orkestrate 0.1.13 → 0.1.15

package/dist/cli.js

@@ -112,21 +112,64 @@ var init_ui = __esm({
 
 // src/lib/config.ts
 import Conf from "conf";
+import { readFileSync, writeFileSync, existsSync } from "fs";
+import { dirname } from "path";
+import { mkdirSync } from "fs";
 function getServerUrl() {
   return config.get("serverUrl");
 }
+function setConfigWithRetry(key, value, maxAttempts = 5) {
+  for (let attempt = 0; attempt < maxAttempts; attempt++) {
+    try {
+      config.set(key, value);
+      return;
+    } catch (err) {
+      if (err?.code !== "EPERM" && err?.code !== "EBUSY") {
+        throw err;
+      }
+      const delay = 50 * Math.pow(2, attempt);
+      if (attempt < maxAttempts - 1) {
+        const start = Date.now();
+        while (Date.now() - start < delay) {
+        }
+      }
+    }
+  }
+  try {
+    const configPath = config.path;
+    const dir = dirname(configPath);
+    if (!existsSync(dir)) {
+      mkdirSync(dir, { recursive: true });
+    }
+    let currentConfig = {};
+    if (existsSync(configPath)) {
+      try {
+        currentConfig = JSON.parse(readFileSync(configPath, "utf-8"));
+      } catch {
+        currentConfig = {};
+      }
+    }
+    currentConfig[key] = value;
+    writeFileSync(configPath, JSON.stringify(currentConfig, null, 2), "utf-8");
+    return;
+  } catch (fallbackErr) {
+    throw new Error(
+      `Failed to save config after ${maxAttempts} attempts. Original error: ${fallbackErr instanceof Error ? fallbackErr.message : String(fallbackErr)}`
+    );
+  }
+}
 function setCredentials(creds) {
-  config.set("credentials", creds);
+  setConfigWithRetry("credentials", creds);
 }
 function getCredentials() {
   return config.get("credentials");
 }
 function clearCredentials() {
-  config.set("credentials", null);
+  setConfigWithRetry("credentials", null);
 }
 function setActiveWorkspace(id, name) {
-  config.set("activeWorkspaceId", id);
-  config.set("activeWorkspaceName", name);
+  setConfigWithRetry("activeWorkspaceId", id);
+  setConfigWithRetry("activeWorkspaceName", name);
 }
 function getActiveWorkspace() {
   return {
@@ -137,6 +180,64 @@ function getActiveWorkspace() {
 function getConfigPath() {
   return config.path;
 }
+function getUserToolSettings() {
+  return config.get("userToolSettings") || {};
+}
+function setUserToolSettings(settings) {
+  setConfigWithRetry("userToolSettings", settings);
+}
+function getEnabledTools() {
+  const settings = getUserToolSettings();
+  return settings.enabledTools ?? null;
+}
+function getDisabledTools() {
+  const settings = getUserToolSettings();
+  return settings.disabledTools || [];
+}
+function setEnabledTools(tools) {
+  const settings = getUserToolSettings();
+  settings.enabledTools = tools;
+  setUserToolSettings(settings);
+}
+function setDisabledTools(tools) {
+  const settings = getUserToolSettings();
+  settings.disabledTools = tools;
+  setUserToolSettings(settings);
+}
+function isToolAllowed(toolName) {
+  const enabledTools = getEnabledTools();
+  const disabledTools = getDisabledTools();
+  if (enabledTools !== null) {
+    return enabledTools.includes(toolName);
+  }
+  return !disabledTools.includes(toolName);
+}
+function enableTool(toolName) {
+  const enabledTools = getEnabledTools();
+  const disabledTools = getDisabledTools();
+  if (enabledTools !== null) {
+    if (!enabledTools.includes(toolName)) {
+      setEnabledTools([...enabledTools, toolName]);
+    }
+  } else {
+    if (disabledTools.includes(toolName)) {
+      setDisabledTools(disabledTools.filter((t) => t !== toolName));
+    }
+  }
+}
+function disableTool(toolName) {
+  const enabledTools = getEnabledTools();
+  const disabledTools = getDisabledTools();
+  if (enabledTools !== null) {
+    if (enabledTools.includes(toolName)) {
+      setEnabledTools(enabledTools.filter((t) => t !== toolName));
+    }
+  } else {
+    if (!disabledTools.includes(toolName)) {
+      setDisabledTools([...disabledTools, toolName]);
+    }
+  }
+}
 function setGithubTokens(tokens) {
   const creds = getCredentials();
   if (!creds) return;
@@ -145,6 +246,25 @@ function setGithubTokens(tokens) {
   creds.githubExpiresAt = tokens.expiresAt;
   setCredentials(creds);
 }
+function getGithubTokens() {
+  const creds = getCredentials();
+  if (!creds?.githubAccessToken || !creds.githubExpiresAt) return null;
+  return {
+    accessToken: creds.githubAccessToken,
+    refreshToken: creds.githubRefreshToken,
+    expiresAt: creds.githubExpiresAt
+  };
+}
+function getValidGithubToken() {
+  const tokens = getGithubTokens();
+  if (!tokens) return null;
+  const now = Math.floor(Date.now() / 1e3);
+  if (tokens.expiresAt <= now + 60) return null;
+  return tokens.accessToken;
+}
+function hasGithubToken() {
+  return getValidGithubToken() !== null;
+}
 var config;
 var init_config = __esm({
   "src/lib/config.ts"() {
@@ -156,7 +276,8 @@ var init_config = __esm({
         credentials: null,
         activeWorkspaceId: null,
         activeWorkspaceName: null,
-        serverUrl: "https://orkestrate.space"
+        serverUrl: "https://orkestrate.space",
+        userToolSettings: {}
       }
     });
   }
@@ -399,7 +520,7 @@ async function performLogin() {
     });
     if (meRes.ok) {
       const me = await meRes.json();
-      userId = me.id || "";
+      userId = me.user?.id || me.id || "";
     }
   } catch {
   }
@@ -626,10 +747,16 @@ __export(detect_exports, {
   detectTools: () => detectTools,
   getToolNames: () => getToolNames
 });
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
 import { homedir } from "os";
 import { join } from "path";
 import { execSync } from "child_process";
+function getZedConfigPath() {
+  if (process.platform === "win32") {
+    return join(homedir(), "AppData", "Roaming", "Zed", "settings.json");
+  }
+  return join(homedir(), ".config", "zed", "settings.json");
+}
 function detectTools(projectDir = process.cwd()) {
   const tools = [];
   tools.push({
@@ -641,111 +768,197 @@ function detectTools(projectDir = process.cwd()) {
   tools.push({
     name: "opencode",
     displayName: "OpenCode",
-    detected: existsSync(opencodeConfig) || isCommandAvailable("opencode"),
+    detected: existsSync2(opencodeConfig) || isCommandAvailable("opencode"),
     configPath: opencodeConfig
   });
   const cursorConfig = join(projectDir, ".cursor", "mcp.json");
   tools.push({
     name: "cursor",
     displayName: "Cursor",
-    detected: existsSync(join(projectDir, ".cursor")) || existsSync(cursorConfig),
+    detected: existsSync2(join(projectDir, ".cursor")) || existsSync2(cursorConfig),
     configPath: cursorConfig
   });
   const windsurfConfig = join(projectDir, ".windsurf", "mcp.json");
   tools.push({
     name: "windsurf",
     displayName: "Windsurf",
-    detected: existsSync(join(projectDir, ".windsurf")) || existsSync(windsurfConfig),
+    detected: existsSync2(join(projectDir, ".windsurf")) || existsSync2(windsurfConfig),
     configPath: windsurfConfig
   });
   const codexDir = join(homedir(), ".codex");
   tools.push({
     name: "codex",
     displayName: "Codex CLI",
-    detected: isCommandAvailable("codex") || existsSync(codexDir)
+    detected: isCommandAvailable("codex") || existsSync2(codexDir)
+  });
+  const zedConfig = getZedConfigPath();
+  tools.push({
+    name: "zed",
+    displayName: "Zed",
+    detected: existsSync2(zedConfig),
+    configPath: zedConfig
   });
   return tools;
 }
 async function configureTool(tool, projectDir = process.cwd()) {
-  const bridge = resolveMcpBridge();
-  const mcpUrl = `${getServerUrl()}/api/mcp`;
+  const bridge = resolveMcpBridge(tool);
   switch (tool) {
     case "claude":
       return configureClaudeCode(bridge);
     case "opencode":
-      return configureOpenCode(join(projectDir, "opencode.json"), bridge);
+      return configureOpenCode(join(projectDir, "opencode.json"), bridge, tool);
     case "cursor":
-      return configureMcpServersJson("Cursor", join(projectDir, ".cursor", "mcp.json"), bridge);
+      return configureMcpServersJson(
+        "Cursor",
+        join(projectDir, ".cursor", "mcp.json"),
+        bridge,
+        tool
+      );
     case "windsurf":
-      return configureMcpServersJson("Windsurf", join(projectDir, ".windsurf", "mcp.json"), bridge);
+      return configureMcpServersJson(
+        "Windsurf",
+        join(projectDir, ".windsurf", "mcp.json"),
+        bridge,
+        tool
+      );
     case "codex":
-      return configureCodex(bridge);
+      return configureCodex(bridge, tool);
+    case "zed":
+      return configureZed(bridge, tool);
     default:
       return { success: false, message: `Unknown tool: ${tool}` };
   }
 }
-function resolveMcpBridge() {
+function resolveMcpBridge(tool) {
   return {
     command: "orkestrate",
-    args: ["mcp"]
+    args: ["mcp", "--parent-tool", tool]
   };
 }
 function configureClaudeCode(bridge) {
-  if (!isCommandAvailable("claude")) return { success: false, message: "Claude Code CLI not found." };
+  if (!isCommandAvailable("claude"))
+    return { success: false, message: "Claude Code CLI not found." };
   try {
-    try {
-      execSync("claude mcp remove Orkestrate", { stdio: "pipe" });
-    } catch {
-    }
     const commandToRun = bridge.command;
     const argsToRun = bridge.args.join(" ");
+    const mcpJsonPath = join(process.cwd(), ".mcp.json");
+    if (existsSync2(mcpJsonPath)) {
+      try {
+        const mcpConfig = JSON.parse(readFileSync2(mcpJsonPath, "utf-8"));
+        if (mcpConfig.mcpServers?.Orkestrate) {
+          delete mcpConfig.mcpServers.Orkestrate;
+          writeFileSync2(
+            mcpJsonPath,
+            JSON.stringify(mcpConfig, null, 2) + "\n",
+            "utf-8"
+          );
+        }
+      } catch {
+      }
+    }
     execSync(
-      `claude mcp add --transport stdio --scope project Orkestrate ${commandToRun} ${argsToRun}`,
+      `claude mcp add --transport stdio --scope project Orkestrate -- ${commandToRun} ${argsToRun}`,
       { stdio: "pipe", encoding: "utf-8" }
     );
     return { success: true, message: "MCP added to Claude Code." };
   } catch (err) {
-    return { success: false, message: `Claude config failed: ${err instanceof Error ? err.message : String(err)}` };
+    return {
+      success: false,
+      message: `Claude config failed: ${err instanceof Error ? err.message : String(err)}`
+    };
   }
 }
-function configureOpenCode(configPath, bridge) {
+function configureOpenCode(configPath, bridge, tool) {
   try {
-    let config2 = existsSync(configPath) ? JSON.parse(readFileSync(configPath, "utf-8")) : {};
+    const config2 = existsSync2(configPath) ? JSON.parse(readFileSync2(configPath, "utf-8")) : {};
     if (!config2.mcp || typeof config2.mcp !== "object") config2.mcp = {};
     config2.mcp["Orkestrate"] = {
       type: "local",
       command: [bridge.command, ...bridge.args],
       enabled: true
     };
-    writeFileSync(configPath, JSON.stringify(config2, null, 2) + "\n", "utf-8");
+    writeFileSync2(configPath, JSON.stringify(config2, null, 2) + "\n", "utf-8");
     return { success: true, message: `Configured OpenCode at ${configPath}` };
   } catch (err) {
-    return { success: false, message: `OpenCode config failed: ${err instanceof Error ? err.message : String(err)}` };
+    return {
+      success: false,
+      message: `OpenCode config failed: ${err instanceof Error ? err.message : String(err)}`
+    };
   }
 }
-function configureMcpServersJson(displayName, configPath, bridge) {
+function configureMcpServersJson(displayName, configPath, bridge, tool) {
   try {
     const dir = join(configPath, "..");
-    if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
-    let config2 = existsSync(configPath) ? JSON.parse(readFileSync(configPath, "utf-8")) : {};
-    if (!config2.mcpServers || typeof config2.mcpServers !== "object") config2.mcpServers = {};
+    if (!existsSync2(dir)) mkdirSync2(dir, { recursive: true });
+    const config2 = existsSync2(configPath) ? JSON.parse(readFileSync2(configPath, "utf-8")) : {};
+    if (!config2.mcpServers || typeof config2.mcpServers !== "object")
+      config2.mcpServers = {};
     config2.mcpServers["Orkestrate"] = {
       command: bridge.command,
       args: bridge.args
     };
-    writeFileSync(configPath, JSON.stringify(config2, null, 2) + "\n", "utf-8");
-    return { success: true, message: `Configured ${displayName} at ${configPath}` };
+    writeFileSync2(configPath, JSON.stringify(config2, null, 2) + "\n", "utf-8");
+    return {
+      success: true,
+      message: `Configured ${displayName} at ${configPath}`
+    };
+  } catch (err) {
+    return {
+      success: false,
+      message: `${displayName} config failed: ${err instanceof Error ? err.message : String(err)}`
+    };
+  }
+}
+function configureZed(bridge, tool) {
+  const configPath = getZedConfigPath();
+  try {
+    const dir = join(configPath, "..");
+    if (!existsSync2(dir)) mkdirSync2(dir, { recursive: true });
+    const serverEntry = {
+      enabled: true,
+      remote: false,
+      command: bridge.command,
+      args: bridge.args
+    };
+    let config2 = {};
+    if (existsSync2(configPath)) {
+      const content = readFileSync2(configPath, "utf-8").trim();
+      const jsonStart = content.indexOf("{");
+      const trimmedContent = jsonStart >= 0 ? content.slice(jsonStart) : "";
+      if (trimmedContent) {
+        try {
+          config2 = new Function("return " + trimmedContent)();
+        } catch {
+          return {
+            success: false,
+            message: "Zed config is not valid JSON - manual configuration required"
+          };
+        }
+      }
+    }
+    if (!config2.context_servers || typeof config2.context_servers !== "object") {
+      config2.context_servers = {};
+    }
+    config2.context_servers["mcp-server-orkestrate"] = serverEntry;
+    writeFileSync2(configPath, JSON.stringify(config2, null, 2), "utf-8");
+    return {
+      success: true,
+      message: `Configured Zed at ${configPath}`
+    };
   } catch (err) {
-    return { success: false, message: `${displayName} config failed: ${err instanceof Error ? err.message : String(err)}` };
+    return {
+      success: false,
+      message: `Zed config failed: ${err instanceof Error ? err.message : String(err)}`
+    };
   }
 }
-function configureCodex(bridge) {
+function configureCodex(bridge, tool) {
   const home = homedir();
   const codexDir = join(home, ".codex");
   const configPath = join(codexDir, "config.toml");
   try {
-    if (!existsSync(codexDir)) mkdirSync(codexDir, { recursive: true });
-    let content = existsSync(configPath) ? readFileSync(configPath, "utf-8") : "[mcp_servers]\n";
+    if (!existsSync2(codexDir)) mkdirSync2(codexDir, { recursive: true });
+    let content = existsSync2(configPath) ? readFileSync2(configPath, "utf-8") : "[mcp_servers]\n";
     const proxySection = `[mcp_servers.Orkestrate]
 command = "${bridge.command}"
 args = [${bridge.args.map((a) => `"${a}"`).join(", ")}]
@@ -763,10 +976,13 @@ args = [${bridge.args.map((a) => `"${a}"`).join(", ")}]
         content = content.trimEnd() + "\n\n[mcp_servers]\n\n" + proxySection;
       }
     }
-    writeFileSync(configPath, content, "utf-8");
+    writeFileSync2(configPath, content, "utf-8");
     return { success: true, message: `Configured Codex.` };
   } catch (err) {
-    return { success: false, message: `Codex config failed: ${err instanceof Error ? err.message : String(err)}` };
+    return {
+      success: false,
+      message: `Codex config failed: ${err instanceof Error ? err.message : String(err)}`
+    };
   }
 }
 function isCommandAvailable(command) {
@@ -780,12 +996,11 @@ function isCommandAvailable(command) {
   }
 }
 function getToolNames() {
-  return ["claude", "opencode", "cursor", "windsurf", "codex"];
+  return ["claude", "opencode", "cursor", "windsurf", "codex", "zed"];
 }
 var init_detect = __esm({
   "src/lib/detect.ts"() {
     "use strict";
-    init_config();
   }
 });
 
@@ -845,7 +1060,6 @@ async function connectCommand(toolName) {
   }
 }
 function displayGenericInstructions() {
-  const mcpUrl = `${getServerUrl()}/api/mcp`;
   const bridgeCommand = "orkestrate";
   const bridgeArgs = "mcp";
   ui.info("Generic MCP Setup (for any tool that supports stdio MCP):");
@@ -882,7 +1096,12 @@ function displayGenericInstructions() {
   ui.line(`      command = "${bridgeCommand}"`);
   ui.line(`      args = ["${bridgeArgs}"]`);
   ui.blank();
-  ui.dim(
+  ui.line("  Zed:");
+  ui.line("    Add to settings.json under context_servers:");
+  ui.line("    ~/.config/zed/settings.json (Linux/macOS)");
+  ui.line("    ~/AppData/Roaming/Zed/settings.json (Windows)");
+  ui.blank();
+  ui.line(
     "  Not sure if your tool supports MCP? Check its docs for 'MCP server'."
   );
 }
@@ -898,7 +1117,8 @@ var init_connect = __esm({
       "opencode",
       "cursor",
       "windsurf",
-      "codex"
+      "codex",
+      "zed"
     ];
   }
 });
@@ -909,6 +1129,7 @@ __export(api_exports, {
   ApiError: () => ApiError,
   checkHealth: () => checkHealth,
   createWorkspace: () => createWorkspace,
+  getGithubStatus: () => getGithubStatus,
   getMe: () => getMe,
   getTeamStatus: () => getTeamStatus,
   listWorkspaces: () => listWorkspaces,
@@ -937,7 +1158,7 @@ async function request(method, path, body) {
     method,
     headers: {
       ...headers,
-      "Accept": "application/json",
+      Accept: "application/json",
       "User-Agent": "Orkestrate-CLI-v1"
     },
     body: body ? JSON.stringify(body) : void 0
@@ -952,8 +1173,18 @@ async function getMe() {
   const data = await request("GET", "/api/auth/me");
   return data.user;
 }
+async function getGithubStatus() {
+  const data = await request(
+    "GET",
+    "/api/github/status"
+  );
+  return { connected: Boolean(data.connected) };
+}
 async function listWorkspaces() {
-  const data = await request("GET", "/api/workspaces");
+  const data = await request(
+    "GET",
+    "/api/workspaces"
+  );
   return data.workspaces || [];
 }
 async function switchWorkspace(workspaceId) {
@@ -963,12 +1194,16 @@ async function switchWorkspace(workspaceId) {
   });
 }
 async function createWorkspace(name, repoUrl, defaultBranch) {
-  const data = await request("POST", "/api/workspaces", {
-    action: "create",
-    name,
-    repoUrl,
-    defaultBranch
-  });
+  const data = await request(
+    "POST",
+    "/api/workspaces",
+    {
+      action: "create",
+      name,
+      repoUrl,
+      defaultBranch
+    }
+  );
   return data.workspace;
 }
 async function getTeamStatus() {
@@ -1143,7 +1378,9 @@ async function workspaceCommand(action, nameOrId, extra) {
     case "create":
     case "new":
       if (!nameOrId) {
-        ui.error("Usage: orkestrate workspace create <name> <repo-url> [branch]");
+        ui.error(
+          "Usage: orkestrate workspace create <name> <repo-url> [branch]"
+        );
         process.exit(1);
       }
       return workspaceCreate(nameOrId, extra);
@@ -1164,7 +1401,9 @@ async function workspaceList() {
     const active = getActiveWorkspace();
     if (workspaces.length === 0) {
       ui.dim("No workspaces found.");
-      ui.info("Create one at orkestrate.space or run `orkestrate workspace create`.");
+      ui.info(
+        "Create one at orkestrate.space or run `orkestrate workspace create`."
+      );
       return;
     }
     for (const ws of workspaces) {
@@ -1183,7 +1422,9 @@ async function workspaceList() {
     ui.blank();
     ui.dim(`${workspaces.length} workspace(s)`);
   } catch (err) {
-    ui.error(`Failed to list workspaces: ${err instanceof Error ? err.message : String(err)}`);
+    ui.error(
+      `Failed to list workspaces: ${err instanceof Error ? err.message : String(err)}`
+    );
     process.exit(1);
   }
 }
@@ -1206,11 +1447,32 @@ async function workspaceSwitch(nameOrId) {
     setActiveWorkspace(target.id, target.name);
     ui.success(`Switched to workspace: ${target.name}`);
   } catch (err) {
-    ui.error(`Failed to switch workspace: ${err instanceof Error ? err.message : String(err)}`);
+    ui.error(
+      `Failed to switch workspace: ${err instanceof Error ? err.message : String(err)}`
+    );
     process.exit(1);
   }
 }
 async function workspaceCreate(name, repoUrl) {
+  const localGithubTokenAvailable = hasGithubToken();
+  let serverGithubConnected = false;
+  try {
+    const status = await getGithubStatus();
+    serverGithubConnected = status.connected;
+  } catch (err) {
+    ui.error(
+      `Failed to verify GitHub connection with server: ${err instanceof Error ? err.message : String(err)}`
+    );
+    ui.info("Please re-run `orkestrate login` and ensure GitHub is connected.");
+    process.exit(1);
+  }
+  if (!localGithubTokenAvailable || !serverGithubConnected) {
+    ui.error("GitHub is not connected. Workspace creation is blocked.");
+    ui.info(
+      "Run `orkestrate login` and complete GitHub connection, then try again."
+    );
+    process.exit(1);
+  }
   if (!repoUrl) {
     ui.error("Repository URL is required.");
     ui.info("Usage: orkestrate workspace create <name> <repo-url>");
@@ -1223,7 +1485,9 @@ async function workspaceCreate(name, repoUrl) {
     ui.kv("ID", workspace.id);
     ui.kv("Repo", repoUrl);
   } catch (err) {
-    ui.error(`Failed to create workspace: ${err instanceof Error ? err.message : String(err)}`);
+    ui.error(
+      `Failed to create workspace: ${err instanceof Error ? err.message : String(err)}`
+    );
     process.exit(1);
   }
 }
@@ -1252,7 +1516,15 @@ function git(cmd, cwd) {
 function detectGitContext(cwd = process.cwd()) {
   const repoRoot = git("rev-parse --show-toplevel", cwd);
   if (!repoRoot) return null;
-  const remote = git("remote get-url origin", cwd);
+  const remotes = git("remote", cwd).split("\n").filter(Boolean);
+  let remote = "";
+  for (const r of remotes) {
+    const url = git(`remote get-url ${r}`, cwd);
+    if (url) {
+      remote = url;
+      break;
+    }
+  }
   const branch = git("rev-parse --abbrev-ref HEAD", cwd);
   const headSha = git("rev-parse HEAD", cwd);
   const status = git("status --porcelain", cwd);
@@ -1276,7 +1548,7 @@ var init_exports = {};
 __export(init_exports, {
   initCommand: () => initCommand
 });
-import { existsSync as existsSync2, writeFileSync as writeFileSync2 } from "fs";
+import { existsSync as existsSync3, writeFileSync as writeFileSync3 } from "fs";
 import { join as join2 } from "path";
 async function initCommand() {
   const creds = getCredentials();
@@ -1386,7 +1658,7 @@ async function initCommand() {
   }
   const configFile = join2(cwd, ".orkestrate.json");
   const activeWs = getActiveWorkspace();
-  if (!existsSync2(configFile)) {
+  if (!existsSync3(configFile)) {
     if (activeWs.id) {
       const projectConfig = {
         $schema: "https://orkestrate.space/schema/project.json",
@@ -1394,18 +1666,18 @@ async function initCommand() {
         server: "https://orkestrate.space",
         initialized: (/* @__PURE__ */ new Date()).toISOString()
       };
-      writeFileSync2(configFile, JSON.stringify(projectConfig, null, 2) + "\n", "utf-8");
+      writeFileSync3(configFile, JSON.stringify(projectConfig, null, 2) + "\n", "utf-8");
       ui.blank();
       ui.success(`Created .orkestrate.json`);
       ui.dim("This file identifies your project workspace. It is gitignored by default.");
     }
   } else {
     try {
-      const { readFileSync: readFileSync2 } = await import("fs");
-      const existing = JSON.parse(readFileSync2(configFile, "utf-8"));
+      const { readFileSync: readFileSync3 } = await import("fs");
+      const existing = JSON.parse(readFileSync3(configFile, "utf-8"));
       if (activeWs.id && existing.workspaceId !== activeWs.id) {
         existing.workspaceId = activeWs.id;
-        writeFileSync2(configFile, JSON.stringify(existing, null, 2) + "\n", "utf-8");
+        writeFileSync3(configFile, JSON.stringify(existing, null, 2) + "\n", "utf-8");
         ui.success(`Updated .orkestrate.json with workspace ID ${activeWs.id}`);
       }
     } catch {
@@ -1441,33 +1713,36 @@ var mcp_exports = {};
 __export(mcp_exports, {
   mcpCommand: () => mcpCommand
 });
-async function mcpCommand() {
+async function mcpCommand(opts) {
+  const PARENT_TOOL = opts.parentTool ?? null;
   try {
     const serverUrl = getServerUrl();
     const mcpUrl = `${serverUrl}/api/mcp`;
     process.stdin.setEncoding("utf-8");
     let buffer = "";
-    process.stderr.write(`[Orkestrate-MCP] Starting bridge to ${mcpUrl}
-`);
+    const startupMsg = `[Orkestrate-MCP] Starting bridge to ${mcpUrl}${PARENT_TOOL ? ` (parent: ${PARENT_TOOL})` : ""}
+`;
+    process.stderr.write(startupMsg);
     process.stdin.on("data", async (chunk) => {
       const rawChunk = String(chunk);
-      if (process.env.DEBUG) process.stderr.write(`[Orkestrate-MCP] Received chunk: ${rawChunk}
+      if (process.env.DEBUG)
+        process.stderr.write(`[Orkestrate-MCP] Received chunk: ${rawChunk}
 `);
       buffer += rawChunk;
       let lineEndIndex;
       while ((lineEndIndex = buffer.indexOf("\n")) >= 0) {
-        let line = buffer.slice(0, lineEndIndex).trim();
+        const line = buffer.slice(0, lineEndIndex).trim();
         buffer = buffer.slice(lineEndIndex + 1);
         if (!line) continue;
         if (line.includes("}{")) {
           const parts = line.split("}{");
-          await processLine(parts[0] + "}", mcpUrl);
+          await processLine(parts[0] + "}", mcpUrl, PARENT_TOOL);
           for (let i = 1; i < parts.length - 1; i++) {
-            await processLine("{" + parts[i] + "}", mcpUrl);
+            await processLine("{" + parts[i] + "}", mcpUrl, PARENT_TOOL);
           }
-          await processLine("{" + parts[parts.length - 1], mcpUrl);
+          await processLine("{" + parts[parts.length - 1], mcpUrl, PARENT_TOOL);
         } else {
-          await processLine(line, mcpUrl);
+          await processLine(line, mcpUrl, PARENT_TOOL);
         }
       }
     });
@@ -1483,14 +1758,16 @@ async function mcpCommand() {
     process.exit(1);
   }
 }
-async function processLine(line, mcpUrl) {
-  if (process.env.DEBUG) process.stderr.write(`[Orkestrate-MCP] Processing line: ${line}
+async function processLine(line, mcpUrl, parentTool) {
+  if (process.env.DEBUG)
+    process.stderr.write(`[Orkestrate-MCP] Processing line: ${line}
 `);
   let payload;
   try {
     payload = JSON.parse(line);
   } catch {
-    if (process.env.DEBUG) process.stderr.write(`[Orkestrate-MCP] JSON Parse failed for: ${line}
+    if (process.env.DEBUG)
+      process.stderr.write(`[Orkestrate-MCP] JSON Parse failed for: ${line}
 `);
     return;
   }
@@ -1499,47 +1776,100 @@ async function processLine(line, mcpUrl) {
   try {
     const token = await getValidToken();
     if (!token) {
-      throw new Error("NOT_LOGGED_IN: Please run 'orkestrate login' to authenticate.");
+      throw new Error(
+        "NOT_LOGGED_IN: Please run 'orkestrate login' to authenticate."
+      );
     }
+    const headers = {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${token}`,
+      "User-Agent": "Orkestrate-CLI-Proxy"
+    };
+    const enrichedPayload = parentTool ? { ...payload, parentTool } : payload;
     const res = await fetch(mcpUrl, {
       method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        "Authorization": `Bearer ${token}`,
-        "User-Agent": "Orkestrate-CLI-Proxy"
-      },
-      body: line
+      headers,
+      body: JSON.stringify(enrichedPayload)
     });
     if (isNotification) return;
     const responseBody = await res.text();
     if (!res.ok) {
-      process.stderr.write(`[Orkestrate-MCP] Backend error (${res.status}): ${responseBody}
-`);
+      process.stderr.write(
+        `[Orkestrate-MCP] Backend error (${res.status}): ${responseBody}
+`
+      );
       if (!isNotification) {
-        process.stdout.write(JSON.stringify({
-          jsonrpc: "2.0",
-          id: requestId,
-          error: {
-            code: -32603,
-            message: `Orkestrate Cloud Error (${res.status}): ${responseBody || "Unauthorized"}. Please try 'orkestrate login'.`
-          }
-        }) + "\n");
+        process.stdout.write(
+          JSON.stringify({
+            jsonrpc: "2.0",
+            id: requestId,
+            error: {
+              code: -32603,
+              message: `Orkestrate Cloud Error (${res.status}): ${responseBody || "Unauthorized"}. Please try 'orkestrate login'.`
+            }
+          }) + "\n"
+        );
       }
       return;
     }
     if (responseBody) {
-      process.stdout.write(responseBody + "\n");
+      if (payload.method === "tools/list") {
+        const filtered = filterToolsList(responseBody);
+        process.stdout.write(filtered + "\n");
+      } else {
+        if (payload.method === "tools/call") {
+          const toolName = payload.params?.name;
+          if (toolName && !isToolAllowed(toolName)) {
+            process.stdout.write(
+              JSON.stringify({
+                jsonrpc: "2.0",
+                id: requestId,
+                error: {
+                  code: -32600,
+                  message: `Tool '${toolName}' is disabled. Use 'orkestrate tools --list' to see available tools and 'orkestrate tools --enable ${toolName}' to enable it.`
+                }
+              }) + "\n"
+            );
+            return;
+          }
+        }
+        process.stdout.write(responseBody + "\n");
+      }
     }
   } catch (err) {
     if (isNotification) return;
-    process.stdout.write(JSON.stringify({
-      jsonrpc: "2.0",
-      id: requestId,
-      error: {
-        code: -32603,
-        message: err instanceof Error ? err.message : String(err)
-      }
-    }) + "\n");
+    process.stdout.write(
+      JSON.stringify({
+        jsonrpc: "2.0",
+        id: requestId,
+        error: {
+          code: -32603,
+          message: err instanceof Error ? err.message : String(err)
+        }
+      }) + "\n"
+    );
+  }
+}
+function filterToolsList(responseBody) {
+  try {
+    const parsed = JSON.parse(responseBody);
+    if (!parsed.result?.tools) return responseBody;
+    const enabledTools = getEnabledTools();
+    const disabledTools = getDisabledTools();
+    let filteredTools = parsed.result.tools;
+    if (enabledTools !== null) {
+      filteredTools = filteredTools.filter(
+        (tool) => enabledTools.includes(tool.name)
+      );
+    } else {
+      filteredTools = filteredTools.filter(
+        (tool) => !disabledTools.includes(tool.name)
+      );
+    }
+    parsed.result.tools = filteredTools;
+    return JSON.stringify(parsed);
+  } catch {
+    return responseBody;
   }
 }
 var init_mcp = __esm({
@@ -1609,11 +1939,82 @@ var init_whoami = __esm({
   }
 });
 
+// src/commands/tools.ts
+var tools_exports = {};
+__export(tools_exports, {
+  toolsCommand: () => toolsCommand
+});
+async function toolsCommand(opts) {
+  const { list, enable, disable } = opts;
+  if (list) {
+    const enabledTools = getEnabledTools();
+    const disabledTools = getDisabledTools();
+    ui.header("Tool Filter Settings");
+    if (enabledTools !== null) {
+      ui.info(`Mode: Additive (only listed tools are enabled)`);
+      if (enabledTools.length === 0) {
+        ui.dim("  No tools enabled");
+      } else {
+        enabledTools.forEach((tool) => {
+          ui.success(tool);
+        });
+      }
+    } else {
+      ui.info(`Mode: Subtractive (all tools except disabled)`);
+      if (disabledTools.length === 0) {
+        ui.dim("  No tools disabled");
+      } else {
+        disabledTools.forEach((tool) => {
+          ui.error(tool);
+        });
+      }
+    }
+    console.log();
+    ui.dim(`  Use 'orkestrate tools --enable <tool>' to enable a tool`);
+    ui.dim(`  Use 'orkestrate tools --disable <tool>' to disable a tool`);
+    return;
+  }
+  if (enable) {
+    const toolName = enable;
+    if (isToolAllowed(toolName)) {
+      ui.warn(`Tool '${toolName}' is already enabled`);
+    } else {
+      enableTool(toolName);
+      ui.success(`Enabled tool: ${toolName}`);
+    }
+    return;
+  }
+  if (disable) {
+    const toolName = disable;
+    if (!isToolAllowed(toolName)) {
+      ui.warn(`Tool '${toolName}' is already disabled`);
+    } else {
+      disableTool(toolName);
+      ui.success(`Disabled tool: ${toolName}`);
+    }
+    return;
+  }
+  ui.header("Orkestrate Tools Management");
+  ui.info("Manage which tools are available through the local MCP proxy");
+  console.log();
+  ui.dim("Usage:");
+  ui.dim("  orkestrate tools --list              Show current settings");
+  ui.dim("  orkestrate tools --enable <tool>     Enable a specific tool");
+  ui.dim("  orkestrate tools --disable <tool>    Disable a specific tool");
+}
+var init_tools = __esm({
+  "src/commands/tools.ts"() {
+    "use strict";
+    init_config();
+    init_ui();
+  }
+});
+
 // src/cli.ts
 init_ui();
 import { Command } from "commander";
 var program = new Command();
-program.name("orkestrate").description("The coordination layer for autonomous AI coding agents").version("0.1.12").hook("preAction", () => {
+program.name("orkestrate").description("The coordination layer for autonomous AI coding agents").version("0.1.15").hook("preAction", () => {
 });
 program.command("login").description("Authenticate with Orkestrate via browser OAuth").action(async () => {
   const { loginCommand: loginCommand2 } = await Promise.resolve().then(() => (init_login(), login_exports));
@@ -1623,7 +2024,9 @@ program.command("logout").description("Clear stored credentials").action(async (
   const { logoutCommand: logoutCommand2 } = await Promise.resolve().then(() => (init_logout(), logout_exports));
   logoutCommand2();
 });
-program.command("connect [tool]").description("Configure MCP endpoint for an AI coding tool (claude, opencode, cursor, windsurf, codex)").action(async (tool) => {
+program.command("connect [tool]").description(
+  "Configure MCP endpoint for an AI coding tool (claude, opencode, cursor, windsurf, codex)"
+).action(async (tool) => {
   const { connectCommand: connectCommand2 } = await Promise.resolve().then(() => (init_connect(), connect_exports));
   await connectCommand2(tool);
 });
@@ -1639,13 +2042,18 @@ program.command("init").description("Initialize Orkestrate in the current projec
   const { initCommand: initCommand2 } = await Promise.resolve().then(() => (init_init(), init_exports));
   await initCommand2();
 });
-program.command("mcp").description("Run as a local MCP server (stdio bridge to Orkestrate Cloud)").action(async () => {
+program.command("mcp").description("Run as a local MCP server (stdio bridge to Orkestrate Cloud)").option(
+  "--parent-tool <tool>",
+  "The AI coding tool invoking this bridge (claude, zed, cursor, etc.)"
+).action(async (opts) => {
   try {
     const { mcpCommand: mcpCommand2 } = await Promise.resolve().then(() => (init_mcp(), mcp_exports));
-    await mcpCommand2();
+    await mcpCommand2(opts);
   } catch (err) {
-    process.stderr.write(`[Orkestrate-MCP] ${err instanceof Error ? err.message : String(err)}
-`);
+    process.stderr.write(
+      `[Orkestrate-MCP] ${err instanceof Error ? err.message : String(err)}
+`
+    );
     process.exit(1);
   }
 });
@@ -1653,6 +2061,10 @@ program.command("whoami").description("Show current authentication and configura
   const { whoamiCommand: whoamiCommand2 } = await Promise.resolve().then(() => (init_whoami(), whoami_exports));
   await whoamiCommand2();
 });
+program.command("tools").description("Manage enabled/disabled tools for local MCP proxy").option("--list", "List current tool filter settings").option("--enable <tool>", "Enable a specific tool").option("--disable <tool>", "Disable a specific tool").action(async (opts) => {
+  const { toolsCommand: toolsCommand2 } = await Promise.resolve().then(() => (init_tools(), tools_exports));
+  await toolsCommand2(opts);
+});
 program.action(() => {
   ui.banner();
   program.help();