Merge pull request #118 from 777genius/fix/hide-cli-child-windows-dev

fix(runtime): hide cli child windows by default

Author: 777genius

mcp-server/src/index.ts

@@ -1,10 +1,28 @@
 #!/usr/bin/env node
-import { pathToFileURL } from 'node:url';
+import { pathToFileURL } from 'url';
 
 import { FastMCP } from 'fastmcp';
 
 import { registerTools } from './tools';
 
+const HTTP_TRANSPORT = 'httpStream';
+const STDIO_TRANSPORT = 'stdio';
+const DEFAULT_HTTP_HOST = '127.0.0.1';
+const DEFAULT_HTTP_ENDPOINT = '/mcp';
+
+export type AgentTeamsMcpStartOptions =
+  | {
+      transportType: typeof STDIO_TRANSPORT;
+    }
+  | {
+      transportType: typeof HTTP_TRANSPORT;
+      httpStream: {
+        host: string;
+        port: number;
+        endpoint: `/${string}`;
+      };
+    };
+
 export function createServer() {
   const server = new FastMCP({
     name: 'agent-teams-mcp',
@@ -16,9 +34,64 @@ export function createServer() {
   return server;
 }
 
+function getArgValue(argv: string[], name: string): string | null {
+  const directPrefix = `${name}=`;
+  for (let index = 2; index < argv.length; index += 1) {
+    const value = argv[index];
+    if (value === name) {
+      return argv[index + 1] ?? null;
+    }
+    if (value.startsWith(directPrefix)) {
+      return value.slice(directPrefix.length);
+    }
+  }
+  return null;
+}
+
+function normalizeEndpoint(value: string | null | undefined): `/${string}` {
+  const trimmed = value?.trim();
+  if (!trimmed) {
+    return DEFAULT_HTTP_ENDPOINT;
+  }
+  return (trimmed.startsWith('/') ? trimmed : `/${trimmed}`) as `/${string}`;
+}
+
+function parsePort(value: string | null | undefined): number {
+  const parsed = Number(value);
+  if (!Number.isInteger(parsed) || parsed <= 0 || parsed > 65535) {
+    throw new Error(`Invalid agent-teams MCP HTTP port: ${value ?? '<empty>'}`);
+  }
+  return parsed;
+}
+
+export function resolveStartOptions(
+  argv: string[] = process.argv,
+  env: NodeJS.ProcessEnv = process.env
+): AgentTeamsMcpStartOptions {
+  const transport =
+    getArgValue(argv, '--transport') ??
+    getArgValue(argv, '--transportType') ??
+    env.AGENT_TEAMS_MCP_TRANSPORT ??
+    STDIO_TRANSPORT;
+
+  if (transport !== HTTP_TRANSPORT) {
+    return { transportType: STDIO_TRANSPORT };
+  }
+
+  return {
+    transportType: HTTP_TRANSPORT,
+    httpStream: {
+      host:
+        getArgValue(argv, '--host')?.trim() ??
+        env.AGENT_TEAMS_MCP_HTTP_HOST?.trim() ??
+        DEFAULT_HTTP_HOST,
+      port: parsePort(getArgValue(argv, '--port') ?? env.AGENT_TEAMS_MCP_HTTP_PORT),
+      endpoint: normalizeEndpoint(getArgValue(argv, '--endpoint') ?? env.AGENT_TEAMS_MCP_HTTP_ENDPOINT),
+    },
+  };
+}
+
 if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
   const server = createServer();
-  void server.start({
-    transportType: 'stdio',
-  });
+  void server.start(resolveStartOptions());
 }

mcp-server/test/startOptions.test.ts

@@ -0,0 +1,54 @@
+import { describe, expect, it } from 'vitest';
+
+import { resolveStartOptions } from '../src/index';
+
+describe('agent-teams MCP start options', () => {
+  it('defaults to stdio transport', () => {
+    expect(resolveStartOptions(['node', 'index.js'], {})).toEqual({
+      transportType: 'stdio',
+    });
+  });
+
+  it('resolves HTTP stream transport from CLI args', () => {
+    expect(
+      resolveStartOptions(
+        [
+          'node',
+          'index.js',
+          '--transport',
+          'httpStream',
+          '--host',
+          '127.0.0.1',
+          '--port',
+          '43123',
+          '--endpoint',
+          'mcp',
+        ],
+        {}
+      )
+    ).toEqual({
+      transportType: 'httpStream',
+      httpStream: {
+        host: '127.0.0.1',
+        port: 43123,
+        endpoint: '/mcp',
+      },
+    });
+  });
+
+  it('resolves HTTP stream transport from environment', () => {
+    expect(
+      resolveStartOptions(['node', 'index.js'], {
+        AGENT_TEAMS_MCP_TRANSPORT: 'httpStream',
+        AGENT_TEAMS_MCP_HTTP_PORT: '43124',
+      })
+    ).toEqual({
+      transportType: 'httpStream',
+      httpStream: {
+        host: '127.0.0.1',
+        port: 43124,
+        endpoint: '/mcp',
+      },
+    });
+  });
+});

src/main/index.ts

@@ -133,6 +133,7 @@ import {
 import { startEventLoopLagMonitor } from './services/infrastructure/EventLoopLagMonitor';
 import { HttpServer } from './services/infrastructure/HttpServer';
 import { clearAutoResumeService } from './services/team/AutoResumeService';
+import { agentTeamsMcpHttpServer } from './services/team/AgentTeamsMcpHttpServer';
 import { LaunchIoGovernor } from './services/team/LaunchIoGovernor';
 import { OpenCodeBridgeCommandClient } from './services/team/opencode/bridge/OpenCodeBridgeCommandClient';
 import {
@@ -352,6 +353,33 @@ async function createOpenCodeRuntimeAdapterRegistry(
   const bridgeEnv = applyOpenCodeAutoUpdatePolicy({ ...process.env });
   bridgeEnv.CLAUDE_TEAM_APP_INSTANCE_ID = openCodeManagedHostInstanceId;
   bridgeEnv.AGENT_TEAMS_MCP_CLAUDE_DIR = getClaudeBasePath();
+  const applyMcpLaunchSpecEnv = async (
+    targetEnv: NodeJS.ProcessEnv,
+    options: { emitProgress?: boolean } = {}
+  ): Promise<void> => {
+    try {
+      if (options.emitProgress) {
+        reportProgress('runtime-mcp', 'Resolving Agent Teams MCP server...');
+      }
+      const mcpLaunchSpec = await resolveAgentTeamsMcpLaunchSpec({
+        onProgress: options.emitProgress
+          ? ({ phase, message }) => reportProgress(`mcp-${phase}`, message)
+          : undefined,
+      });
+      const mcpEntry = mcpLaunchSpec.args[0];
+      if (mcpEntry) {
+        targetEnv.CLAUDE_MULTIMODEL_AGENT_TEAMS_MCP_COMMAND = mcpLaunchSpec.command;
+        targetEnv.CLAUDE_MULTIMODEL_AGENT_TEAMS_MCP_ENTRY = mcpEntry;
+        targetEnv.CLAUDE_MULTIMODEL_AGENT_TEAMS_MCP_ARGS_JSON = JSON.stringify(mcpLaunchSpec.args);
+      }
+    } catch (error) {
+      logger.warn(
+        `[OpenCode] Runtime adapter bridge MCP entrypoint unresolved: ${
+          error instanceof Error ? error.message : String(error)
+        }`
+      );
+    }
+  };
   try {
     const appManagedOpenCodeBinary = await resolveVerifiedAppManagedOpenCodeRuntimeBinaryPath();
     if (appManagedOpenCodeBinary && !bridgeEnv.CLAUDE_MULTIMODEL_OPENCODE_BIN_PATH) {
@@ -381,29 +409,69 @@ async function createOpenCodeRuntimeAdapterRegistry(
     );
   }
   try {
-    reportProgress('runtime-mcp', 'Resolving Agent Teams MCP server...');
-    const mcpLaunchSpec = await resolveAgentTeamsMcpLaunchSpec({
-      onProgress: ({ phase, message }) => reportProgress(`mcp-${phase}`, message),
-    });
-    const mcpEntry = mcpLaunchSpec.args[0];
-    if (mcpEntry) {
-      bridgeEnv.CLAUDE_MULTIMODEL_AGENT_TEAMS_MCP_COMMAND = mcpLaunchSpec.command;
-      bridgeEnv.CLAUDE_MULTIMODEL_AGENT_TEAMS_MCP_ENTRY = mcpEntry;
-      bridgeEnv.CLAUDE_MULTIMODEL_AGENT_TEAMS_MCP_ARGS_JSON = JSON.stringify(mcpLaunchSpec.args);
-    }
+    reportProgress('runtime-mcp-http', 'Starting Agent Teams MCP server...');
+    const mcpHttpServer = await agentTeamsMcpHttpServer.ensureStarted();
+    bridgeEnv.CLAUDE_MULTIMODEL_AGENT_TEAMS_MCP_URL = mcpHttpServer.url;
+    reportProgress('runtime-mcp-http-ready', 'Agent Teams MCP server is ready...');
   } catch (error) {
     logger.warn(
-      `[OpenCode] Runtime adapter bridge MCP entrypoint unresolved: ${
+      `[OpenCode] Runtime adapter bridge MCP HTTP server unavailable: ${
         error instanceof Error ? error.message : String(error)
       }`
     );
   }
+  if (!bridgeEnv.CLAUDE_MULTIMODEL_AGENT_TEAMS_MCP_URL) {
+    await applyMcpLaunchSpecEnv(bridgeEnv, { emitProgress: true });
+  }
 
   reportProgress('runtime-bridge', 'Preparing OpenCode bridge...');
+  const resolveBridgeCommandEnv = async (): Promise<NodeJS.ProcessEnv> => {
+    const nextEnv = { ...bridgeEnv };
+    if (!bridgeEnv.CLAUDE_MULTIMODEL_AGENT_TEAMS_MCP_URL) {
+      return nextEnv;
+    }
+    try {
+      const mcpHttpServer = await agentTeamsMcpHttpServer.ensureStarted();
+      bridgeEnv.CLAUDE_MULTIMODEL_AGENT_TEAMS_MCP_URL = mcpHttpServer.url;
+      nextEnv.CLAUDE_MULTIMODEL_AGENT_TEAMS_MCP_URL = mcpHttpServer.url;
+      delete nextEnv.CLAUDE_MULTIMODEL_AGENT_TEAMS_MCP_COMMAND;
+      delete nextEnv.CLAUDE_MULTIMODEL_AGENT_TEAMS_MCP_ENTRY;
+      delete nextEnv.CLAUDE_MULTIMODEL_AGENT_TEAMS_MCP_ARGS_JSON;
+    } catch (error) {
+      delete nextEnv.CLAUDE_MULTIMODEL_AGENT_TEAMS_MCP_URL;
+      if (
+        bridgeEnv.CLAUDE_MULTIMODEL_AGENT_TEAMS_MCP_COMMAND &&
+        bridgeEnv.CLAUDE_MULTIMODEL_AGENT_TEAMS_MCP_ENTRY &&
+        bridgeEnv.CLAUDE_MULTIMODEL_AGENT_TEAMS_MCP_ARGS_JSON
+      ) {
+        nextEnv.CLAUDE_MULTIMODEL_AGENT_TEAMS_MCP_COMMAND =
+          bridgeEnv.CLAUDE_MULTIMODEL_AGENT_TEAMS_MCP_COMMAND;
+        nextEnv.CLAUDE_MULTIMODEL_AGENT_TEAMS_MCP_ENTRY =
+          bridgeEnv.CLAUDE_MULTIMODEL_AGENT_TEAMS_MCP_ENTRY;
+        nextEnv.CLAUDE_MULTIMODEL_AGENT_TEAMS_MCP_ARGS_JSON =
+          bridgeEnv.CLAUDE_MULTIMODEL_AGENT_TEAMS_MCP_ARGS_JSON;
+      } else {
+        await applyMcpLaunchSpecEnv(nextEnv);
+        bridgeEnv.CLAUDE_MULTIMODEL_AGENT_TEAMS_MCP_COMMAND =
+          nextEnv.CLAUDE_MULTIMODEL_AGENT_TEAMS_MCP_COMMAND;
+        bridgeEnv.CLAUDE_MULTIMODEL_AGENT_TEAMS_MCP_ENTRY =
+          nextEnv.CLAUDE_MULTIMODEL_AGENT_TEAMS_MCP_ENTRY;
+        bridgeEnv.CLAUDE_MULTIMODEL_AGENT_TEAMS_MCP_ARGS_JSON =
+          nextEnv.CLAUDE_MULTIMODEL_AGENT_TEAMS_MCP_ARGS_JSON;
+      }
+      logger.warn(
+        `[OpenCode] Runtime adapter bridge MCP HTTP server refresh failed: ${
+          error instanceof Error ? error.message : String(error)
+        }`
+      );
+    }
+    return nextEnv;
+  };
   const bridgeClient = new OpenCodeBridgeCommandClient({
     binaryPath,
     tempDirectory: join(app.getPath('temp'), 'claude-team-opencode-bridge'),
     env: bridgeEnv,
+    envProvider: resolveBridgeCommandEnv,
   });
   const bridgeControlDir = join(app.getPath('userData'), 'opencode-bridge');
   const clientIdentity = createOpenCodeBridgeClientIdentity({
@@ -2081,6 +2149,9 @@ async function shutdownServices(): Promise<void> {
       () => cleanupOpenCodeHostsForLifecycle('shutdown'),
       10_000
     );
+    await runShutdownStep('Agent Teams MCP HTTP server cleanup', () =>
+      agentTeamsMcpHttpServer.stop()
+    );
     await runShutdownStep('tracked CLI subprocess cleanup', () =>
       killTrackedCliProcesses('SIGKILL')
     );