@launchchair/agent 0.4.11 → 0.5.0

package/local-bridge.mjs

@@ -15,9 +15,10 @@ import os from "node:os";
 import path from "node:path";
 import process from "node:process";
 import { fileURLToPath } from "node:url";
+import { resolveProjectWorkspace } from "./project-workspace.mjs";
 import { buildRunnerCommand, parseRunnerCommand } from "./runner-command.mjs";
 
-const VERSION = "0.4.11";
+const VERSION = "0.5.0";
 const CLIENT_TYPES = ["codex", "chatgpt", "claude", "claude_code", "other"];
 const AGENT_SCRIPT_DIR = path.dirname(fileURLToPath(import.meta.url));
 const CONFIG_DIR = process.env.LAUNCHCHAIR_CONFIG_DIR?.trim()
@@ -130,10 +131,10 @@ Optional env:
   AGENT_MOCK_RESPONSE            If set, skips runner command and returns this payload
   OPENAI_API_KEY                 Enables built-in ChatGPT runner fallback
   ANTHROPIC_API_KEY              Enables built-in Claude runner fallback
-  LC_AGENT_CODEX_CWD             Folder codex-runner should build in (default: bridge cwd)
+  LC_AGENT_CODEX_CWD             Legacy search candidate; Git origin must match the project
   LC_AGENT_CODEX_SANDBOX         read-only|workspace-write|danger-full-access (default: workspace-write)
   LC_AGENT_CODEX_MODEL           Optional Codex model override
-  LC_AGENT_CLAUDE_CODE_CWD       Folder claude-code-runner should build in (default: bridge cwd)
+  LC_AGENT_CLAUDE_CODE_CWD       Legacy search candidate; Git origin must match the project
   LC_AGENT_CLAUDE_CODE_MODEL     Optional Claude Code model override
   LC_AGENT_CLAUDE_CODE_ALLOWED_TOOLS
                                  Optional Claude Code allowedTools list
@@ -193,6 +194,10 @@ const config = {
     gpt: normalizeTarget(env("LC_AGENT_ROUTER_GPT_TARGET", "codex"), "codex"),
     codex: normalizeTarget(env("LC_AGENT_ROUTER_CODEX_TARGET", "codex"), "codex"),
   },
