feat: /friend start tauri app

src/commands/friend/friend.tsx

@@ -14,15 +14,12 @@ import {
 } from '../../friend/tauri-launcher.js'
 import type { LocalJSXCommandOnDone, CommandResultDisplay } from '../../types/command.js'
 
-const FRIEND_FRONTEND_DIR = '../../components/friend/frontend'
 const FRIEND_URL = 'http://127.0.0.1:3456/friend/'
 
-function logger() {
-  return {
-    info: (msg: string) => console.log(`[Friend] ${msg}`),
-    warn: (msg: string) => console.warn(`[Friend] ${msg}`),
-  }
-}
+const logger = () => ({
+  info: (msg: string) => console.log(`[Friend] ${msg}`),
+  warn: (msg: string) => console.warn(`[Friend] ${msg}`),
+})
 
 type Page = 'status' | 'help'
 
@@ -44,7 +41,7 @@ export async function call(
         </Box>
       )
     }
-    launchTauri(FRIEND_FRONTEND_DIR, logger())
+    await launchTauri(logger())
     return (
       <Box flexDirection="column">
         <Text>Starting Friend VRM companion...</Text>

src/components/friend/frontend/src-tauri/src/lib.rs

@@ -1,6 +1,17 @@
+use tauri::Manager;
+
+#[cfg_attr(mobile, tauri::mobile_entry_point)]
 pub fn run() {
-    tauri::Builder::default()
+    let builder = tauri::Builder::default()
         .plugin(tauri_plugin_opener::init())
-        .run(tauri::generate_context!())
+        .setup(|app| {
+            let window = app.get_webview_window("main").unwrap();
+            // Force load from HTTP server so WebGL works properly in webkit2gtk
+            window.eval("window.location.replace('http://127.0.0.1:3456/friend/')")
+                .map_err(|e| eprintln!("Failed to set URL: {e}")).ok();
+            Ok(())
+        });
+
+    builder.run(tauri::generate_context!())
         .expect("error while running tauri application");
-}
+}

src/friend/tauri-launcher.ts

@@ -1,80 +1,150 @@
 /**
  * Tauri desktop app process management for Friend (VersperClaw native).
  *
- * Builds and launches the VRM desktop pet as a native Tauri window
- * (transparent, always-on-top) instead of a browser tab.
+ * Launches the VRM desktop pet as a native Tauri window.
+ * Also manages a background server on port 3456 that serves the frontend.
  */
-import { spawn } from 'node:child_process';
+import { spawn, execSync } from 'node:child_process';
 import path from 'node:path';
 import { existsSync } from 'node:fs';
 
 let tauriProcess: ReturnType<typeof spawn> | null = null;
+let serverProcess: ReturnType<typeof spawn> | null = null;
 
