@microi.net/cli 4.9.6 → 4.9.7

package/scripts/microi-codex-router.js

@@ -10,6 +10,7 @@
 const childProcess = require('node:child_process');
 const crypto = require('node:crypto');
 const fs = require('node:fs');
+const net = require('node:net');
 const os = require('node:os');
 const path = require('node:path');
 
@@ -18,13 +19,14 @@ const CONFIG_FILE = '.microi-config.json';
 const TOKEN_FILE = '.microi-mcp-tokens.json';
 const PROTOCOL_VERSION = '2024-11-05';
 const pluginRoot = path.resolve(__dirname, '..');
-const mcpServerPath = path.join(__dirname, 'mcp-server.js');
+const mcpServerPath = path.resolve(process.env.MICROI_MCP_SERVER_PATH || path.join(__dirname, 'mcp-server.js'));
+const brokerScriptPath = path.resolve(process.env.MICROI_CODEX_BROKER_SCRIPT || path.join(__dirname, 'microi-codex-broker.js'));
 const packagePath = path.join(pluginRoot, 'package.json');
-const pluginVersion = readJson(packagePath, {}).version || '0.0.0';
-const children = new Map();
+const pluginVersion = process.env.MICROI_TOOL_VERSION || readJson(packagePath, {}).version || '0.0.0';
 let inputBuffer = '';
 let requestSequence = 0;
 let shuttingDown = false;
