@microi.net/cli 4.7.7 → 4.8.1

package/scripts/microi-codex-router.js

@@ -0,0 +1,480 @@
+#!/usr/bin/env node
+/*
+ * Microi Codex Plugin 多连接路由器。
+ *
+ * 它只负责发现 VS Code/CLI 共用的工作区配置、选择连接并把请求转发给
+ * 同一份 Microi MCP bundle。所有业务 schema、确认口令、审计和写后回读
+ * 都由原 MCP 工具执行，本文件不实现第二套远端 API。
+ */
+
+const childProcess = require('node:child_process');
+const crypto = require('node:crypto');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+
+const CONFIG_DIR = 'Microi-V8-Engine';
+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 packagePath = path.join(pluginRoot, 'package.json');
+const pluginVersion = readJson(packagePath, {}).version || '0.0.0';
+const children = new Map();
+let inputBuffer = '';
+let requestSequence = 0;
+let shuttingDown = false;
+
+function readJson(filePath, fallback) {
+  try {
+    const parsed = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+    return parsed && typeof parsed === 'object' && !Array.isArray(parsed) ? parsed : fallback;
+  } catch {
+    return fallback;
+  }
+}
+
+function normalizeUrl(value) {
+  return String(value || '').trim().replace(/\/+$/, '');
+}
+
+function safeName(value) {
+  return String(value || '').normalize('NFKD').replace(/[^\x00-\x7F]/g, '')
+    .replace(/[^A-Za-z0-9_]+/g, '_').replace(/_+/g, '_')
+    .replace(/^_+|_+$/g, '').toLowerCase().slice(0, 48);
+}
+
+function hostPart(profile) {
+  try { return safeName(new URL(profile.apiBaseUrl).host); } catch { return safeName(profile.apiBaseUrl); }
+}
+
+function profileIdentity(profile) {
+  return [
+    normalizeUrl(profile.apiBaseUrl),
+    String(profile.osClient || '').trim(),
+    String(profile.osClientType || '').trim(),
+    String(profile.osClientNetwork || '').trim(),
+  ].join('|');
+}
+
+function candidateRoots() {
+  const values = [
+    process.env.MICROI_WORKSPACE_ROOT,
+    process.env.CODEX_WORKSPACE_ROOT,
+    process.env.INIT_CWD,
+    process.cwd(),
+  ].filter(Boolean).map(value => path.resolve(value));
+  const roots = [];
+  for (const start of values) {
+    let current = start;
+    while (current && !roots.includes(current)) {
+      roots.push(current);
+      const parent = path.dirname(current);
+      if (parent === current) break;
+      current = parent;
+    }
+  }
+  return roots;
+}
+
+function resolveWorkspace() {
+  const explicitConfig = process.env.MICROI_CONFIG_PATH
+    ? path.resolve(process.env.MICROI_CONFIG_PATH)
+    : '';
+  const candidates = explicitConfig
+    ? [explicitConfig]
+    : candidateRoots().flatMap(root => [
+      path.join(root, CONFIG_DIR, CONFIG_FILE),
+      path.join(root, CONFIG_DIR.toLowerCase(), CONFIG_FILE),
+    ]);
+  const configPath = candidates.find(filePath => fs.existsSync(filePath));
+  const fallbackRoot = path.resolve(process.env.MICROI_WORKSPACE_ROOT || process.cwd());
+  if (!configPath) {
+    return {
+      workspaceRoot: fallbackRoot,
+      syncRoot: path.join(fallbackRoot, CONFIG_DIR),
+      configPath: path.join(fallbackRoot, CONFIG_DIR, CONFIG_FILE),
+      tokenPath: path.join(fallbackRoot, CONFIG_DIR, TOKEN_FILE),
+      config: {},
+    };
+  }
+  const syncRoot = path.dirname(configPath);
+  return {
+    workspaceRoot: path.dirname(syncRoot),
+    syncRoot,
+    configPath,
+    tokenPath: path.join(syncRoot, TOKEN_FILE),
+    config: readJson(configPath, {}),
+  };
+}
+
+function loadProfiles() {
+  const workspace = resolveWorkspace();
+  const configured = Array.isArray(workspace.config.profiles)
+    ? workspace.config.profiles
+    : [];
+  const rawProfiles = configured.length > 0
+    ? configured
+    : (workspace.config.apiBaseUrl ? [{
+      label: workspace.config.osClient || workspace.config.apiBaseUrl,
+      apiBaseUrl: workspace.config.apiBaseUrl,
+      osClient: workspace.config.osClient || '',
+    }] : []);
+  const tokens = readJson(workspace.tokenPath, {});
+  const identityNames = rawProfiles.map(profile => safeName(profile.osClient || profile.label) || hostPart(profile) || 'default');
+  const counts = identityNames.reduce((map, name) => map.set(name, (map.get(name) || 0) + 1), new Map());
+  const used = new Set();
+  const profiles = rawProfiles.filter(profile => /^https?:\/\//i.test(String(profile.apiBaseUrl || ''))).map((raw, index) => {
+    const profile = {
+      label: String(raw.label || raw.sysShortTitle || raw.sysTitle || raw.osClient || raw.apiBaseUrl || ''),
+      apiBaseUrl: normalizeUrl(raw.apiBaseUrl),
+      osClient: String(raw.osClient || '').trim(),
+      osClientType: String(raw.osClientType || '').trim(),
+      osClientNetwork: String(raw.osClientNetwork || '').trim(),
+    };
+    const identityName = identityNames[index];
+    const host = hostPart(profile);
+    const base = `microi_${identityName}`;
+    let name = counts.get(identityName) > 1 && host && host !== identityName ? `${base}_${host}` : base;
+    if (used.has(name) && host) name = `${base}_${host}`;
+    let suffix = 2;
+    while (used.has(name)) name = `${base}_${suffix++}`;
+    used.add(name);
+    const exactKey = profileIdentity(profile);
+    const legacyKey = profile.osClient ? `${profile.apiBaseUrl}|${profile.osClient}` : profile.apiBaseUrl;
+    return {
+      ...profile,
+      index: index + 1,
+      name,
+      identity: exactKey,
+      loggedIn: typeof tokens[exactKey] === 'string' || typeof tokens[legacyKey] === 'string',
+      workspaceRoot: workspace.workspaceRoot,
+      syncRoot: workspace.syncRoot,
+      tokenPath: workspace.tokenPath,
+    };
+  });
+  return { workspace, profiles };
+}
+
+function publicProfile(profile) {
+  return {
+    index: profile.index,
+    name: profile.name,
+    label: profile.label,
+    apiBaseUrl: profile.apiBaseUrl,
+    osClient: profile.osClient,
+    osClientType: profile.osClientType,
+    osClientNetwork: profile.osClientNetwork,
+    loggedIn: profile.loggedIn,
+  };
+}
+
+function selectProfile(selector) {
+  const state = loadProfiles();
+  if (state.profiles.length === 0) {
+    throw new Error(`当前工作区尚未初始化 Microi。请在 ${state.workspace.workspaceRoot} 运行 bundled CLI 的 init 命令。`);
+  }
+  const raw = String(selector || '').trim();
+  if (raw) {
+    const lower = raw.toLowerCase();
+    const matches = state.profiles.filter(profile =>
+      String(profile.index) === raw
+      || profile.name.toLowerCase() === lower
+      || profile.osClient.toLowerCase() === lower
+      || profile.label.toLowerCase() === lower
+      || profile.identity.toLowerCase() === lower
+    );
+    if (matches.length === 1) return matches[0];
+    if (matches.length > 1) throw new Error(`连接选择“${raw}”存在歧义，请改用 profiles 返回的 name。`);
+    throw new Error(`未找到连接“${raw}”。可用连接：${state.profiles.map(item => item.name).join(', ')}`);
+  }
+  const loggedIn = state.profiles.filter(profile => profile.loggedIn);
+  if (loggedIn.length === 1) return loggedIn[0];
+  if (state.profiles.length === 1) return state.profiles[0];
+  throw new Error(`当前工作区有 ${state.profiles.length} 个 Microi 连接，请先调用 action="profiles"，再传 profile=name。`);
+}
+
+function buildApplicationsDir(profile) {
+  const title = profile.label || profile.apiBaseUrl || 'Microi';
+  const serverDir = `${title} (${hostPart(profile) || 'server'})`.replace(/[<>:"/\\|?*]/g, '_');
+  const osClientDir = [profile.osClient || 'default', profile.osClientType || 'default', profile.osClientNetwork || 'default']
+    .join('.').replace(/[<>:"/\\|?*]/g, '_');
+  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)}`;
+}
+
+class ChildMcp {
+  constructor(profile) {
+    this.profile = profile;
+    this.pending = new Map();
+    this.buffer = '';
+    this.ready = this.start();
+  }
+
+  async start() {
+    if (!fs.existsSync(mcpServerPath)) {
+      throw new Error(`Codex Plugin 缺少 MCP bundle：${mcpServerPath}`);
+    }
+    this.child = childProcess.spawn(process.execPath, [mcpServerPath], {
+      cwd: this.profile.workspaceRoot,
+      windowsHide: true,
+      stdio: ['pipe', 'pipe', 'pipe'],
+      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_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', {});
+  }
+
+  onData(chunk) {
+    this.buffer += chunk.toString('utf8');
+    let newline;
+    while ((newline = this.buffer.indexOf('\n')) >= 0) {
+      const line = this.buffer.slice(0, newline).trim();
+      this.buffer = this.buffer.slice(newline + 1);
+      if (!line) continue;
+      let message;
+      try { message = JSON.parse(line); } catch { continue; }
+      if (message.id == null) continue;
+      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)));
+      else pending.resolve(message.result);
+    }
+  }
+
+  rejectAll(error) {
+    for (const pending of this.pending.values()) pending.reject(error);
+    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) {
+    return (async () => {
+      if (!skipReady) await this.ready;
+      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 });
+      return response;
+    })();
+  }
+
+  notify(method, params) {
+    this.write({ jsonrpc: '2.0', method, params });
+  }
+
+  stop() {
+    try { this.child?.stdin.end(); } catch { /* best effort */ }
+    try { this.child?.kill('SIGTERM'); } catch { /* best effort */ }
+  }
+}
+
+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 resultText(value, isError = false) {
+  return {
+    content: [{ type: 'text', text: typeof value === 'string' ? value : JSON.stringify(value, null, 2) }],
+    ...(isError ? { isError: true } : {}),
+  };
+}
+
+function toolCatalog() {
+  return [{
+    name: 'microi_codex',
+    description: 'Microi吾码统一入口。先用 action="profiles" 查看当前工作区连接；多连接时传 profile=name。其余 action 为 list_tools、describe_tool 或任意原始 microi_* 工具，全部复用原工具验证、确认、审计和回读。',
+    inputSchema: {
+      type: 'object',
+      additionalProperties: false,
+      required: ['action'],
+      properties: {
+        profile: { type: 'string', description: '可选：profiles 返回的 name、序号、OsClient 或连接名称。多连接时必填。' },
+        action: { type: 'string', description: 'profiles | list_tools | describe_tool | 任意原始 microi_* 工具名' },
+        params: { type: 'object', additionalProperties: true, description: '所选 action 的参数。' },
+      },
+    },
+  }];
+}
+
+async function callRouterTool(args) {
+  const action = String(args?.action || '').trim();
+  if (!action) return resultText('action 不能为空', true);
+  if (action === 'profiles' || action === 'profile_list') {
+    const state = loadProfiles();
+    return resultText({
+      workspace: state.workspace.workspaceRoot,
+      configPath: state.workspace.configPath,
+      count: state.profiles.length,
+      profiles: state.profiles.map(publicProfile),
+      next: state.profiles.length > 1 ? '后续调用请传 profile=name。' : '后续调用可省略 profile。',
+    });
+  }
+  try {
+    const profile = selectProfile(args?.profile);
+    return await childFor(profile).request('tools/call', {
+      name: 'microi_codex',
+      arguments: { action, params: args?.params || {} },
+    });
+  } catch (error) {
+    return resultText(`Microi Codex 路由失败：${error instanceof Error ? error.message : String(error)}`, true);
+  }
+}
+
+function resourceList() {
+  const state = loadProfiles();
+  return [{
+    uri: 'microi://codex/profiles',
+    name: 'microi_profiles',
+    title: 'Microi connection profiles',
+    description: '当前工作区 Microi 连接与登录状态。',
+    mimeType: 'application/json',
+  }, ...state.profiles.flatMap(profile => ['status', 'tools'].map(kind => ({
+    uri: `microi://codex/${encodeURIComponent(profile.name)}/${kind}`,
+    name: `microi_${profile.name}_${kind}`,
+    title: `Microi ${profile.label || profile.name} ${kind}`,
+    description: kind === 'status' ? '只读连接状态。' : '该连接的原始工具目录。',
+    mimeType: 'application/json',
+  })))];
+}
+
+async function readResource(uri) {
+  if (uri === 'microi://codex/profiles') {
+    const state = loadProfiles();
+    return { contents: [{ uri, mimeType: 'application/json', text: JSON.stringify({ profiles: state.profiles.map(publicProfile) }, null, 2) }] };
+  }
+  const match = /^microi:\/\/codex\/([^/]+)\/(status|tools|action\/([^/]+)\/(.*))$/.exec(uri);
+  if (!match) throw new Error(`不支持的 Microi 资源 URI：${uri}`);
+  const profile = selectProfile(decodeURIComponent(match[1]));
+  let action;
+  let params = {};
+  if (match[2] === 'status') action = 'microi_get_status';
+  else if (match[2] === 'tools') action = 'list_tools';
+  else {
+    action = decodeURIComponent(match[3]);
+    const raw = decodeURIComponent(match[4] || '');
+    params = raw ? JSON.parse(raw) : {};
+  }
+  const result = await childFor(profile).request('tools/call', {
+    name: 'microi_codex',
+    arguments: { action, params },
+  });
+  return { contents: [{ uri, mimeType: 'application/json', text: JSON.stringify(result, null, 2) }] };
+}
+
+function send(message) {
+  process.stdout.write(`${JSON.stringify(message)}\n`);
+}
+
+function sendResult(id, result) {
+  send({ jsonrpc: '2.0', id, result });
+}
+
+function sendError(id, code, message) {
+  send({ jsonrpc: '2.0', id, error: { code, message } });
+}
+
+async function handle(message) {
+  if (!message || message.jsonrpc !== '2.0') return;
+  const { id, method, params } = message;
+  if (method === 'initialize') {
+    sendResult(id, {
+      protocolVersion: params?.protocolVersion || PROTOCOL_VERSION,
+      capabilities: { tools: {}, resources: {} },
+      serverInfo: { name: 'Microi-Codex-Plugin', version: pluginVersion },
+      instructions: '先调用 microi_codex action="profiles"；多连接时把返回的 name 作为 profile。所有业务动作由同源 Microi MCP 工具处理。',
+    });
+    return;
+  }
+  if (method === 'ping') { sendResult(id, {}); return; }
+  if (method === 'tools/list') { sendResult(id, { tools: toolCatalog() }); return; }
+  if (method === 'tools/call') {
+    if (params?.name !== 'microi_codex') { sendResult(id, resultText(`Unknown tool: ${params?.name || '(empty)'}`, true)); return; }
+    sendResult(id, await callRouterTool(params.arguments || {})); return;
+  }
+  if (method === 'resources/list') { sendResult(id, { resources: resourceList() }); return; }
+  if (method === 'resources/templates/list') {
+    sendResult(id, { resourceTemplates: [{
+      uriTemplate: 'microi://codex/{profile}/action/{action}/{params}',
+      name: 'microi_codex_action',
+      title: 'Microi action fallback',
+      description: '工具未注入时，按连接路由到同一原始 Microi 工具。params 是 URI 编码 JSON 对象。',
+      mimeType: 'application/json',
+    }] });
+    return;
+  }
+  if (method === 'resources/read') {
+    try { sendResult(id, await readResource(String(params?.uri || ''))); }
+    catch (error) { sendError(id, -32002, error instanceof Error ? error.message : String(error)); }
+    return;
+  }
+  if (method === 'shutdown') { sendResult(id, {}); shutdown(); return; }
+  if (method?.startsWith('notifications/')) return;
+  if (id != null) sendError(id, -32601, `Method not found: ${method}`);
+}
+
+function shutdown() {
+  if (shuttingDown) return;
+  shuttingDown = true;
+  for (const child of children.values()) child.stop();
+  children.clear();
+}
+
+process.stdin.setEncoding('utf8');
+process.stdin.on('data', chunk => {
+  inputBuffer += chunk;
+  let newline;
+  while ((newline = inputBuffer.indexOf('\n')) >= 0) {
+    const line = inputBuffer.slice(0, newline).trim();
+    inputBuffer = inputBuffer.slice(newline + 1);
+    if (!line) continue;
+    let message;
+    try { message = JSON.parse(line); }
+    catch { continue; }
+    Promise.resolve(handle(message)).catch(error => {
+      if (message.id != null) sendError(message.id, -32603, error instanceof Error ? error.message : String(error));
+    });
+  }
+});
+process.stdin.on('end', () => { shutdown(); process.exit(0); });
+process.stdin.on('error', () => { shutdown(); process.exit(1); });
+for (const signal of ['SIGINT', 'SIGTERM', 'SIGHUP']) process.on(signal, () => { shutdown(); process.exit(0); });
+process.on('exit', shutdown);