@rehpic/vcli 0.1.0-beta.51.1 → 0.1.0-beta.53.1

package/dist/index.js

@@ -285,7 +285,7 @@ var init_default_browser_id = __esm({
 // ../../node_modules/.pnpm/run-applescript@7.1.0/node_modules/run-applescript/index.js
 import process5 from "process";
 import { promisify as promisify4 } from "util";
-import { execFile as execFile4, execFileSync } from "child_process";
+import { execFile as execFile4, execFileSync as execFileSync2 } from "child_process";
 async function runAppleScript(script, { humanReadableOutput = true, signal } = {}) {
   if (process5.platform !== "darwin") {
     throw new Error("macOS only");
@@ -736,9 +736,9 @@ var init_open = __esm({
 });
 
 // src/index.ts
-import { readFileSync as readFileSync2 } from "fs";
+import { readFileSync as readFileSync3 } from "fs";
 import { readFile as readFile2 } from "fs/promises";
-import { dirname, extname, join as join2 } from "path";
+import { dirname, extname, join as join3 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { config as loadEnv } from "dotenv";
 import { Command } from "commander";
@@ -1058,9 +1058,11 @@ function printOutput(data, json = false) {
 import { mkdir, readFile, rm, writeFile } from "fs/promises";
 import { homedir } from "os";
 import path from "path";
-var SESSION_ROOT = path.join(homedir(), ".vector");
+function getSessionRoot() {
+  return process.env.VECTOR_HOME?.trim() || path.join(homedir(), ".vector");
+}
 function getSessionPath(profile = "default") {
-  return path.join(SESSION_ROOT, `cli-${profile}.json`);
+  return path.join(getSessionRoot(), `cli-${profile}.json`);
 }
 async function readSession(profile = "default") {
   try {
@@ -1076,7 +1078,7 @@ async function readSession(profile = "default") {
   }
 }
 async function writeSession(session, profile = "default") {
-  await mkdir(SESSION_ROOT, { recursive: true });
+  await mkdir(getSessionRoot(), { recursive: true });
   await writeFile(
     getSessionPath(profile),
     `${JSON.stringify(session, null, 2)}
@@ -1096,114 +1098,404 @@ function createEmptySession() {
 
 // src/bridge-service.ts
 import { ConvexHttpClient as ConvexHttpClient2 } from "convex/browser";
-import { execSync } from "child_process";
+import { execFileSync, execSync as execSync2 } from "child_process";
 import {
-  existsSync,
+  existsSync as existsSync2,
   mkdirSync,
-  readFileSync,
+  readFileSync as readFileSync2,
   writeFileSync,
   unlinkSync
 } from "fs";
-import { homedir as homedir2, hostname, platform } from "os";
-import { join } from "path";
+import { homedir as homedir3, hostname, platform } from "os";
+import { join as join2 } from "path";
 import { randomUUID } from "crypto";
-var CONFIG_DIR = join(homedir2(), ".vector");
-var BRIDGE_CONFIG_FILE = join(CONFIG_DIR, "bridge.json");
-var PID_FILE = join(CONFIG_DIR, "bridge.pid");
-var LIVE_ACTIVITIES_CACHE = join(CONFIG_DIR, "live-activities.json");
-var LAUNCHAGENT_DIR = join(homedir2(), "Library", "LaunchAgents");
-var LAUNCHAGENT_PLIST = join(LAUNCHAGENT_DIR, "com.vector.bridge.plist");
-var LAUNCHAGENT_LABEL = "com.vector.bridge";
-var HEARTBEAT_INTERVAL_MS = 3e4;
-var COMMAND_POLL_INTERVAL_MS = 5e3;
-var PROCESS_DISCOVERY_INTERVAL_MS = 6e4;
-function loadBridgeConfig() {
-  if (!existsSync(BRIDGE_CONFIG_FILE)) return null;
+
+// src/agent-adapters.ts
+import { execSync, spawn } from "child_process";
+import { existsSync, readFileSync, readdirSync, statSync } from "fs";
+import { homedir as homedir2, userInfo } from "os";
+import { basename, join } from "path";
+var MAX_DISCOVERED_FILES_PER_PROVIDER = 30;
+function discoverAttachableSessions() {
+  return dedupeSessions([
+    ...discoverCodexSessions(),
+    ...discoverClaudeSessions()
+  ]);
+}
+async function launchProviderSession(provider, cwd, prompt2) {
+  if (provider === "codex") {
+    const stdout2 = await runCommand("codex", ["exec", "--json", prompt2], cwd);
+    return parseCodexRunResult(stdout2, cwd, "codex exec --json");
+  }
+  const stdout = await runCommand(
+    "claude",
+    ["-p", "--output-format", "json", prompt2],
+    cwd
+  );
+  return parseClaudeRunResult(stdout, cwd, "claude -p --output-format json");
+}
+async function resumeProviderSession(provider, sessionKey, cwd, prompt2) {
+  if (provider === "codex") {
+    const stdout2 = await runCommand(
+      "codex",
+      ["exec", "resume", "--json", sessionKey, prompt2],
+      cwd
+    );
+    return parseCodexRunResult(stdout2, cwd, "codex exec resume --json");
+  }
+  const stdout = await runCommand(
+    "claude",
+    ["-p", "--resume", sessionKey, "--output-format", "json", prompt2],
+    cwd
+  );
+  return parseClaudeRunResult(
+    stdout,
+    cwd,
+    "claude -p --resume --output-format json"
+  );
+}
+async function runCommand(command, args, cwd) {
+  const child = spawn(command, args, {
+    cwd,
+    env: { ...process.env },
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+  let stdout = "";
+  let stderr = "";
+  child.stdout.on("data", (chunk) => {
+    stdout += chunk.toString();
+  });
+  child.stderr.on("data", (chunk) => {
+    stderr += chunk.toString();
+  });
+  return await new Promise((resolve, reject) => {
+    child.on("error", reject);
+    child.on("close", (code) => {
+      if (code === 0) {
+        resolve(stdout);
+        return;
+      }
+      const detail = stderr.trim() || stdout.trim() || `exit code ${code}`;
+      reject(new Error(`${command} failed: ${detail}`));
+    });
+  });
+}
+function discoverCodexSessions() {
+  return listRecentJsonlFiles(getCodexSessionsDir()).flatMap((file) => {
+    const entries = readJsonLines(file);
+    let sessionKey;
+    let cwd;
+    let title;
+    let lastUserMessage;
+    let lastAssistantMessage;
+    for (const entry of entries) {
+      if (entry.type === "session_meta") {
+        sessionKey = asString(entry.payload?.id) ?? sessionKey;
+        cwd = asString(entry.payload?.cwd) ?? cwd;
+      }
+      if (entry.type === "event_msg" && entry.payload?.type === "user_message") {
+        lastUserMessage = asString(entry.payload?.message) ?? lastUserMessage;
+      }
+      if (entry.type === "response_item" && entry.payload?.type === "message" && entry.payload?.role === "user") {
+        lastUserMessage = extractCodexResponseText(entry.payload?.content) ?? lastUserMessage;
+      }
+      if (entry.type === "event_msg" && entry.payload?.type === "agent_message") {
+        lastAssistantMessage = asString(entry.payload?.message) ?? lastAssistantMessage;
+      }
+      if (entry.type === "response_item" && entry.payload?.type === "message" && entry.payload?.role === "assistant") {
+        lastAssistantMessage = extractCodexResponseText(entry.payload?.content) ?? lastAssistantMessage;
+      }
+    }
+    if (!sessionKey) {
+      return [];
+    }
+    title = summarizeTitle(lastUserMessage ?? lastAssistantMessage, cwd);
+    const gitInfo = cwd ? getGitInfo(cwd) : {};
+    return [
+      {
+        provider: "codex",
+        providerLabel: "Codex",
+        sessionKey,
+        cwd,
+        ...gitInfo,
+        title,
+        mode: "observed",
+        status: "observed",
+        supportsInboundMessages: true
+      }
+    ];
+  });
+}
+function discoverClaudeSessions() {
+  return listRecentJsonlFiles(getClaudeSessionsDir()).flatMap((file) => {
+    const entries = readJsonLines(file);
+    let sessionKey;
+    let cwd;
+    let branch;
+    let model;
+    let lastUserMessage;
+    let lastAssistantMessage;
+    for (const entry of entries) {
+      sessionKey = asString(entry.sessionId) ?? sessionKey;
+      cwd = asString(entry.cwd) ?? cwd;
+      branch = asString(entry.gitBranch) ?? branch;
+      if (entry.type === "user") {
+        lastUserMessage = extractClaudeUserText(entry.message) ?? lastUserMessage;
+      }
+      if (entry.type === "assistant") {
+        model = asString(entry.message?.model) ?? model;
+        lastAssistantMessage = extractClaudeAssistantText(entry.message) ?? lastAssistantMessage;
+      }
+    }
+    if (!sessionKey) {
+      return [];
+    }
+    const gitInfo = cwd ? getGitInfo(cwd) : {};
+    return [
+      {
+        provider: "claude_code",
+        providerLabel: "Claude",
+        sessionKey,
+        cwd,
+        repoRoot: gitInfo.repoRoot,
+        branch: branch ?? gitInfo.branch,
+        title: summarizeTitle(lastUserMessage ?? lastAssistantMessage, cwd),
+        model,
+        mode: "observed",
+        status: "observed",
+        supportsInboundMessages: true
+      }
+    ];
+  });
+}
+function parseCodexRunResult(stdout, cwd, launchCommand) {
+  let sessionKey;
+  const responseParts = [];
+  for (const line of stdout.split("\n").map((part) => part.trim()).filter(Boolean)) {
+    const payload = tryParseJson(line);
+    if (!payload) continue;
+    if (payload.type === "thread.started") {
+      sessionKey = asString(payload.thread_id) ?? sessionKey;
+    }
+    if (payload.type === "item.completed" && payload.item?.type === "agent_message" && typeof payload.item.text === "string") {
+      responseParts.push(payload.item.text.trim());
+    }
+    if (payload.type === "response_item" && payload.payload?.type === "message" && payload.payload?.role === "assistant") {
+      const responseText2 = extractCodexResponseText(payload.payload?.content);
+      if (responseText2) {
+        responseParts.push(responseText2);
+      }
+    }
+  }
+  if (!sessionKey) {
+    throw new Error("Codex did not return a thread id");
+  }
+  const gitInfo = getGitInfo(cwd);
+  const responseText = responseParts.filter(Boolean).join("\n\n") || void 0;
+  return {
+    provider: "codex",
+    providerLabel: "Codex",
+    sessionKey,
+    cwd,
+    ...gitInfo,
+    title: summarizeTitle(void 0, cwd),
+    mode: "managed",
+    status: "waiting",
+    supportsInboundMessages: true,
+    responseText,
+    launchCommand
+  };
+}
+function parseClaudeRunResult(stdout, cwd, launchCommand) {
+  const payload = stdout.split("\n").map((line) => tryParseJson(line)).filter(Boolean).pop();
+  if (!payload) {
+    throw new Error("Claude did not return JSON output");
+  }
+  const sessionKey = asString(payload.session_id);
+  if (!sessionKey) {
+    throw new Error("Claude did not return a session id");
+  }
+  const gitInfo = getGitInfo(cwd);
+  const model = firstObjectKey(payload.modelUsage);
+  return {
+    provider: "claude_code",
+    providerLabel: "Claude",
+    sessionKey,
+    cwd,
+    ...gitInfo,
+    title: summarizeTitle(void 0, cwd),
+    model,
+    mode: "managed",
+    status: "waiting",
+    supportsInboundMessages: true,
+    responseText: asString(payload.result) ?? void 0,
+    launchCommand
+  };
+}
+function listRecentJsonlFiles(root) {
+  if (!existsSync(root)) {
+    return [];
+  }
+  const files = collectJsonlFiles(root);
+  return files.map((path3) => ({ path: path3, mtimeMs: statSync(path3).mtimeMs })).sort((a, b) => b.mtimeMs - a.mtimeMs).slice(0, MAX_DISCOVERED_FILES_PER_PROVIDER).map((file) => file.path);
+}
+function getCodexSessionsDir() {
+  return join(getRealHomeDir(), ".codex", "sessions");
+}
+function getClaudeSessionsDir() {
+  return join(getRealHomeDir(), ".claude", "projects");
+}
+function getRealHomeDir() {
   try {
-    return JSON.parse(readFileSync(BRIDGE_CONFIG_FILE, "utf-8"));
+    const realHome = userInfo().homedir?.trim();
+    if (realHome) {
+      return realHome;
+    }
   } catch {
-    return null;
   }
+  return homedir2();
 }
-function saveBridgeConfig(config) {
-  if (!existsSync(CONFIG_DIR)) mkdirSync(CONFIG_DIR, { recursive: true });
-  writeFileSync(BRIDGE_CONFIG_FILE, JSON.stringify(config, null, 2));
+function collectJsonlFiles(root) {
+  const files = [];
+  for (const entry of readdirSync(root, { withFileTypes: true })) {
+    const path3 = join(root, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...collectJsonlFiles(path3));
+      continue;
+    }
+    if (entry.isFile() && entry.name.endsWith(".jsonl")) {
+      files.push(path3);
+    }
+  }
+  return files;
 }
-function discoverLocalProcesses() {
-  const processes = [];
-  const patterns = [
-    {
-      grep: "[c]laude",
-      provider: "claude_code",
-      label: "Claude",
-      prefix: "claude"
-    },
-    { grep: "[c]odex", provider: "codex", label: "Codex", prefix: "codex" }
-  ];
-  for (const { grep, provider, label, prefix } of patterns) {
-    try {
-      const ps = execSync(
-        `ps aux | grep -E '${grep}' | grep -v vector-bridge | grep -v grep`,
-        { encoding: "utf-8", timeout: 5e3 }
-      );
-      for (const line of ps.trim().split("\n").filter(Boolean)) {
-        const pid = line.split(/\s+/)[1];
-        if (!pid) continue;
-        let cwd;
-        try {
-          cwd = execSync(
-            `lsof -p ${pid} 2>/dev/null | grep cwd | awk '{print $NF}'`,
-            { encoding: "utf-8", timeout: 3e3 }
-          ).trim() || void 0;
-        } catch {
-        }
-        const gitInfo = cwd ? getGitInfo(cwd) : {};
-        processes.push({
-          provider,
-          providerLabel: label,
-          localProcessId: pid,
-          sessionKey: `${prefix}-${pid}`,
-          cwd,
-          ...gitInfo,
-          mode: "observed",
-          status: "observed",
-          supportsInboundMessages: false
-        });
-      }
-    } catch {
+function readJsonLines(path3) {
+  return readFileSync(path3, "utf-8").split("\n").map((line) => line.trim()).filter(Boolean).map(tryParseJson).filter(Boolean);
+}
+function tryParseJson(value) {
+  try {
+    return JSON.parse(value);
+  } catch {
+    return null;
+  }
+}
+function dedupeSessions(sessions) {
+  const seen = /* @__PURE__ */ new Set();
+  return sessions.filter((session) => {
+    const key = `${session.provider}:${session.sessionKey}`;
+    if (seen.has(key)) {
+      return false;
     }
+    seen.add(key);
+    return true;
+  });
+}
+function extractCodexResponseText(content) {
+  if (!Array.isArray(content)) {
+    return void 0;
   }
-  return processes;
+  const texts = content.map(
+    (item) => item && typeof item === "object" && "text" in item ? asString(item.text) : void 0
+  ).filter(Boolean);
+  return texts.length > 0 ? texts.join("\n\n") : void 0;
+}
+function extractClaudeUserText(message) {
+  if (!message || typeof message !== "object") {
+    return void 0;
+  }
+  const content = message.content;
+  if (typeof content === "string") {
+    return content;
+  }
+  return void 0;
+}
+function extractClaudeAssistantText(message) {
+  if (!message || typeof message !== "object") {
+    return void 0;
+  }
+  const content = message.content;
+  if (!Array.isArray(content)) {
+    return void 0;
+  }
+  const texts = content.map(
+    (item) => item && typeof item === "object" && "text" in item ? asString(item.text) : void 0
+  ).filter(Boolean);
+  return texts.length > 0 ? texts.join("\n\n") : void 0;
+}
+function summarizeTitle(message, cwd) {
+  if (message) {
+    return truncate(message.replace(/\s+/g, " ").trim(), 96);
+  }
+  if (cwd) {
+    return basename(cwd);
+  }
+  return "Local session";
+}
+function truncate(value, maxLength) {
+  return value.length > maxLength ? `${value.slice(0, maxLength - 3).trimEnd()}...` : value;
+}
+function firstObjectKey(value) {
+  if (!value || typeof value !== "object") {
+    return void 0;
+  }
+  const [firstKey] = Object.keys(value);
+  return firstKey;
+}
+function asString(value) {
+  return typeof value === "string" && value.trim() ? value : void 0;
 }
 function getGitInfo(cwd) {
   try {
-    const branch = execSync("git rev-parse --abbrev-ref HEAD", {
+    const repoRoot = execSync("git rev-parse --show-toplevel", {
       encoding: "utf-8",
       cwd,
       timeout: 3e3
     }).trim();
-    const repoRoot = execSync("git rev-parse --show-toplevel", {
+    const branch = execSync("git rev-parse --abbrev-ref HEAD", {
       encoding: "utf-8",
       cwd,
       timeout: 3e3
     }).trim();
-    return { branch, repoRoot };
+    return {
+      repoRoot: repoRoot || void 0,
+      branch: branch || void 0
+    };
   } catch {
     return {};
   }
 }
-function generateReply(userMessage) {
-  const lower = userMessage.toLowerCase().trim();
-  if (["hey", "hi", "hello"].includes(lower)) {
-    return "Hey! I'm running on your local machine via the Vector bridge. What would you like me to work on?";
-  }
-  if (lower.includes("status") || lower.includes("progress")) {
-    return "I'm making good progress. Currently reviewing the changes and running tests.";
-  }
-  if (lower.includes("stop") || lower.includes("cancel")) {
-    return "Understood \u2014 wrapping up the current step.";
+
+// src/bridge-service.ts
+var CONFIG_DIR = process.env.VECTOR_HOME?.trim() || join2(homedir3(), ".vector");
+var BRIDGE_CONFIG_FILE = join2(CONFIG_DIR, "bridge.json");
+var PID_FILE = join2(CONFIG_DIR, "bridge.pid");
+var LIVE_ACTIVITIES_CACHE = join2(CONFIG_DIR, "live-activities.json");
+var LAUNCHAGENT_DIR = join2(homedir3(), "Library", "LaunchAgents");
+var LAUNCHAGENT_PLIST = join2(LAUNCHAGENT_DIR, "com.vector.bridge.plist");
+var LAUNCHAGENT_LABEL = "com.vector.bridge";
+var LEGACY_MENUBAR_LAUNCHAGENT_LABEL = "com.vector.menubar";
+var LEGACY_MENUBAR_LAUNCHAGENT_PLIST = join2(
+  LAUNCHAGENT_DIR,
+  `${LEGACY_MENUBAR_LAUNCHAGENT_LABEL}.plist`
+);
+var HEARTBEAT_INTERVAL_MS = 3e4;
+var COMMAND_POLL_INTERVAL_MS = 5e3;
+var PROCESS_DISCOVERY_INTERVAL_MS = 6e4;
+function loadBridgeConfig() {
+  if (!existsSync2(BRIDGE_CONFIG_FILE)) return null;
+  try {
+    return JSON.parse(readFileSync2(BRIDGE_CONFIG_FILE, "utf-8"));
+  } catch {
+    return null;
   }
-  return `Got it \u2014 "${userMessage}". I'll incorporate that into my current work.`;
+}
+function saveBridgeConfig(config) {
+  if (!existsSync2(CONFIG_DIR)) mkdirSync(CONFIG_DIR, { recursive: true });
+  writeFileSync(BRIDGE_CONFIG_FILE, JSON.stringify(config, null, 2));
+}
+function writeLiveActivitiesCache(activities) {
+  if (!existsSync2(CONFIG_DIR)) mkdirSync(CONFIG_DIR, { recursive: true });
+  writeFileSync(LIVE_ACTIVITIES_CACHE, JSON.stringify(activities, null, 2));
 }
 var BridgeService = class {
   constructor(config) {
@@ -1233,45 +1525,50 @@ var BridgeService = class {
     }
   }
   async handleCommand(cmd) {
+    const claimed = await this.client.mutation(
+      api.agentBridge.bridgePublic.claimCommand,
+      {
+        deviceId: this.config.deviceId,
+        deviceSecret: this.config.deviceSecret,
+        commandId: cmd._id
+      }
+    );
+    if (!claimed) {
+      return;
+    }
     console.log(`  ${cmd.kind}: ${cmd._id}`);
-    if (cmd.kind === "message" && cmd.liveActivityId) {
-      const payload = cmd.payload;
-      const body = payload?.body ?? "";
-      console.log(`  > "${body}"`);
-      const reply = generateReply(body);
-      await this.client.mutation(
-        api.agentBridge.bridgePublic.postAgentMessage,
-        {
-          deviceId: this.config.deviceId,
-          deviceSecret: this.config.deviceSecret,
-          liveActivityId: cmd.liveActivityId,
-          role: "assistant",
-          body: reply
-        }
-      );
-      console.log(`  < "${reply.slice(0, 60)}..."`);
+    try {
+      switch (cmd.kind) {
+        case "message":
+          await this.handleMessageCommand(cmd);
+          await this.completeCommand(cmd._id, "delivered");
+          return;
+        case "launch":
+          await this.handleLaunchCommand(cmd);
+          await this.completeCommand(cmd._id, "delivered");
+          return;
+        default:
+          throw new Error(`Unsupported bridge command: ${cmd.kind}`);
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Unknown bridge error";
+      console.error(`  ! ${message}`);
+      await this.postCommandError(cmd, message);
+      await this.completeCommand(cmd._id, "failed");
     }
-    await this.client.mutation(api.agentBridge.bridgePublic.completeCommand, {
-      deviceId: this.config.deviceId,
-      deviceSecret: this.config.deviceSecret,
-      commandId: cmd._id,
-      status: "delivered"
-    });
   }
   async reportProcesses() {
-    const processes = discoverLocalProcesses();
+    const processes = discoverAttachableSessions();
     for (const proc of processes) {
       try {
-        await this.client.mutation(api.agentBridge.bridgePublic.reportProcess, {
-          deviceId: this.config.deviceId,
-          deviceSecret: this.config.deviceSecret,
-          ...proc
-        });
+        await this.reportProcess(proc);
       } catch {
       }
     }
     if (processes.length > 0) {
-      console.log(`[${ts()}] Discovered ${processes.length} local process(es)`);
+      console.log(
+        `[${ts()}] Discovered ${processes.length} attachable session(s)`
+      );
     }
   }
   async refreshLiveActivities() {
@@ -1283,7 +1580,7 @@ var BridgeService = class {
           deviceSecret: this.config.deviceSecret
         }
       );
-      writeFileSync(LIVE_ACTIVITIES_CACHE, JSON.stringify(activities, null, 2));
+      writeLiveActivitiesCache(activities);
     } catch {
     }
   }
@@ -1295,7 +1592,7 @@ var BridgeService = class {
     console.log(`  Convex:  ${this.config.convexUrl}`);
     console.log(`  PID:     ${process.pid}`);
     console.log("");
-    if (!existsSync(CONFIG_DIR)) mkdirSync(CONFIG_DIR, { recursive: true });
+    if (!existsSync2(CONFIG_DIR)) mkdirSync(CONFIG_DIR, { recursive: true });
     writeFileSync(PID_FILE, String(process.pid));
     await this.heartbeat();
     await this.reportProcesses();
@@ -1333,6 +1630,10 @@ var BridgeService = class {
         unlinkSync(PID_FILE);
       } catch {
       }
+      try {
+        writeLiveActivitiesCache([]);
+      } catch {
+      }
       process.exit(0);
     };
     process.on("SIGINT", shutdown);
@@ -1340,21 +1641,205 @@ var BridgeService = class {
     await new Promise(() => {
     });
   }
+  async handleMessageCommand(cmd) {
+    if (!cmd.liveActivityId) {
+      throw new Error("Message command is missing liveActivityId");
+    }
+    const payload = cmd.payload;
+    const body = payload?.body?.trim();
+    if (!body) {
+      throw new Error("Message command is missing a body");
+    }
+    const process9 = cmd.process;
+    if (!process9 || !process9.supportsInboundMessages || !process9.sessionKey || !process9.cwd || !isBridgeProvider(process9.provider)) {
+      throw new Error("No resumable local session is attached to this issue");
+    }
+    console.log(`  > "${truncateForLog(body)}"`);
+    await this.reportProcess({
+      provider: process9.provider,
+      providerLabel: process9.providerLabel ?? providerLabel(process9.provider),
+      sessionKey: process9.sessionKey,
+      cwd: process9.cwd,
+      repoRoot: process9.repoRoot,
+      branch: process9.branch,
+      title: process9.title,
+      model: process9.model,
+      mode: "managed",
+      status: "waiting",
+      supportsInboundMessages: true
+    });
+    await this.updateLiveActivity(cmd.liveActivityId, {
+      status: "active",
+      processId: process9._id,
+      title: cmd.liveActivity?.title ?? process9.title
+    });
+    const result = await resumeProviderSession(
+      process9.provider,
+      process9.sessionKey,
+      process9.cwd,
+      body
+    );
+    const processId = await this.reportProcess(result);
+    if (result.responseText) {
+      await this.postAgentMessage(
+        cmd.liveActivityId,
+        "assistant",
+        result.responseText
+      );
+      console.log(`  < "${truncateForLog(result.responseText)}"`);
+    }
+    await this.updateLiveActivity(cmd.liveActivityId, {
+      processId,
+      status: "waiting_for_input",
+      latestSummary: summarizeMessage(result.responseText),
+      title: cmd.liveActivity?.title ?? process9.title
+    });
+  }
+  async handleLaunchCommand(cmd) {
+    if (!cmd.liveActivityId) {
+      throw new Error("Launch command is missing liveActivityId");
+    }
+    const payload = cmd.payload;
+    const workspacePath = payload?.workspacePath?.trim();
+    if (!workspacePath) {
+      throw new Error("Launch command is missing workspacePath");
+    }
+    if (!payload?.provider || !isBridgeProvider(payload.provider)) {
+      throw new Error("Launch command is missing a supported provider");
+    }
+    const provider = payload.provider;
+    const issueKey = payload.issueKey ?? cmd.liveActivity?.issueKey ?? "ISSUE";
+    const issueTitle = payload.issueTitle ?? cmd.liveActivity?.issueTitle ?? "Untitled issue";
+    const prompt2 = buildLaunchPrompt(issueKey, issueTitle, workspacePath);
+    await this.updateLiveActivity(cmd.liveActivityId, {
+      status: "active",
+      latestSummary: `Launching ${providerLabel(provider)} in ${workspacePath}`,
+      delegatedRunId: payload.delegatedRunId,
+      launchStatus: "launching",
+      title: `${providerLabel(provider)} on ${this.config.displayName}`
+    });
+    await this.postAgentMessage(
+      cmd.liveActivityId,
+      "status",
+      `Launching ${providerLabel(provider)} in ${workspacePath}`
+    );
+    const result = await launchProviderSession(provider, workspacePath, prompt2);
+    const processId = await this.reportProcess({
+      ...result,
+      title: `${issueKey}: ${issueTitle}`
+    });
+    await this.updateLiveActivity(cmd.liveActivityId, {
+      processId,
+      status: "waiting_for_input",
+      latestSummary: summarizeMessage(result.responseText),
+      delegatedRunId: payload.delegatedRunId,
+      launchStatus: "running",
+      title: `${providerLabel(provider)} on ${this.config.displayName}`
+    });
+    if (result.responseText) {
+      await this.postAgentMessage(
+        cmd.liveActivityId,
+        "assistant",
+        result.responseText
+      );
+      console.log(`  < "${truncateForLog(result.responseText)}"`);
+    }
+  }
+  async reportProcess(process9) {
+    const {
+      provider,
+      providerLabel: providerLabel2,
+      localProcessId,
+      sessionKey,
+      cwd,
+      repoRoot,
+      branch,
+      title,
+      model,
+      mode,
+      status,
+      supportsInboundMessages
+    } = process9;
+    return await this.client.mutation(
+      api.agentBridge.bridgePublic.reportProcess,
+      {
+        deviceId: this.config.deviceId,
+        deviceSecret: this.config.deviceSecret,
+        provider,
+        providerLabel: providerLabel2,
+        localProcessId,
+        sessionKey,
+        cwd,
+        repoRoot,
+        branch,
+        title,
+        model,
+        mode,
+        status,
+        supportsInboundMessages
+      }
+    );
+  }
+  async updateLiveActivity(liveActivityId, args) {
+    await this.client.mutation(
+      api.agentBridge.bridgePublic.updateLiveActivityState,
+      {
+        deviceId: this.config.deviceId,
+        deviceSecret: this.config.deviceSecret,
+        liveActivityId,
+        ...args
+      }
+    );
+  }
+  async postAgentMessage(liveActivityId, role, body) {
+    await this.client.mutation(api.agentBridge.bridgePublic.postAgentMessage, {
+      deviceId: this.config.deviceId,
+      deviceSecret: this.config.deviceSecret,
+      liveActivityId,
+      role,
+      body
+    });
+  }
+  async completeCommand(commandId, status) {
+    await this.client.mutation(api.agentBridge.bridgePublic.completeCommand, {
+      deviceId: this.config.deviceId,
+      deviceSecret: this.config.deviceSecret,
+      commandId,
+      status
+    });
+  }
+  async postCommandError(cmd, errorMessage) {
+    if (cmd.kind === "launch" && cmd.liveActivityId) {
+      const payload = cmd.payload;
+      await this.updateLiveActivity(cmd.liveActivityId, {
+        status: "failed",
+        latestSummary: errorMessage,
+        delegatedRunId: payload?.delegatedRunId,
+        launchStatus: "failed"
+      });
+      await this.postAgentMessage(cmd.liveActivityId, "status", errorMessage);
+      return;
+    }
+    if (cmd.kind === "message" && cmd.liveActivityId) {
+      await this.postAgentMessage(cmd.liveActivityId, "status", errorMessage);
+      await this.updateLiveActivity(cmd.liveActivityId, {
+        status: "waiting_for_input",
+        latestSummary: errorMessage
+      });
+    }
+  }
 };
-async function setupBridgeDevice(convexUrl, userId) {
-  const client = new ConvexHttpClient2(convexUrl);
+async function setupBridgeDevice(client, convexUrl, userId) {
   const deviceKey = `${hostname()}-${randomUUID().slice(0, 8)}`;
-  const deviceSecret = randomUUID();
   const displayName = `${process.env.USER ?? "user"}'s ${platform() === "darwin" ? "Mac" : "machine"}`;
   const result = await client.mutation(
-    api.agentBridge.bridgePublic.setupDevice,
+    api.agentBridge.mutations.registerBridgeDevice,
     {
-      userId,
       deviceKey,
-      deviceSecret,
       displayName,
       hostname: hostname(),
       platform: platform(),
+      serviceType: "foreground",
       cliVersion: "0.1.0",
       capabilities: ["codex", "claude_code"]
     }
@@ -1362,7 +1847,7 @@ async function setupBridgeDevice(convexUrl, userId) {
   const config = {
     deviceId: result.deviceId,
     deviceKey,
-    deviceSecret,
+    deviceSecret: result.deviceSecret,
     userId,
     displayName,
     convexUrl,
@@ -1371,11 +1856,43 @@ async function setupBridgeDevice(convexUrl, userId) {
   saveBridgeConfig(config);
   return config;
 }
+function buildLaunchPrompt(issueKey, issueTitle, workspacePath) {
+  return [
+    `You are working on Vector issue ${issueKey}: ${issueTitle}.`,
+    `The repository is already checked out at ${workspacePath}.`,
+    "Inspect the codebase, identify the relevant implementation area, and start the work.",
+    "In your first reply, summarize your plan and the first concrete step you are taking."
+  ].join("\n\n");
+}
+function summarizeMessage(message) {
+  if (!message) {
+    return void 0;
+  }
+  return message.length > 120 ? `${message.slice(0, 117).trimEnd()}...` : message;
+}
+function truncateForLog(message) {
+  return message.length > 80 ? `${message.slice(0, 77).trimEnd()}...` : message;
+}
+function isBridgeProvider(provider) {
+  return provider === "codex" || provider === "claude_code";
+}
+function providerLabel(provider) {
+  return provider === "codex" ? "Codex" : "Claude";
+}
 function installLaunchAgent(vcliPath) {
   if (platform() !== "darwin") {
     console.error("LaunchAgent is macOS only. Use systemd on Linux.");
     return;
   }
+  const programArguments = getLaunchAgentProgramArguments(vcliPath);
+  const environmentVariables = [
+    "  <key>PATH</key>",
+    "  <string>/usr/local/bin:/opt/homebrew/bin:/usr/bin:/bin</string>",
+    ...process.env.VECTOR_HOME?.trim() ? [
+      "  <key>VECTOR_HOME</key>",
+      `  <string>${process.env.VECTOR_HOME.trim()}</string>`
+    ] : []
+  ].join("\n");
   const plist = `<?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
 <plist version="1.0">
@@ -1383,11 +1900,7 @@ function installLaunchAgent(vcliPath) {
   <key>Label</key>
   <string>${LAUNCHAGENT_LABEL}</string>
   <key>ProgramArguments</key>
-  <array>
-    <string>${vcliPath}</string>
-    <string>service</string>
-    <string>run</string>
-  </array>
+  ${programArguments}
   <key>RunAtLoad</key>
   <true/>
   <key>KeepAlive</key>
@@ -1398,145 +1911,225 @@ function installLaunchAgent(vcliPath) {
   <string>${CONFIG_DIR}/bridge.err.log</string>
   <key>EnvironmentVariables</key>
   <dict>
-    <key>PATH</key>
-    <string>/usr/local/bin:/opt/homebrew/bin:/usr/bin:/bin</string>
+${environmentVariables}
   </dict>
 </dict>
 </plist>`;
-  const menuBarCandidates = [
-    join(CONFIG_DIR, "VectorMenuBar"),
-    "/usr/local/bin/VectorMenuBar",
-    join(homedir2(), ".local", "bin", "VectorMenuBar")
-  ];
-  const menuBarBinary = menuBarCandidates.find((p) => existsSync(p));
-  if (menuBarBinary) {
-    const menuBarPlist = `<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
-<plist version="1.0">
-<dict>
-  <key>Label</key>
-  <string>com.vector.menubar</string>
-  <key>ProgramArguments</key>
-  <array>
-    <string>${menuBarBinary}</string>
-  </array>
-  <key>RunAtLoad</key>
-  <true/>
-  <key>KeepAlive</key>
-  <false/>
-</dict>
-</plist>`;
-    const menuBarPlistPath = join(LAUNCHAGENT_DIR, "com.vector.menubar.plist");
-    writeFileSync(menuBarPlistPath, menuBarPlist);
-    try {
-      execSync(`launchctl load ${menuBarPlistPath}`, { stdio: "pipe" });
-      console.log("Menu bar helper installed.");
-    } catch {
-    }
-  }
-  if (!existsSync(LAUNCHAGENT_DIR)) {
+  if (!existsSync2(LAUNCHAGENT_DIR)) {
     mkdirSync(LAUNCHAGENT_DIR, { recursive: true });
   }
+  removeLegacyMenuBarLaunchAgent();
   writeFileSync(LAUNCHAGENT_PLIST, plist);
   console.log(`Installed LaunchAgent: ${LAUNCHAGENT_PLIST}`);
 }
+function getLaunchAgentProgramArguments(vcliPath) {
+  const args = resolveCliInvocation(vcliPath);
+  return [
+    "<array>",
+    ...args.map((arg) => `    <string>${arg}</string>`),
+    "    <string>service</string>",
+    "    <string>run</string>",
+    "  </array>"
+  ].join("\n");
+}
+function resolveCliInvocation(vcliPath) {
+  if (vcliPath.endsWith(".js")) {
+    return [process.execPath, vcliPath];
+  }
+  if (vcliPath.endsWith(".ts")) {
+    const tsxPath = join2(
+      import.meta.dirname ?? process.cwd(),
+      "..",
+      "..",
+      "..",
+      "node_modules",
+      ".bin",
+      "tsx"
+    );
+    if (existsSync2(tsxPath)) {
+      return [tsxPath, vcliPath];
+    }
+  }
+  return [vcliPath];
+}
 function loadLaunchAgent() {
-  try {
-    execSync(`launchctl load ${LAUNCHAGENT_PLIST}`, { stdio: "inherit" });
+  if (runLaunchctl(["bootstrap", launchctlGuiDomain(), LAUNCHAGENT_PLIST])) {
+    runLaunchctl([
+      "kickstart",
+      "-k",
+      `${launchctlGuiDomain()}/${LAUNCHAGENT_LABEL}`
+    ]);
     console.log(
       "LaunchAgent loaded. Bridge will start automatically on login."
     );
-  } catch {
-    console.error("Failed to load LaunchAgent");
+    return;
+  }
+  if (runLaunchctl([
+    "kickstart",
+    "-k",
+    `${launchctlGuiDomain()}/${LAUNCHAGENT_LABEL}`
+  ]) || runLaunchctl(["load", LAUNCHAGENT_PLIST])) {
+    console.log(
+      "LaunchAgent loaded. Bridge will start automatically on login."
+    );
+    return;
   }
+  console.error("Failed to load LaunchAgent");
 }
 function unloadLaunchAgent() {
-  try {
-    execSync(`launchctl unload ${LAUNCHAGENT_PLIST}`, { stdio: "inherit" });
+  if (runLaunchctl(["bootout", `${launchctlGuiDomain()}/${LAUNCHAGENT_LABEL}`]) || runLaunchctl(["bootout", launchctlGuiDomain(), LAUNCHAGENT_PLIST]) || runLaunchctl(["unload", LAUNCHAGENT_PLIST])) {
     console.log("LaunchAgent unloaded.");
-  } catch {
-    console.error("Failed to unload LaunchAgent (may not be loaded)");
+    return true;
   }
+  console.error("Failed to unload LaunchAgent (may not be loaded)");
+  return false;
 }
 function uninstallLaunchAgent() {
   unloadLaunchAgent();
+  removeLegacyMenuBarLaunchAgent();
   try {
     unlinkSync(LAUNCHAGENT_PLIST);
     console.log("LaunchAgent removed.");
   } catch {
   }
 }
-var MENUBAR_BINARY = join(CONFIG_DIR, "VectorMenuBar");
-var MENUBAR_SWIFT_URL = "https://raw.githubusercontent.com/xrehpicx/vector/main/cli/macos/VectorMenuBar.swift";
-async function ensureMenuBarBinary() {
-  if (platform() !== "darwin") return null;
-  if (existsSync(MENUBAR_BINARY)) return MENUBAR_BINARY;
+var MENUBAR_PID_FILE = join2(CONFIG_DIR, "menubar.pid");
+function removeLegacyMenuBarLaunchAgent() {
+  if (platform() !== "darwin" || !existsSync2(LEGACY_MENUBAR_LAUNCHAGENT_PLIST)) {
+    return;
+  }
+  try {
+    execSync2(`launchctl unload ${LEGACY_MENUBAR_LAUNCHAGENT_PLIST}`, {
+      stdio: "pipe"
+    });
+  } catch {
+  }
   try {
-    execSync("which swiftc", { stdio: "pipe" });
+    unlinkSync(LEGACY_MENUBAR_LAUNCHAGENT_PLIST);
   } catch {
+  }
+}
+function launchctlGuiDomain() {
+  const uid = typeof process.getuid === "function" ? process.getuid() : typeof process.geteuid === "function" ? process.geteuid() : 0;
+  return `gui/${uid}`;
+}
+function runLaunchctl(args) {
+  try {
+    execFileSync("launchctl", args, {
+      stdio: "ignore"
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function findCliEntrypoint() {
+  const candidates = [
+    join2(import.meta.dirname ?? "", "index.js"),
+    join2(import.meta.dirname ?? "", "index.ts"),
+    join2(import.meta.dirname ?? "", "..", "dist", "index.js")
+  ];
+  for (const p of candidates) {
+    if (existsSync2(p)) return p;
+  }
+  return null;
+}
+function getCurrentCliInvocation() {
+  const entrypoint = findCliEntrypoint();
+  if (!entrypoint) {
     return null;
   }
-  const localSource = join(
-    process.cwd(),
-    "cli",
-    "macos",
-    "VectorMenuBar.swift"
-  );
-  let swiftSource;
-  if (existsSync(localSource)) {
-    swiftSource = localSource;
-  } else {
-    const downloadPath = join(CONFIG_DIR, "VectorMenuBar.swift");
-    try {
-      execSync(`curl -fsSL "${MENUBAR_SWIFT_URL}" -o "${downloadPath}"`, {
-        stdio: "pipe",
-        timeout: 15e3
-      });
-      swiftSource = downloadPath;
-    } catch {
-      return null;
+  return resolveCliInvocation(entrypoint);
+}
+function findMenuBarExecutable() {
+  const candidates = [
+    join2(
+      import.meta.dirname ?? "",
+      "..",
+      "native",
+      "VectorMenuBar.app",
+      "Contents",
+      "MacOS",
+      "VectorMenuBar"
+    ),
+    join2(
+      import.meta.dirname ?? "",
+      "native",
+      "VectorMenuBar.app",
+      "Contents",
+      "MacOS",
+      "VectorMenuBar"
+    )
+  ];
+  for (const p of candidates) {
+    if (existsSync2(p)) {
+      return p;
     }
   }
+  return null;
+}
+function isKnownMenuBarProcess(pid) {
   try {
-    execSync(
-      `swiftc -o "${MENUBAR_BINARY}" "${swiftSource}" -framework AppKit`,
-      { stdio: "pipe", timeout: 3e4 }
-    );
-    const assetsSource = join(swiftSource, "..", "assets");
-    const assetsDest = join(CONFIG_DIR, "assets");
-    if (existsSync(assetsSource)) {
-      mkdirSync(assetsDest, { recursive: true });
-      for (const f of ["vector-menubar.png", "vector-menubar@2x.png"]) {
-        const src = join(assetsSource, f);
-        if (existsSync(src))
-          writeFileSync(join(assetsDest, f), readFileSync(src));
+    const command = execSync2(`ps -p ${pid} -o args=`, {
+      encoding: "utf-8",
+      timeout: 3e3
+    });
+    return command.includes("menubar.js") || command.includes("menubar.ts") || command.includes("VectorMenuBar");
+  } catch {
+    return false;
+  }
+}
+function killExistingMenuBar() {
+  if (existsSync2(MENUBAR_PID_FILE)) {
+    try {
+      const pid = Number(readFileSync2(MENUBAR_PID_FILE, "utf-8").trim());
+      if (Number.isFinite(pid) && pid > 0 && isKnownMenuBarProcess(pid)) {
+        process.kill(pid, "SIGTERM");
       }
+    } catch {
+    }
+    try {
+      unlinkSync(MENUBAR_PID_FILE);
+    } catch {
     }
-    return MENUBAR_BINARY;
-  } catch {
-    return null;
   }
 }
 async function launchMenuBar() {
   if (platform() !== "darwin") return;
-  const binary = await ensureMenuBarBinary();
-  if (!binary) return;
+  removeLegacyMenuBarLaunchAgent();
+  const executable = findMenuBarExecutable();
+  const cliInvocation = getCurrentCliInvocation();
+  if (!executable || !cliInvocation) return;
+  killExistingMenuBar();
   try {
     const { spawn: spawnChild } = await import("child_process");
-    const child = spawnChild(binary, [], { detached: true, stdio: "ignore" });
+    const child = spawnChild(executable, [], {
+      detached: true,
+      stdio: "ignore",
+      env: {
+        ...process.env,
+        VECTOR_CLI_COMMAND: cliInvocation[0],
+        VECTOR_CLI_ARGS_JSON: JSON.stringify(cliInvocation.slice(1))
+      }
+    });
     child.unref();
-    console.log("Menu bar started.");
+    if (child.pid) {
+      writeFileSync(MENUBAR_PID_FILE, String(child.pid));
+    }
   } catch {
   }
 }
+function stopMenuBar() {
+  killExistingMenuBar();
+}
 function getBridgeStatus() {
   const config = loadBridgeConfig();
   if (!config) return { configured: false, running: false, starting: false };
   let running = false;
   let starting = false;
   let pid;
-  if (existsSync(PID_FILE)) {
-    const pidStr = readFileSync(PID_FILE, "utf-8").trim();
+  if (existsSync2(PID_FILE)) {
+    const pidStr = readFileSync2(PID_FILE, "utf-8").trim();
     pid = Number(pidStr);
     try {
       process.kill(pid, 0);
@@ -1546,22 +2139,20 @@ function getBridgeStatus() {
     }
   }
   if (!running && platform() === "darwin") {
-    try {
-      const result = execSync(
-        `launchctl list ${LAUNCHAGENT_LABEL} 2>/dev/null`,
-        { encoding: "utf-8", timeout: 3e3 }
-      );
-      if (result.includes(LAUNCHAGENT_LABEL)) {
-        starting = true;
-      }
-    } catch {
-    }
+    starting = runLaunchctl(["print", `${launchctlGuiDomain()}/${LAUNCHAGENT_LABEL}`]) || runLaunchctl(["list", LAUNCHAGENT_LABEL]);
   }
   return { configured: true, running, starting, pid, config };
 }
-function stopBridge() {
-  if (!existsSync(PID_FILE)) return false;
-  const pid = Number(readFileSync(PID_FILE, "utf-8").trim());
+function stopBridge(options) {
+  if (options?.includeMenuBar) {
+    killExistingMenuBar();
+  }
+  try {
+    writeLiveActivitiesCache([]);
+  } catch {
+  }
+  if (!existsSync2(PID_FILE)) return false;
+  const pid = Number(readFileSync2(PID_FILE, "utf-8").trim());
   try {
     process.kill(pid, "SIGTERM");
     return true;
@@ -2017,7 +2608,7 @@ var program = new Command();
 function readPackageVersionSync() {
   try {
     const dir = import.meta.dirname ?? dirname(fileURLToPath2(import.meta.url));
-    const raw = readFileSync2(join2(dir, "..", "package.json"), "utf8");
+    const raw = readFileSync3(join3(dir, "..", "package.json"), "utf8");
     return JSON.parse(raw).version ?? "unknown";
   } catch {
     return "unknown";
@@ -3564,6 +4155,7 @@ folderCommand.command("delete <folderId>").action(async (folderId, _options, com
   });
   printOutput(result, runtime.json);
 });
+var VECTOR_HOME = process.env.VECTOR_HOME?.trim() || `${process.env.HOME ?? "~"}/.vector`;
 var serviceCommand = program.command("service").description("Manage the local bridge service");
 serviceCommand.command("start").description("Start the bridge service via LaunchAgent (macOS) or foreground").action(async (_options, command) => {
   const existing = getBridgeStatus();
@@ -3588,7 +4180,7 @@ serviceCommand.command("start").description("Start the bridge service via Launch
       s.stop("Failed");
       throw new Error("Not logged in. Run `vcli auth login` first.");
     }
-    config = await setupBridgeDevice(runtime.convexUrl, user._id);
+    config = await setupBridgeDevice(client, runtime.convexUrl, user._id);
     s.stop(`Device registered: ${config.displayName}`);
   }
   if (osPlatform() === "darwin") {
@@ -3596,7 +4188,6 @@ serviceCommand.command("start").description("Start the bridge service via Launch
     const vcliPath = process.argv[1] ?? "vcli";
     installLaunchAgent(vcliPath);
     loadLaunchAgent();
-    await launchMenuBar();
     s.stop("Bridge service started.");
   } else {
     console.log(
@@ -3618,19 +4209,25 @@ serviceCommand.command("run").description("Run the bridge service in the foregro
     );
     const user = await runQuery(client, api.users.currentUser);
     if (!user) throw new Error("Not logged in. Run `vcli auth login` first.");
-    config = await setupBridgeDevice(runtime.convexUrl, user._id);
+    config = await setupBridgeDevice(client, runtime.convexUrl, user._id);
+  }
+  if (osPlatform() === "darwin") {
+    await launchMenuBar();
   }
   const bridge = new BridgeService(config);
   await bridge.run();
 });
-serviceCommand.command("stop").description("Stop the bridge service and menu bar").action(() => {
+serviceCommand.command("stop").description("Stop the bridge service").action(() => {
+  let unloaded = false;
   if (osPlatform() === "darwin") {
-    unloadLaunchAgent();
+    unloaded = unloadLaunchAgent();
   }
-  if (stopBridge()) {
+  if (stopBridge() || unloaded) {
     console.log("Bridge stopped.");
   } else if (osPlatform() !== "darwin") {
     console.log("Bridge is not running.");
+  } else {
+    console.log("Bridge is not running.");
   }
 });
 serviceCommand.command("status").description("Show bridge service status").action((_options, command) => {
@@ -3646,7 +4243,7 @@ serviceCommand.command("status").description("Show bridge service status").actio
   console.log(`  User:    ${status.config.userId}`);
   const statusLabel = status.running ? `Running (PID ${status.pid})` : status.starting ? "Starting..." : "Not running";
   console.log(`  Status:  ${statusLabel}`);
-  console.log(`  Config:  ~/.vector/bridge.json`);
+  console.log(`  Config:  ${VECTOR_HOME}/bridge.json`);
 });
 serviceCommand.command("install").description("Install the bridge as a system service (macOS LaunchAgent)").action(async (_options, command) => {
   if (osPlatform() !== "darwin") {
@@ -3671,7 +4268,7 @@ serviceCommand.command("install").description("Install the bridge as a system se
       s.stop("Failed");
       throw new Error("Not logged in. Run `vcli auth login` first.");
     }
-    config = await setupBridgeDevice(runtime.convexUrl, user._id);
+    config = await setupBridgeDevice(client, runtime.convexUrl, user._id);
     s.stop(`Device registered: ${config.displayName}`);
   }
   s.start("Installing LaunchAgent...");
@@ -3681,30 +4278,27 @@ serviceCommand.command("install").description("Install the bridge as a system se
   s.start("Starting bridge service...");
   loadLaunchAgent();
   s.stop("Bridge service started");
-  s.start("Launching menu bar...");
-  await launchMenuBar();
-  s.stop("Menu bar ready");
   console.log("");
   console.log(
     "Bridge installed and running. Will start automatically on login."
   );
 });
 serviceCommand.command("uninstall").description("Stop the bridge and uninstall the system service").action(() => {
-  stopBridge();
+  stopBridge({ includeMenuBar: true });
   uninstallLaunchAgent();
+  stopMenuBar();
   console.log("Bridge stopped and service uninstalled.");
 });
 serviceCommand.command("logs").description("Show bridge service logs").action(async () => {
   const fs7 = await import("fs");
-  const os2 = await import("os");
   const p = await import("path");
-  const logPath = p.join(os2.homedir(), ".vector", "bridge.log");
+  const logPath = p.join(VECTOR_HOME, "bridge.log");
   if (fs7.existsSync(logPath)) {
     const content = fs7.readFileSync(logPath, "utf-8");
     const lines = content.split("\n");
     console.log(lines.slice(-50).join("\n"));
   } else {
-    console.log("No log file found at ~/.vector/bridge.log");
+    console.log(`No log file found at ${logPath}`);
   }
 });
 serviceCommand.command("enable").description("Enable bridge to start at login (macOS LaunchAgent)").action(async () => {
@@ -3719,6 +4313,7 @@ serviceCommand.command("enable").description("Enable bridge to start at login (m
 });
 serviceCommand.command("disable").description("Disable bridge from starting at login").action(() => {
   uninstallLaunchAgent();
+  stopMenuBar();
   console.log("Bridge will no longer start at login.");
 });
 var bridgeCommand = program.command("bridge").description("Start/stop the local agent bridge");
@@ -3734,7 +4329,7 @@ bridgeCommand.command("start").description("Register device, install service, an
     );
     const user = await runQuery(client, api.users.currentUser);
     if (!user) throw new Error("Not logged in. Run `vcli auth login` first.");
-    config = await setupBridgeDevice(runtime.convexUrl, user._id);
+    config = await setupBridgeDevice(client, runtime.convexUrl, user._id);
     console.log(
       `Device registered: ${config.displayName} (${config.deviceId})`
     );
@@ -3753,10 +4348,12 @@ bridgeCommand.command("start").description("Register device, install service, an
   }
 });
 bridgeCommand.command("stop").description("Stop the bridge service").action(() => {
+  let unloaded = false;
   if (osPlatform() === "darwin") {
     uninstallLaunchAgent();
+    unloaded = true;
   }
-  if (stopBridge()) {
+  if (stopBridge() || unloaded) {
     console.log("Bridge stopped.");
   } else {
     console.log("Bridge is not running.");