+  legacyRepoPaths: {
+    codex: env("LC_AGENT_CODEX_CWD", savedConfigValue("codexCwd", process.cwd())),
+    claudeCode: env("LC_AGENT_CLAUDE_CODE_CWD", savedConfigValue("claudeCodeCwd", process.cwd())),
+  },
   runnerCommands: {
     generic: env("LC_AGENT_RUNNER_CMD"),
     gpt: env("LC_AGENT_RUNNER_CMD_GPT"),
@@ -347,6 +352,25 @@ async function claimNextRun() {
   return payload?.run ?? null;
 }
 
+function resolveWorkspaceForRun(run) {
+  const target = getTargetForRun(run) === "claude_code" ? "claude_code" : "codex";
+  const legacyPath = target === "claude_code" ? config.legacyRepoPaths.claudeCode : config.legacyRepoPaths.codex;
+  const context = run?.runnerWorkspace && typeof run.runnerWorkspace === "object" && !Array.isArray(run.runnerWorkspace)
+    ? run.runnerWorkspace
+    : {};
+  return {
+    target,
+    workspace: resolveProjectWorkspace({
+      configDir: CONFIG_DIR,
+      configPath: CONFIG_PATH,
+      projectId: String(run?.projectId ?? context.projectId ?? "").trim(),
+      repository: context.repository,
+      requireRepository: context.requiresRepository === true,
+      legacyPaths: [legacyPath],
+    }),
+  };
+}
+
 async function executeRunner(run) {
   if (config.mockResponse) {
     return {
@@ -367,6 +391,9 @@ async function executeRunner(run) {
   }
   const command = buildRunnerCommand(commandTemplate, run);
   const parsedCommand = parseRunnerCommand(command);
+  const resolved = resolveWorkspaceForRun(run);
+  const workspaceEnvName = resolved.target === "claude_code" ? "LC_AGENT_CLAUDE_CODE_CWD" : "LC_AGENT_CODEX_CWD";
+  log(`Workspace ${resolved.workspace.path} (${resolved.workspace.source})`);
 
   const startedAt = Date.now();
   return new Promise((resolve, reject) => {
@@ -375,6 +402,7 @@ async function executeRunner(run) {
       stdio: ["pipe", "pipe", "pipe"],
       env: {
         ...process.env,
+        ...(resolved.workspace.source === "isolated" && run?.runnerWorkspace?.requiresRepository !== true ? { LC_AGENT_CODEX_SKIP_GIT_CHECK: "1" } : {}),
         LC_AGENT_RUN_ID: String(run.id ?? ""),
         LC_AGENT_PROJECT_ID: String(run.projectId ?? ""),
         LC_AGENT_PHASE_KEY: String(run.phaseKey ?? ""),
@@ -382,6 +410,7 @@ async function executeRunner(run) {
         LC_AGENT_CARD_ID: String(run.cardId ?? ""),
         LC_AGENT_PROMPT_MODE: String(run.promptMode ?? ""),
         LC_AGENT_RUN_TYPE: String(run.runType ?? ""),
+        [workspaceEnvName]: resolved.workspace.path,
       },
     });
 
@@ -415,6 +444,7 @@ async function executeRunner(run) {
         durationMs,
         usedMock: false,
         target: getTargetForRun(run),
+        workspace: resolved.workspace,
       });
     });
 
@@ -480,6 +510,7 @@ async function runOnce() {
         runIntent: run.runIntent ?? "initial",
         attemptNumber: run.attemptNumber ?? 1,
         maxAttempts: run.maxAttempts ?? 1,
+        localWorkspaceSource: execution.workspace?.source ?? null,
       },
       error: null,
     });

package/mcp-bridge-server.mjs

@@ -17,9 +17,11 @@ import os from "node:os";
 import path from "node:path";
 import process from "node:process";
 import { fileURLToPath } from "node:url";
+import { resolveProjectWorkspace } from "./project-workspace.mjs";
 import { buildRunnerCommand, parseRunnerCommand } from "./runner-command.mjs";
+import { createMcpCapabilities, EXTRA_MCP_TOOLS, MCP_WORKFLOW_INSTRUCTIONS, VALIDATION_GATE_SCHEMA } from "./mcp-capabilities.mjs";
 
-const VERSION = "0.4.11";
+const VERSION = "0.5.0";
 const SERVER_NAME = "launchchair-agent-mcp";
 const AGENT_SCRIPT_DIR = path.dirname(fileURLToPath(import.meta.url));
 const CONFIG_DIR = process.env.LAUNCHCHAIR_CONFIG_DIR?.trim()
@@ -107,7 +109,7 @@ function builtInRunnerCommand(target) {
 }
 
 const config = {
-  baseUrl: env("LAUNCHCHAIR_BASE_URL", savedConfigValue("baseUrl", "http://localhost:3000")).replace(/\/+$/, ""),
+  baseUrl: env("LAUNCHCHAIR_BASE_URL", savedConfigValue("baseUrl", "https://www.launchchair.io")).replace(/\/+$/, ""),
   token: env("LAUNCHCHAIR_AGENT_TOKEN", env("LAUNCHCHAIR_API_KEY", savedConfigValue("agentToken"))),
   projectId: env("LAUNCHCHAIR_PROJECT_ID", savedConfigValue("projectId")) || null,
   clientName: env("LC_AGENT_CLIENT_NAME", "MCP Bridge"),
@@ -128,76 +130,58 @@ const config = {
     codexTarget: env("LC_AGENT_RUNNER_CMD_CODEX", builtInRunnerCommand("codex")),
     claudeCode: env("LC_AGENT_RUNNER_CMD_CLAUDE_CODE", builtInRunnerCommand("claude_code")),
   },
-  localRepoPaths: {
+  legacyRepoPaths: {
     codex: env("LC_AGENT_CODEX_CWD", savedConfigValue("codexCwd", process.cwd())),
     claudeCode: env("LC_AGENT_CLAUDE_CODE_CWD", savedConfigValue("claudeCodeCwd", process.cwd())),
   },
 };
 
-if (!config.token) {
-  // eslint-disable-next-line no-console
-  console.error(
-    `Missing LaunchChair Agent API token. Run "launchchair login" or set LAUNCHCHAIR_AGENT_TOKEN. Checked ${CONFIG_PATH}.`,
-  );
-  process.exit(1);
-}
-
-if (
-  !config.mockResponse &&
-  !config.runnerCommands.generic &&
-  !config.runnerCommands.gpt &&
-  !config.runnerCommands.codex &&
-  !config.runnerCommands.chatgpt &&
-  !config.runnerCommands.claude &&
-  !config.runnerCommands.codexTarget &&
-  !config.runnerCommands.claudeCode
-) {
-  // eslint-disable-next-line no-console
-  console.error(
-    "No runner command configured for MCP bridge. Set LC_AGENT_RUNNER_CMD* or use the built-in Codex/Claude Code runners; ChatGPT/Claude API fallbacks require provider API keys.",
-  );
-  process.exit(1);
-}
+let statusPromise = null;
+let initialized = false;
+const capabilities = createMcpCapabilities({ config, configPath: CONFIG_PATH, api, resolveProjectId, onAuthChange: () => { statusPromise = null; if (initialized) writeMessage({ jsonrpc: "2.0", method: "notifications/tools/list_changed" }); } });
 
 async function api(path, { method = "GET", body } = {}) {
+  const token = capabilities.currentToken();
+  if (!token) {
+    const error = new Error("Login required. Call launchchair_login and complete browser approval.");
+    error.status = 401;
+    error.payload = { code: "login_required", nextTool: "launchchair_login" };
+    throw error;
+  }
   const response = await fetch(`${config.baseUrl}${path}`, {
     method,
     headers: {
-      Authorization: `Bearer ${config.token}`,
+      Authorization: `Bearer ${token}`,
       "Content-Type": "application/json",
     },
     body: body === undefined ? undefined : JSON.stringify(body),
+    signal: AbortSignal.timeout(30_000),
   });
 
-  let payload = null;
-  try {
-    payload = await response.json();
-  } catch (_error) {
-    payload = null;
-  }
+  const raw = await response.text();
+  let payload;
+  try { payload = raw ? JSON.parse(raw) : null; } catch { payload = { content: raw, contentType: response.headers.get("content-type") }; }
 
   if (!response.ok) {
     const err = new Error(`HTTP ${response.status}: ${String(payload?.error ?? response.statusText ?? "Request failed")}`);
     err.status = response.status;
-    err.payload = payload;
+    err.payload = response.status === 401 ? { ...payload, code: "login_required", nextTool: "launchchair_login" } : payload;
     err.retryAfterSeconds = Number.parseInt(response.headers.get("retry-after") ?? "", 10) || null;
     throw err;
   }
   return payload;
 }
 
-let statusPromise = null;
-
 function loadStatus() {
   if (!statusPromise) {
-    statusPromise = api("/api/agent/v1").catch(() => null);
+    statusPromise = api("/api/agent/v1").catch(() => { statusPromise = null; return null; });
   }
   return statusPromise;
 }
 
 function serverInstructions(status) {
   const featureInstructions = String(status?.capabilities?.mcpServerInstructions ?? "").trim();
-  return featureInstructions ? `${BASE_SERVER_INSTRUCTIONS} ${featureInstructions}` : BASE_SERVER_INSTRUCTIONS;
+  return `${BASE_SERVER_INSTRUCTIONS} ${featureInstructions} ${MCP_WORKFLOW_INSTRUCTIONS}`;
 }
 
 function targetForRun(run) {
@@ -227,6 +211,32 @@ function commandForRun(run) {
   return config.runnerCommands.generic;
 }
 
+function runnerTargetForRun(run) {
+  return targetForRun(run) === "claude_code" ? "claude_code" : "codex";
+}
+
+function resolveWorkspaceForRun(run, workspaceContext = run?.runnerWorkspace, options = {}) {
+  const target = runnerTargetForRun(run);
+  const context = workspaceContext && typeof workspaceContext === "object" && !Array.isArray(workspaceContext)
+    ? workspaceContext
+    : {};
+  const legacyPath = target === "claude_code" ? config.legacyRepoPaths.claudeCode : config.legacyRepoPaths.codex;
+  return resolveProjectWorkspace({
+    configDir: CONFIG_DIR,
+    configPath: CONFIG_PATH,
+    projectId: String(run?.projectId ?? context.projectId ?? "").trim(),
+    repository: context.repository,
+    requireRepository: context.requiresRepository === true,
+    preferRepository: options.preferRepository === true,
+    legacyPaths: [legacyPath],
+  });
+}
+
+async function getRunnerWorkspaceContext(projectId) {
+  const payload = await api(`/api/agent/v1/projects/${encodeURIComponent(projectId)}/runner-workspace`);
+  return payload?.workspace && typeof payload.workspace === "object" ? payload.workspace : { projectId };
+}
+
 async function executeRunner(run) {
   if (config.mockResponse) {
     return {
@@ -245,6 +255,10 @@ async function executeRunner(run) {
   }
   const command = buildRunnerCommand(template, run);
   const parsedCommand = parseRunnerCommand(command);
+  const workspace = resolveWorkspaceForRun(run);
+  const workspaceEnvName = runnerTargetForRun(run) === "claude_code"
+    ? "LC_AGENT_CLAUDE_CODE_CWD"
+    : "LC_AGENT_CODEX_CWD";
   const startedAt = Date.now();
   return new Promise((resolve, reject) => {
     const child = spawn(parsedCommand.file, parsedCommand.args, {
@@ -259,6 +273,8 @@ async function executeRunner(run) {
         LC_AGENT_CARD_ID: String(run.cardId ?? ""),
         LC_AGENT_PROMPT_MODE: String(run.promptMode ?? ""),
         LC_AGENT_RUN_TYPE: String(run.runType ?? ""),
+        [workspaceEnvName]: workspace.path,
+        ...(workspace.source === "isolated" && run?.runnerWorkspace?.requiresRepository !== true ? { LC_AGENT_CODEX_SKIP_GIT_CHECK: "1" } : {}),
       },
     });
     let stdout = "";
@@ -286,6 +302,7 @@ async function executeRunner(run) {
         stderr,
         exitCode: code ?? 0,
         durationMs,
+        workspace,
       });
     });
     child.stdin.write(String(run.prompt ?? ""));
@@ -314,6 +331,7 @@ async function claimNextRun(args = {}) {
     method: "POST",
     body: {
       projectId,
+      ...(args.runId ? { runId: String(args.runId) } : {}),
       clientName: String(args.clientName ?? "").trim() || config.clientName,
       clientType: normalizeTarget(args.clientType ?? config.clientType, "other"),
       clientVersion: String(args.clientVersion ?? "").trim() || config.clientVersion,
@@ -366,6 +384,7 @@ async function runOnce(args = {}) {
           runIntent: run.runIntent ?? "initial",
           attemptNumber: run.attemptNumber ?? 1,
           maxAttempts: run.maxAttempts ?? 1,
+          localWorkspaceSource: execution.workspace?.source ?? null,
         },
         error: null,
         clientName: String(args.clientName ?? "").trim() || config.clientName,
@@ -520,22 +539,35 @@ async function continueProjectLoop(args = {}) {
     typeof args.ideaSnapshot === "object" && args.ideaSnapshot !== null && !Array.isArray(args.ideaSnapshot)
       ? args.ideaSnapshot
       : null;
-  const runnerTarget = config.modeTargets.codex === "claude_code" ? "claude_code" : config.modeTargets.codex;
-  const localRepoPath =
-    runnerTarget === "claude_code" ? config.localRepoPaths.claudeCode : config.localRepoPaths.codex;
-  const agentSetup = {
-    localRepoPath,
-    runnerTarget,
-    clientType: config.clientType,
-    ...(typeof args.agentSetup === "object" && args.agentSetup !== null && !Array.isArray(args.agentSetup)
-      ? args.agentSetup
-      : {}),
+  const runnerTarget = config.modeTargets.codex === "claude_code" ? "claude_code" : "codex";
+  let runnerWorkspaceContext = await getRunnerWorkspaceContext(projectId);
+  let agentSetup = null;
+  const refreshAgentSetup = async () => {
+    runnerWorkspaceContext = await getRunnerWorkspaceContext(projectId);
+    const resolvedAgentWorkspace = resolveWorkspaceForRun(
+      { projectId, promptMode: "codex", runnerWorkspace: runnerWorkspaceContext },
+      runnerWorkspaceContext,
+      { preferRepository: true },
+    );
+    agentSetup = {
+      ...(typeof args.agentSetup === "object" && args.agentSetup !== null && !Array.isArray(args.agentSetup)
+        ? args.agentSetup
+        : {}),
+      localRepoPath: resolvedAgentWorkspace.path,
+      runnerTarget,
+      clientType: config.clientType,
+      repositoryVerified: resolvedAgentWorkspace.repositoryVerified,
+      repositoryUrl: resolvedAgentWorkspace.repositoryUrl,
+      workspaceSource: resolvedAgentWorkspace.source,
+    };
   };
+  await refreshAgentSetup();
   let pendingChoiceSelections = normalizeChoiceSelections(args);
   const steps = [];
   let final = null;
 
   for (let index = 0; index < maxSteps; index += 1) {
+    if (index > 0) await refreshAgentSetup();
     const loop = await api(`/api/agent/v1/projects/${encodeURIComponent(projectId)}/loop/continue`, {
       method: "POST",
       body: {
@@ -553,13 +585,19 @@ async function continueProjectLoop(args = {}) {
       break;
     }
 
-    const run = loop.run;
-    if (!run?.id || !run?.prompt) {
-      final = loop;
+    const claimed = loop.run?.id ? await claimNextRun({ ...args, projectId, runId: loop.run.id }) : null;
+    if (!claimed) {
+      final = { ...loop, run: loop.run?.id ? { id: loop.run.id } : null, message: "Run already claimed; do not execute it again." };
+      break;
+    }
+    const run = { ...claimed, runnerWorkspace: claimed.runnerWorkspace ?? loop.runnerWorkspace ?? runnerWorkspaceContext };
+    let execution;
+    try { execution = await executeRunner(run); }
+    catch (error) {
+      await completeRun({ runId: run.id, status: "failed", error: error.message, resultRaw: error.stdout || error.stderr || "" });
+      final = { status: "stopped_after_failed_step", projectId, runId: run.id, message: error.message };
       break;
     }
-
-    const execution = await executeRunner(run);
     const stdout = String(execution.stdout ?? "").trim();
     const stderr = String(execution.stderr ?? "").trim();
     const output = stdout || stderr;
@@ -578,6 +616,7 @@ async function continueProjectLoop(args = {}) {
           attemptNumber: run.attemptNumber ?? 1,
           maxAttempts: run.maxAttempts ?? 1,
           projectLoopStep: index + 1,
+          localWorkspaceSource: execution.workspace?.source ?? null,
         },
         error: null,
         clientName: String(args.clientName ?? "").trim() || config.clientName,
@@ -645,6 +684,7 @@ async function createProject(args = {}) {
   delete createArgs.maxSteps;
   delete createArgs.fullLoop;
   delete createArgs.buildMaxSteps;
+  delete createArgs.executionMode;
   const body = {
     ...createArgs,
     name: String(args.name ?? args.projectName ?? "").trim(),
@@ -671,6 +711,8 @@ async function createProject(args = {}) {
     return payload;
   }
 
+  if (args.executionMode !== "local_runner") return { ...payload, next: { ...payload.next, tool: "launchchair_next_step", arguments: { projectId, stopPhaseKey: "build", completionTarget: fullLoop ? "phase_complete" : "build_board_ready" }, execution: "host", instructions: MCP_WORKFLOW_INSTRUCTIONS } };
+
   const planning = await continueProjectLoop({
     projectId,
     stopPhaseKey: "build",
@@ -949,8 +991,8 @@ function annotateTool(tool) {
     ...tool,
     annotations: {
       ...(tool.annotations ?? {}),
-      readOnlyHint: READ_ONLY_TOOLS.has(tool.name),
-      destructiveHint: false,
+      readOnlyHint: tool.annotations?.readOnlyHint ?? READ_ONLY_TOOLS.has(tool.name),
+      destructiveHint: tool.annotations?.destructiveHint ?? false,
       openWorldHint: true,
     },
   };
@@ -966,7 +1008,12 @@ function mergeToolOverrides(baseTools, overrides) {
       merged.push(override);
     }
   }
-  return merged.map(annotateTool);
+  return merged.map((tool) => {
+    if (["launchchair_create_project", "launchchair_create_feature_project"].includes(tool.name)) tool = { ...tool, inputSchema: { ...tool.inputSchema, properties: { ...tool.inputSchema.properties, idempotencyKey: { type: "string" }, ideaIntent: { type: "string", enum: ["preserve", "explore"], default: "preserve" }, validationGate: VALIDATION_GATE_SCHEMA, executionMode: { type: "string", enum: ["host", "local_runner"], default: "host" } } } };
+    if (tool.name === "launchchair_claim_next_run") tool = { ...tool, inputSchema: { ...tool.inputSchema, properties: { ...tool.inputSchema.properties, runId: { type: "string" } } } };
+    if (tool.name === "launchchair_continue_project") tool = { ...tool, description: "Advance one step in the current host agent by default. Only use executionMode=local_runner to spawn a separate local CLI.", inputSchema: { ...tool.inputSchema, properties: { ...tool.inputSchema.properties, executionMode: { type: "string", enum: ["host", "local_runner"], default: "host" } } } };
+    return annotateTool(tool);
+  });
 }
 
 function writeMessage(obj) {
@@ -1009,7 +1056,7 @@ async function handleRpc(request) {
     writeResult(id, {
       protocolVersion: "2024-11-05",
       capabilities: {
-        tools: {},
+        tools: { listChanged: true },
       },
       serverInfo: {
         name: SERVER_NAME,
@@ -1021,6 +1068,7 @@ async function handleRpc(request) {
   }
 
   if (method === "notifications/initialized") {
+    initialized = true;
     return;
   }
 
@@ -1029,7 +1077,7 @@ async function handleRpc(request) {
     const overrides = Array.isArray(status?.capabilities?.mcpToolOverrides)
       ? status.capabilities.mcpToolOverrides
       : [];
-    const tools = mergeToolOverrides(MCP_TOOLS, overrides);
+    const tools = mergeToolOverrides([...MCP_TOOLS, ...EXTRA_MCP_TOOLS], overrides);
     writeResult(id, { tools });
     return;
   }
@@ -1039,9 +1087,13 @@ async function handleRpc(request) {
     const toolName = String(params.name ?? "");
     const args = typeof params.arguments === "object" && params.arguments ? params.arguments : {};
     try {
+      if (EXTRA_MCP_TOOLS.some((tool) => tool.name === toolName)) {
+        writeResult(id, textResult(await capabilities.dispatch(toolName, args)));
+        return;
+      }
       if (toolName === "launchchair_status") {
         const status = await api("/api/agent/v1");
-        writeResult(id, textResult(status));
+        writeResult(id, textResult({ ...status, authenticated: true }));
         return;
       }
       if (toolName === "launchchair_create_project") {
@@ -1090,7 +1142,7 @@ async function handleRpc(request) {
         return;
       }
       if (toolName === "launchchair_continue_project") {
-        const payload = await continueProjectLoop(args);
+        const payload = args.executionMode === "local_runner" ? await continueProjectLoop(args) : await capabilities.dispatch("launchchair_next_step", { ...args, executionMode: undefined, maxSteps: undefined });
         writeResult(id, textResult(payload));
         return;
       }