-/**
- * Launch the Friend Tauri desktop window.
- * Uses the release binary (built via `npx tauri build`).
- * The binary loads the pre-built frontend from frontend/dist/.
- */
-export function launchTauri(appDir: string, log: { info: (msg: string) => void; warn: (msg: string) => void }) {
-  const releaseBinary = path.join(appDir, 'src-tauri', 'target', 'release', 'versperclaw-friend')
-  const debugBinary = path.join(appDir, 'src-tauri', 'target', 'debug', 'versperclaw-friend')
-
-  const binary = existsSync(releaseBinary)
-    ? releaseBinary
-    : existsSync(debugBinary)
-    ? debugBinary
+const SERVER_PORT = 3456
+const FRIEND_URL = `http://127.0.0.1:${SERVER_PORT}/friend/`
+
+/** Check if the friend server is already listening. */
+function isServerRunning(): boolean {
+  try {
+    const result = execSync(
+      `curl -s -o /dev/null -w "%{http_code}" http://127.0.0.1:${SERVER_PORT}/friend/ 2>/dev/null || true`,
+      { timeout: 3000, encoding: 'utf-8' },
+    )
+    return result.trim() === '200'
+  } catch {
+    return false
+  }
+}
+
+/** Wait until the server responds, up to `timeoutMs`. */
+function waitForServer(timeoutMs = 10_000): Promise<boolean> {
+  const start = Date.now()
+  return new Promise((resolve) => {
+    const check = () => {
+      if (isServerRunning()) return resolve(true)
+      if (Date.now() - start > timeoutMs) return resolve(false)
+      setTimeout(check, 500)
+    }
+    check()
+  })
+}
+
+/** Start the backend server if not already running. */
+async function ensureServer(log: { info: (msg: string) => void; warn: (msg: string) => void }) {
+  if (isServerRunning()) {
+    log.info('[Friend] Server already running')
+    return true
+  }
+
+  const cwd = process.cwd()
+  const serverEntry = path.join(cwd, 'src', 'server', 'index.ts')
+  if (!existsSync(serverEntry)) {
+    log.warn(`[Friend] Server entry not found: ${serverEntry}`)
+    return false
+  }
+
+  log.info('[Friend] Starting background server...')
+  serverProcess = spawn('bun', ['run', serverEntry, `--port=${SERVER_PORT}`], {
+    cwd,
+    stdio: 'pipe',
+    detached: true,
+  })
+
+  serverProcess.stderr?.on('data', (data: Buffer) => {
+    for (const line of data.toString().split('\n').filter(Boolean)) {
+      log.info(`[Friend:server] ${line}`)
+    }
+  })
+
+  const ok = await waitForServer()
+  if (!ok) log.warn('[Friend] Server did not become ready in time')
+  return ok
+}
+
+export async function launchTauri(log: { info: (msg: string) => void; warn: (msg: string) => void }) {
+  // 1. Ensure the server is running (Tauri loads from HTTP)
+  const serverOk = await ensureServer(log)
+  if (!serverOk) {
+    log.warn('[Friend] Cannot start — server failed to start')
+    return
+  }
+
+  // 2. Find the Tauri binary
+  const cwd = process.cwd()
+  const releaseBinary = path.join(cwd, 'src', 'components', 'friend', 'frontend', 'src-tauri', 'target', 'release', 'versperclaw-friend')
+  const debugBinary = path.join(cwd, 'src', 'components', 'friend', 'frontend', 'src-tauri', 'target', 'debug', 'versperclaw-friend')
+
+  const binary = existsSync(releaseBinary) ? releaseBinary
+    : existsSync(debugBinary) ? debugBinary
     : null
 
   if (!binary) {
-    log.warn(`Friend: Tauri binary not found. Run \`cd ${appDir} && npx tauri build\` first.`)
-    log.warn(`Looking for: ${releaseBinary}`)
+    log.warn(`[Friend] Tauri binary not found. Run \`cd src/components/friend/frontend && npx tauri build\` first.`)
+    log.warn(`[Friend] Looked for: ${releaseBinary}`)
     return
   }
 
-  log.info(`Starting Friend desktop window from ${binary}`)
+  // 3. Launch the Tauri desktop window (it connects to FRIEND_URL via lib.rs)
+  log.info(`[Friend] Starting desktop window from ${binary}`)
 
   tauriProcess = spawn(binary, [], {
-    cwd: appDir,
+    cwd: path.dirname(binary),
     stdio: 'pipe',
     detached: true,
   })
 
   tauriProcess.stdout?.on('data', (data: Buffer) => {
     for (const line of data.toString().split('\n').filter(Boolean)) {
-      log.info(line)
+      log.info(`[Friend:tauri] ${line}`)
     }
   })
 
   tauriProcess.stderr?.on('data', (data: Buffer) => {
     for (const line of data.toString().split('\n').filter(Boolean)) {
-      log.info(line)
+      log.info(`[Friend:tauri] ${line}`)
     }
   })
 
   tauriProcess.on('error', (err: Error) => {
-    log.warn(`Friend Tauri error: ${err.message}`)
+    log.warn(`[Friend] Tauri error: ${err.message}`)
     tauriProcess = null
   })
 
   tauriProcess.on('exit', (code: number | null) => {
-    log.info(`Friend Tauri exited (code: ${code})`)
+    log.info(`[Friend] Tauri exited (code: ${code})`)
     tauriProcess = null
   })
 }
 
 export function stopTauri(log: { info: (msg: string) => void }) {
   if (tauriProcess) {
-    log.info('Stopping Friend Tauri window...')
+    log.info('[Friend] Stopping Tauri window...')
     const proc = tauriProcess
     tauriProcess = null
-
     proc.kill('SIGTERM')
     setTimeout(() => {
       try { if (!proc.killed) proc.kill('SIGKILL') } catch { /* ignore */ }
     }, 3000)
   }
+  if (serverProcess) {
+    log.info('[Friend] Stopping background server...')
+    const proc = serverProcess
+    serverProcess = null
+    proc.kill('SIGTERM')
+  }
 }
 
 export function getTauriProcess(): ReturnType<typeof spawn> | null {
   return tauriProcess
-}
+}

src/server/index.ts

@@ -440,7 +440,7 @@ export function startServer(port = PORT, host = HOST) {
     // Try launching Tauri desktop window first
     const _srcDir = path.dirname(fileURLToPath(import.meta.url))
     const friendFrontendDir = path.resolve(_srcDir, '..', '..', 'src', 'components', 'friend', 'frontend')
-    launchTauri(friendFrontendDir, {
+    launchTauri({
       info: (msg: string) => console.log(`[Friend] ${msg}`),
       warn: (msg: string) => console.warn(`[Friend] ${msg}`),
     })

src/skills/bundled/friendPrompt.ts

@@ -26,20 +26,16 @@ function buildVrmSystemPrompt(): string {
 
 export function registerFriendPromptSkill(): void {
   registerBundledSkill({
-    name: 'friend',
+    name: 'friend-vrm',
     description:
-      'Enable VRM desktop companion mode — opens a 3D avatar window and adds avatar awareness, emotions, and screen observation to the conversation.',
-    userInvocable: true,
+      'Add VRM avatar context to the conversation — system prompt for avatar emotions and companion behavior. Called automatically when Friend is enabled.',
+    userInvocable: false,
     isEnabled: () => getPrefs().enabled ?? false,
     async getPromptForCommand() {
-      // Enable friend prefs when the skill is invoked
-      const prefs = updatePrefs({ enabled: true })
-      const moodIndex = (prefs as any)._moodIndex ?? 60
-
       return [
         {
           type: 'text' as const,
-          text: `[VRM avatar frontend launched at ${FRIEND_URL}. Tell the user the browser window is open and ready!]\n\n${buildVrmSystemPrompt()}`,
+          text: buildVrmSystemPrompt(),
         },
       ]
     },