+let brokerClient = null;
 
 function readJson(filePath, fallback) {
   try {
@@ -231,56 +233,102 @@ function buildApplicationsDir(profile) {
   return path.join(profile.syncRoot, serverDir, osClientDir, 'AI应用');
 }
 
-function deviceId() {
-  const raw = `MCP:${os.hostname() || 'Unknown'}`;
-  if (/^[\x20-\x7E]{1,128}$/.test(raw)) return raw;
-  return `MCP-${crypto.createHash('sha256').update(raw).digest('hex').slice(0, 16)}`;
+function brokerCoordinates(workspace) {
+  const normalizedRoot = process.platform === 'win32'
+    ? workspace.workspaceRoot.toLowerCase()
+    : workspace.workspaceRoot;
+  const key = crypto.createHash('sha256').update(`${normalizedRoot}\0${pluginVersion}`).digest('hex').slice(0, 24);
+  const runtimeRoot = path.resolve(process.env.MICROI_RUNTIME_HOME || path.join(os.homedir(), '.microi', 'runtime'));
+  const endpoint = process.env.MICROI_CODEX_BROKER_ENDPOINT || (process.platform === 'win32'
+    ? `\\\\.\\pipe\\microi-codex-${key}`
+    : path.join(runtimeRoot, 'brokers', `${key}.sock`));
+  return {
+    endpoint,
+    leasePath: path.resolve(process.env.MICROI_CODEX_BROKER_LEASE || path.join(runtimeRoot, 'leases', `microi-codex-${key}.json`)),
+    workspaceRoot: workspace.workspaceRoot,
+  };
+}
+
+function wait(milliseconds) {
+  return new Promise(resolve => setTimeout(resolve, milliseconds));
+}
+
+function readBrokerToken(leasePath) {
+  const lease = readJson(leasePath, {});
+  return typeof lease.token === 'string' ? lease.token : '';
 }
 
-class ChildMcp {
-  constructor(profile) {
-    this.profile = profile;
+class SharedBrokerClient {
+  constructor(workspace) {
+    this.coordinates = brokerCoordinates(workspace);
     this.pending = new Map();
     this.buffer = '';
-    this.ready = this.start();
+    this.closed = false;
+    this.spawnAttempted = false;
+    this.ready = this.connect();
   }
 
-  async start() {
-    if (!fs.existsSync(mcpServerPath)) {
-      throw new Error(`Codex Plugin 缺少 MCP bundle：${mcpServerPath}`);
+  startBroker() {
+    if (!fs.existsSync(brokerScriptPath)) {
+      throw new Error(`Codex Plugin 缺少共享 Broker：${brokerScriptPath}`);
     }
-    this.child = childProcess.spawn(process.execPath, [mcpServerPath], {
-      cwd: this.profile.workspaceRoot,
+    const child = childProcess.spawn(process.execPath, [brokerScriptPath], {
+      cwd: pluginRoot,
+      detached: true,
       windowsHide: true,
-      stdio: ['pipe', 'pipe', 'pipe'],
+      stdio: 'ignore',
       env: {
         ...process.env,
-        MICROI_API_URL: this.profile.apiBaseUrl,
-        MICROI_TOKEN_FILE: this.profile.tokenPath,
-        MICROI_AUTH_RECOVERY_DIR: `${this.profile.tokenPath}.recovery`,
-        MICROI_OS_CLIENT: this.profile.osClient,
-        MICROI_OS_CLIENT_TYPE: this.profile.osClientType,
-        MICROI_OS_CLIENT_NETWORK: this.profile.osClientNetwork,
-        MICROI_WORKSPACE_ROOT: this.profile.workspaceRoot,
-        MICROI_SYNC_ROOT: this.profile.syncRoot,
-        MICROI_AI_APPLICATIONS_DIR: buildApplicationsDir(this.profile),
-        MICROI_LABEL_BASE64: Buffer.from(this.profile.label, 'utf8').toString('base64'),
-        MICROI_MCP_DID: deviceId(),
-        MICROI_TOOL_SOURCE: 'codex-plugin',
+        MICROI_CODEX_BROKER_ENDPOINT: this.coordinates.endpoint,
+        MICROI_CODEX_BROKER_LEASE: this.coordinates.leasePath,
+        MICROI_WORKSPACE_ROOT: this.coordinates.workspaceRoot,
+        MICROI_MCP_SERVER_PATH: mcpServerPath,
         MICROI_TOOL_VERSION: pluginVersion,
-        MICROI_CODEX_MODE: '1',
       },
     });
-    this.child.stdout.on('data', chunk => this.onData(chunk));
-    this.child.stderr.on('data', chunk => process.stderr.write(`[${this.profile.name}] ${chunk}`));
-    this.child.on('error', error => this.rejectAll(error));
-    this.child.on('exit', code => this.rejectAll(new Error(`Microi MCP ${this.profile.name} 已退出（${code ?? 'unknown'}）`)));
-    await this.request('initialize', {
-      protocolVersion: PROTOCOL_VERSION,
-      capabilities: {},
-      clientInfo: { name: 'microi-codex-plugin-router', version: pluginVersion },
-    }, true);
-    this.notify('notifications/initialized', {});
+    child.on('error', () => { /* connect retry reports the actionable failure */ });
+    child.unref();
+  }
+
+  openSocket() {
+    return new Promise((resolve, reject) => {
+      const socket = net.createConnection(this.coordinates.endpoint);
+      const fail = error => {
+        socket.destroy();
+        reject(error);
+      };
+      socket.once('error', fail);
+      socket.once('connect', () => {
+        socket.off('error', fail);
+        this.socket = socket;
+        socket.setEncoding('utf8');
+        socket.on('data', chunk => this.onData(chunk));
+        socket.on('error', error => this.rejectAll(error));
+        socket.on('close', () => {
+          this.closed = true;
+          this.rejectAll(new Error('Microi shared broker disconnected'));
+        });
+        resolve();
+      });
+    });
+  }
+
+  async connect() {
+    let lastError;
+    for (let attempt = 0; attempt < 50; attempt += 1) {
+      try {
+        await this.openSocket();
+        return;
+      } catch (error) {
+        lastError = error;
+        if (!this.spawnAttempted || attempt === 15) {
+          this.spawnAttempted = true;
+          this.startBroker();
+        }
+        await wait(Math.min(40 + attempt * 12, 250));
+      }
+    }
+    throw new Error(`无法连接 Microi 共享 Broker：${lastError instanceof Error ? lastError.message : String(lastError)}`);
   }
 
   onData(chunk) {
@@ -296,7 +344,7 @@ class ChildMcp {
       const pending = this.pending.get(String(message.id));
       if (!pending) continue;
       this.pending.delete(String(message.id));
-      if (message.error) pending.reject(new Error(message.error.message || JSON.stringify(message.error)));
+      if (message.error) pending.reject(new Error(typeof message.error === 'string' ? message.error : (message.error.message || JSON.stringify(message.error))));
       else pending.resolve(message.result);
     }
   }
@@ -306,37 +354,42 @@ class ChildMcp {
     this.pending.clear();
   }
 
-  write(message) {
-    if (!this.child || this.child.stdin.destroyed) throw new Error(`Microi MCP ${this.profile.name} 不可用`);
-    this.child.stdin.write(`${JSON.stringify(message)}\n`);
-  }
-
-  request(method, params, skipReady = false) {
+  request(profile, method, params) {
     return (async () => {
-      if (!skipReady) await this.ready;
+      await this.ready;
+      if (this.closed || !this.socket || this.socket.destroyed) throw new Error('Microi shared broker is unavailable');
+      let auth = '';
+      for (let attempt = 0; attempt < 10 && !auth; attempt += 1) {
+        auth = readBrokerToken(this.coordinates.leasePath);
+        if (!auth) await wait(25);
+      }
+      if (!auth) throw new Error('Microi shared broker lease is unavailable');
       const id = `router-${process.pid}-${++requestSequence}`;
       const response = new Promise((resolve, reject) => this.pending.set(id, { resolve, reject }));
-      this.write({ jsonrpc: '2.0', id, method, params });
+      this.socket.write(`${JSON.stringify({
+        id,
+        auth,
+        type: 'request',
+        profile: { ...profile, applicationsDir: buildApplicationsDir(profile) },
+        method,
+        params,
+      })}\n`);
       return response;
     })();
   }
 
-  notify(method, params) {
-    this.write({ jsonrpc: '2.0', method, params });
+  close() {
+    try { this.socket?.end(); } catch { /* best effort */ }
   }
+}
 
-  stop() {
-    try { this.child?.stdin.end(); } catch { /* best effort */ }
-    try { this.child?.kill('SIGTERM'); } catch { /* best effort */ }
-  }
+function sharedBroker(profile) {
+  if (!brokerClient || brokerClient.closed) brokerClient = new SharedBrokerClient({ workspaceRoot: profile.workspaceRoot });
+  return brokerClient;
 }
 
-function childFor(profile) {
-  const existing = children.get(profile.identity);
-  if (existing) return existing;
-  const child = new ChildMcp(profile);
-  children.set(profile.identity, child);
-  return child;
+function requestThroughBroker(profile, method, params) {
+  return sharedBroker(profile).request(profile, method, params);
 }
 
 function resultText(value, isError = false) {
@@ -378,7 +431,7 @@ async function callRouterTool(args) {
   }
   try {
     const profile = selectProfile(args?.profile);
-    return await childFor(profile).request('tools/call', {
+    return await requestThroughBroker(profile, 'tools/call', {
       name: 'microi_codex',
       arguments: { action, params: args?.params || {} },
     });
@@ -421,7 +474,7 @@ async function readResource(uri) {
     const raw = decodeURIComponent(match[4] || '');
     params = raw ? JSON.parse(raw) : {};
   }
-  const result = await childFor(profile).request('tools/call', {
+  const result = await requestThroughBroker(profile, 'tools/call', {
     name: 'microi_codex',
     arguments: { action, params },
   });
@@ -482,8 +535,8 @@ async function handle(message) {
 function shutdown() {
   if (shuttingDown) return;
   shuttingDown = true;
-  for (const child of children.values()) child.stop();
-  children.clear();
+  brokerClient?.close();
+  brokerClient = null;
 }
 
 process.stdin.setEncoding('utf8');
@@ -506,5 +559,16 @@ process.stdin.on('data', chunk => {
 });
 process.stdin.on('end', () => { shutdown(); process.exit(0); });
 process.stdin.on('error', () => { shutdown(); process.exit(1); });
+process.stdout.on('error', error => { shutdown(); process.exit(error?.code === 'EPIPE' ? 0 : 1); });
+process.on('disconnect', () => { shutdown(); process.exit(0); });
 for (const signal of ['SIGINT', 'SIGTERM', 'SIGHUP']) process.on(signal, () => { shutdown(); process.exit(0); });
 process.on('exit', shutdown);
+
+const parentPid = process.ppid;
+if (parentPid > 1) {
+  const parentWatchTimer = setInterval(() => {
+    try { process.kill(parentPid, 0); }
+    catch (error) { if (error?.code === 'ESRCH') { shutdown(); process.exit(0); } }
+  }, 5000);
+  parentWatchTimer.unref();
+}