coding-tool-x 3.7.0 → 3.7.2

package/src/server/services/native-oauth-adapters.js

@@ -2,6 +2,7 @@ const fs = require('fs');
 const path = require('path');
 const os = require('os');
 const crypto = require('crypto');
+const { spawnSync } = require('child_process');
 const toml = require('toml');
 const tomlStringify = require('@iarna/toml').stringify;
 const { NATIVE_PATHS, PATHS } = require('../../config/paths');
@@ -13,7 +14,7 @@ const { syncCodexUserEnvironment } = require('./codex-env-manager');
 const nativeKeychain = require('./native-keychain');
 const { maskToken, decodeJwtPayload, removeFileIfExists, sha256 } = require('./oauth-utils');
 
-const SUPPORTED_TOOLS = ['claude', 'codex', 'gemini', 'opencode'];
+const SUPPORTED_TOOLS = ['claude', 'codex', 'gemini', 'opencode', 'omp'];
 const GEMINI_MAIN_ACCOUNT_KEY = 'main-account';
 const GEMINI_KEYCHAIN_SERVICE = 'gemini-cli-oauth';
 const CODEX_KEYCHAIN_SERVICE = 'Codex Auth';
@@ -1006,6 +1007,202 @@ function inspectOpenCodeState() {
   };
 }
 
+function resolveOmpRuntime() {
+  try {
+    const ompConfig = require('./omp-config');
+    const runtime = ompConfig.resolveOmpRuntime(process.env, {});
+    return runtime && runtime.runtime === 'omp' && runtime.installed ? runtime : null;
+  } catch {
+    return null;
+  }
+}
+
+function runOmpCommand(args = [], options = {}) {
+  const runtime = options.runtime || resolveOmpRuntime();
+  if (!runtime) {
+    return { ok: false, status: 127, stdout: '', stderr: 'OMP CLI not installed' };
+  }
+
+  const result = spawnSync(runtime.command, args, {
+    encoding: 'utf8',
+    env: {
+      ...process.env,
+      ...(options.env || {})
+    },
+    timeout: options.timeout || 10000
+  });
+  const status = result?.status === undefined || result?.status === null ? 0 : result.status;
+  return {
+    ok: !result?.error && status === 0,
+    status,
+    stdout: String(result?.stdout || ''),
+    stderr: String(result?.stderr || ''),
+    error: result?.error || null,
+    command: runtime.command
+  };
+}
+
+function getOmpAuthSnapshot(options = {}) {
+  try {
+    const { getOmpAuthProviderSnapshot } = require('./omp-auth-providers');
+    return getOmpAuthProviderSnapshot({
+      accountCheck: true,
+      includeStatus: false,
+      ...options
+    });
+  } catch {
+    return null;
+  }
+}
+
+function readAllOmpNativeOAuth() {
+  const snapshot = getOmpAuthSnapshot({ forceRefresh: true });
+  if (!snapshot?.available || !Array.isArray(snapshot.providers)) {
+    return [];
+  }
+
+  return snapshot.providers
+    .filter(provider => provider?.loggedIn || Number(provider?.accountCount || 0) > 0)
+    .flatMap((provider) => {
+      const accounts = Array.isArray(provider.accounts) && provider.accounts.length > 0
+        ? provider.accounts
+        : [{ index: 1, identity: '' }];
+      return accounts.map((account) => ({
+        providerId: provider.id,
+        accountId: String(account.index || '').trim(),
+        accountEmail: String(account.identity || '').trim(),
+        storage: 'auth-broker',
+        primaryToken: ''
+      }));
+    });
+}
+
+function readOmpNativeOAuth() {
+  return readAllOmpNativeOAuth()[0] || null;
+}
+
+function clearOmpOAuth() {
+  const credentials = readAllOmpNativeOAuth();
+  const providerIds = [...new Set(credentials.map(item => item.providerId).filter(Boolean))];
+  providerIds.forEach((providerId) => {
+    runOmpCommand(['auth-broker', 'logout', providerId], { timeout: 10000 });
+  });
+  try {
+    require('./omp-auth-providers').clearOmpAuthProviderCache();
+  } catch {
+    // cache invalidation is best-effort
+  }
+}
+
+function disableOmpOAuthCredential(credential = {}) {
+  const providerId = String(credential.providerId || '').trim();
+  if (!providerId) {
+    clearOmpOAuth();
+    return;
+  }
+  runOmpCommand(['auth-broker', 'logout', providerId], { timeout: 10000 });
+  try {
+    require('./omp-auth-providers').clearOmpAuthProviderCache();
+  } catch {
+    // cache invalidation is best-effort
+  }
+}
+
+function buildOmpImportPayload(credential = {}) {
+  if (credential.importPayload && typeof credential.importPayload === 'object') {
+    return credential.importPayload;
+  }
+
+  const access = String(credential.accessToken || credential.primaryToken || '').trim();
+  if (!access) {
+    return null;
+  }
+
+  return {
+    provider: credential.providerId,
+    credential_type: credential.credentialType || 'oauth',
+    identity_key: credential.identityKey || credential.accountId || credential.accountEmail || undefined,
+    data: {
+      access,
+      refresh: credential.refreshToken || '',
+      expires: credential.expiresAt || null,
+      accountId: credential.accountId || undefined,
+      accountEmail: credential.accountEmail || undefined
+    }
+  };
+}
+
+function hasOmpNativeCredential(providerId) {
+  return readAllOmpNativeOAuth().some((entry) => (
+    !providerId || entry.providerId === providerId
+  ));
+}
+
+function applyOmpOAuth(credential = {}) {
+  const providerId = String(credential.providerId || '').trim();
+  if (!providerId) {
+    throw new Error('OMP OAuth credential requires providerId');
+  }
+
+  const payload = buildOmpImportPayload(credential);
+  if (!payload) {
+    if (hasOmpNativeCredential(providerId)) {
+      return { storage: 'auth-broker-existing' };
+    }
+    throw new Error('OMP OAuth credential requires an import payload or access token');
+  }
+
+  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'ctx-omp-oauth-'));
+  const tempPath = path.join(tempDir, `${providerId}.json`);
+  try {
+    fs.writeFileSync(tempPath, JSON.stringify(payload, null, 2), 'utf8');
+    ensureFileMode(tempPath);
+    const result = runOmpCommand(['auth-broker', 'import', tempPath, '--provider', providerId], { timeout: 15000 });
+    if (!result.ok) {
+      const detail = result.stderr.trim() || result.stdout.trim() || result.error?.message || `exit code ${result.status}`;
+      throw new Error(`OMP auth-broker import failed: ${detail}`);
+    }
+    try {
+      require('./omp-auth-providers').clearOmpAuthProviderCache();
+    } catch {
+      // cache invalidation is best-effort
+    }
+    return { storage: 'auth-broker' };
+  } finally {
+    try {
+      removeFileIfExists(tempPath);
+      fs.rmSync(tempDir, { recursive: true, force: true });
+    } catch {
+      // ignore cleanup failures
+    }
+  }
+}
+
+function inspectOmpState() {
+  const { getOmpProxyStatus } = require('../omp-proxy-server');
+  const { isManagedOmpProvidersActive } = require('./omp-settings-manager');
+  const proxyStatus = getOmpProxyStatus();
+  const nativeCredentials = readAllOmpNativeOAuth();
+
+  let channelConfigured = false;
+  try {
+    channelConfigured = Boolean(isManagedOmpProvidersActive());
+  } catch {
+    channelConfigured = false;
+  }
+
+  return {
+    tool: 'omp',
+    mode: proxyStatus.running || channelConfigured
+      ? 'proxy'
+      : (nativeCredentials.length > 0 ? 'oauth' : 'idle'),
+    proxyRunning: Boolean(proxyStatus.running || channelConfigured),
+    oauthPresent: nativeCredentials.length > 0,
+    channelConfigured,
+    nativeCredential: nativeCredentials[0] ? buildNativeSummary(nativeCredentials[0]) : null
+  };
+}
+
 function inspectTool(tool) {
   switch (tool) {
     case 'claude':
@@ -1016,6 +1213,8 @@ function inspectTool(tool) {
       return inspectGeminiState();
     case 'opencode':
       return inspectOpenCodeState();
+    case 'omp':
+      return inspectOmpState();
     default:
       throw new Error(`Unsupported OAuth tool: ${tool}`);
   }
@@ -1031,6 +1230,8 @@ function readNativeOAuth(tool) {
       return readGeminiNativeOAuth();
     case 'opencode':
       return readOpenCodeNativeOAuth();
+    case 'omp':
+      return readOmpNativeOAuth();
     default:
       throw new Error(`Unsupported OAuth tool: ${tool}`);
   }
@@ -1052,6 +1253,8 @@ function readAllNativeOAuth(tool) {
     }
     case 'opencode':
       return readAllOpenCodeNativeOAuth();
+    case 'omp':
+      return readAllOmpNativeOAuth();
     default:
       throw new Error(`Unsupported OAuth tool: ${tool}`);
   }
@@ -1071,6 +1274,9 @@ function clearNativeOAuth(tool) {
     case 'opencode':
       clearOpenCodeOAuth();
       return;
+    case 'omp':
+      clearOmpOAuth();
+      return;
     default:
       throw new Error(`Unsupported OAuth tool: ${tool}`);
   }
@@ -1090,6 +1296,9 @@ function disableNativeOAuthCredential(tool, credential = {}) {
     case 'opencode':
       disableOpenCodeOAuthCredential(credential);
       return;
+    case 'omp':
+      disableOmpOAuthCredential(credential);
+      return;
     default:
       throw new Error(`Unsupported OAuth tool: ${tool}`);
   }
@@ -1105,6 +1314,8 @@ function applyOAuthCredential(tool, credential) {
       return applyGeminiOAuth(credential);
     case 'opencode':
       return applyOpenCodeOAuth(credential);
+    case 'omp':
+      return applyOmpOAuth(credential);
     default:
       throw new Error(`Unsupported OAuth tool: ${tool}`);
   }

package/src/server/services/network-access.js

@@ -72,6 +72,10 @@ function createRemoteMutationGuard(options = {}) {
   };
 }
 
+function isRemoteMutationAllowedByEnv(env = process.env) {
+  return String(env.CC_TOOL_ALLOW_REMOTE_WRITE || '').toLowerCase() !== 'false';
+}
+
 function createRemoteRouteGuard(options = {}) {
   const enabled = options.enabled === true;
   const allowRemoteAccess = options.allowRemoteAccess === true;
@@ -113,6 +117,7 @@ module.exports = {
   isLoopbackRequest,
   isSameOriginRequest,
   createRemoteMutationGuard,
+  isRemoteMutationAllowedByEnv,
   createRemoteRouteGuard,
   createSameOriginGuard
 };

package/src/server/services/notification-hooks.js

@@ -13,6 +13,7 @@ const geminiSettingsManager = require('./gemini-settings-manager');
 
 const MANAGED_HOOK_NAME = 'coding-tool-notify';
 const MANAGED_OPENCODE_PLUGIN_FILE = 'coding-tool-notify.js';
+const MANAGED_OMP_EXTENSION_FILE = 'coding-tool-notify.ts';
 const REMOTE_PROVIDER_TYPES = [
   'wechatBot',
   'qqBot',
@@ -371,6 +372,13 @@ function getOpenCodeManagedPluginPath() {
   return path.join(NATIVE_PATHS.opencode.config, 'plugins', MANAGED_OPENCODE_PLUGIN_FILE);
 }
 
+function getOmpManagedExtensionPath() {
+  const ompPaths = NATIVE_PATHS.omp || {};
+  const extensionsDir = ompPaths.extensions ||
+    path.join(ompPaths.dir || path.dirname(ompPaths.settings || PATHS.notifyHook), 'extensions');
+  return path.join(extensionsDir, MANAGED_OMP_EXTENSION_FILE);
+}
+
 function buildOpenCodePluginContent(type) {
   const mode = normalizeType(type);
   return `// Managed by Coding Tool. Do not edit manually.
@@ -410,6 +418,64 @@ export const CodingToolNotifyPlugin = async () => ({
 `;
 }
 
+function buildOmpExtensionContent(type) {
+  const mode = normalizeType(type);
+  return `// Managed by Coding Tool. Do not edit manually.
+// mode:${mode}
+import { spawn } from 'node:child_process'
+
+const SCRIPT_PATH = ${JSON.stringify(PATHS.notifyHook)}
+const MODE = ${JSON.stringify(mode)}
+let lastFireAt = 0
+
+function shouldFire() {
+  const now = Date.now()
+  if (now - lastFireAt < 1000) {
+    return false
+  }
+  lastFireAt = now
+  return true
+}
+
+function fire(eventType) {
+  if (!shouldFire()) {
+    return
+  }
+
+  try {
+    const child = spawn('node', [
+      SCRIPT_PATH,
+      '--source=omp',
+      \`--mode=\${MODE}\`,
+      \`--cc-notify-type=\${MODE}\`,
+      \`--event-type=\${eventType}\`
+    ], {
+      detached: true,
+      stdio: 'ignore',
+      windowsHide: true
+    })
+    child.unref()
+  } catch (error) {
+    // Ignore notification failures.
+  }
+}
+
+export default async function CodingToolNotifyExtension(omp) {
+  const register = (eventName) => {
+    if (typeof omp?.on !== 'function') {
+      return
+    }
+    omp.on(eventName, async () => {
+      fire(eventName)
+    })
+  }
+
+  register('agent_settled')
+  register('turn_end')
+}
+`;
+}
+
 function escapeForAppleScript(value) {
   return String(value || '').replace(/\\/g, '\\\\').replace(/"/g, '\\"');
 }
@@ -712,6 +778,10 @@ function resolveMessage(source, eventType, payload) {
     return 'OpenCode 响应已完成 | 等待交互'
   }
 
+  if (source === 'omp') {
+    return 'OMP 回合已完成 | 等待交互'
+  }
+
   return 'Claude Code 任务已完成 | 等待交互'
 }
 
@@ -886,12 +956,17 @@ function sendTelegramMessage(config = {}, ctx, send = postJson) {
   return send(url, payload, {}, agent ? { agent } : {})
 }
 
+function resolveDisplaySource(source) {
+  if (source === 'omp') return 'OMP'
+  return source
+}
+
 function buildNotificationContext(message, source, eventType) {
   const timestamp = new Date().toLocaleString('zh-CN')
   return {
     title: 'Coding Tool - 通知',
     message,
-    source,
+    source: resolveDisplaySource(source),
     eventType,
     timestamp,
     hostname: os.hostname()
@@ -1545,6 +1620,24 @@ function parseOpenCodeNotificationStatus(content = '') {
   };
 }
 
+function parseOmpNotificationStatus(content = '') {
+  if (!content) {
+    return {
+      enabled: false,
+      external: false,
+      type: 'notification',
+      method: 'Extension Events'
+    };
+  }
+
+  return {
+    enabled: true,
+    external: false,
+    type: parseManagedType(content) || 'notification',
+    method: 'Extension Events'
+  };
+}
+
 function getOpenCodeHookStatus() {
   const pluginPath = getOpenCodeManagedPluginPath();
   if (!fs.existsSync(pluginPath)) {
@@ -1554,6 +1647,15 @@ function getOpenCodeHookStatus() {
   return parseOpenCodeNotificationStatus(fs.readFileSync(pluginPath, 'utf8'));
 }
 
+function getOmpHookStatus() {
+  const extensionPath = getOmpManagedExtensionPath();
+  if (!fs.existsSync(extensionPath)) {
+    return parseOmpNotificationStatus('');
+  }
+
+  return parseOmpNotificationStatus(fs.readFileSync(extensionPath, 'utf8'));
+}
+
 function saveOpenCodeHook(enabled, type) {
   const pluginPath = getOpenCodeManagedPluginPath();
   const opencodeSettingsManager = require('./opencode-settings-manager');
@@ -1608,6 +1710,20 @@ function saveOpenCodeHook(enabled, type) {
   }
 }
 
+function saveOmpHook(enabled, type) {
+  const extensionPath = getOmpManagedExtensionPath();
+
+  if (!enabled) {
+    if (fs.existsSync(extensionPath)) {
+      fs.unlinkSync(extensionPath);
+    }
+    return;
+  }
+
+  ensureParentDir(extensionPath);
+  fs.writeFileSync(extensionPath, buildOmpExtensionContent(type), 'utf8');
+}
+
 function getNotificationSettings() {
   const uiConfig = loadUIConfig();
   const remoteNotifications = getRemoteNotificationsConfig(uiConfig);
@@ -1623,7 +1739,8 @@ function getNotificationSettings() {
       claude: getClaudeHookStatus(),
       codex: getCodexHookStatus(),
       gemini: getGeminiHookStatus(),
-      opencode: getOpenCodeHookStatus()
+      opencode: getOpenCodeHookStatus(),
+      omp: getOmpHookStatus()
     }
   };
 }
@@ -1643,6 +1760,8 @@ function resolveBrowserNotificationTitle(source = 'claude') {
       return 'Gemini CLI';
     case 'opencode':
       return 'OpenCode';
+    case 'omp':
+      return 'OMP';
     default:
       return 'Claude Code';
   }
@@ -1656,6 +1775,8 @@ function resolveBrowserNotificationUrl(source = 'claude') {
       return '/gemini';
     case 'opencode':
       return '/opencode';
+    case 'omp':
+      return '/omp';
     default:
       return '/claude';
   }
@@ -1694,7 +1815,8 @@ function saveNotificationSettings(input = {}) {
     claude: normalizePlatformInput(input?.platforms?.claude),
     codex: normalizePlatformInput(input?.platforms?.codex),
     gemini: normalizePlatformInput(input?.platforms?.gemini),
-    opencode: normalizePlatformInput(input?.platforms?.opencode)
+    opencode: normalizePlatformInput(input?.platforms?.opencode),
+    omp: normalizePlatformInput(input?.platforms?.omp)
   };
 
   saveNotificationUiConfig(remoteNotifications, platforms.claude.enabled);
@@ -1708,6 +1830,7 @@ function saveNotificationSettings(input = {}) {
   saveCodexHook(platforms.codex.enabled, platforms.codex.type);
   saveGeminiHook(platforms.gemini.enabled, platforms.gemini.type);
   saveOpenCodeHook(platforms.opencode.enabled, platforms.opencode.type);
+  saveOmpHook(platforms.omp.enabled, platforms.omp.type);
 
   if (!hasManagedPlatform) {
     removeNotifyScript();
@@ -1834,7 +1957,8 @@ function buildLegacyClaudeSaveInput(input = {}, currentSettings = getNotificatio
         : { enabled: false, type: 'notification' },
       codex: normalizeSavedPlatformStatus(currentSettings?.platforms?.codex),
       gemini: normalizeSavedPlatformStatus(currentSettings?.platforms?.gemini),
-      opencode: normalizeSavedPlatformStatus(currentSettings?.platforms?.opencode)
+      opencode: normalizeSavedPlatformStatus(currentSettings?.platforms?.opencode),
+      omp: normalizeSavedPlatformStatus(currentSettings?.platforms?.omp)
     },
     remoteNotifications: currentSettings?.remoteNotifications || { providers: [] }
   };
@@ -1873,7 +1997,8 @@ function initDefaultHooks() {
             claude: { enabled: true, type: currentStatus.type || 'notification' },
             codex: normalizeSavedPlatformStatus(currentSettings?.platforms?.codex),
             gemini: normalizeSavedPlatformStatus(currentSettings?.platforms?.gemini),
-            opencode: normalizeSavedPlatformStatus(currentSettings?.platforms?.opencode)
+            opencode: normalizeSavedPlatformStatus(currentSettings?.platforms?.opencode),
+            omp: normalizeSavedPlatformStatus(currentSettings?.platforms?.omp)
           },
           remoteNotifications: currentSettings?.remoteNotifications || { providers: [] }
         });
@@ -1890,7 +2015,8 @@ function initDefaultHooks() {
         claude: { enabled: true, type: 'notification' },
         codex: normalizeSavedPlatformStatus(currentSettings?.platforms?.codex),
         gemini: normalizeSavedPlatformStatus(currentSettings?.platforms?.gemini),
-        opencode: normalizeSavedPlatformStatus(currentSettings?.platforms?.opencode)
+        opencode: normalizeSavedPlatformStatus(currentSettings?.platforms?.opencode),
+        omp: normalizeSavedPlatformStatus(currentSettings?.platforms?.omp)
       },
       remoteNotifications: currentSettings?.remoteNotifications || { providers: [] }
     });
@@ -2277,7 +2403,9 @@ module.exports = {
   initDefaultHooks,
   syncManagedNotificationAssets,
   getOpenCodeManagedPluginPath,
+  getOmpManagedExtensionPath,
   buildOpenCodePluginContent,
+  buildOmpExtensionContent,
   buildCodexNotifyCommand,
   writeNotifyScript,
   generateNotifyScript,
@@ -2292,9 +2420,11 @@ module.exports = {
     getCodexHookStatus,
     getGeminiHookStatus,
     getOpenCodeHookStatus,
+    getOmpHookStatus,
     parseCodexNotificationStatus,
     parseGeminiNotificationStatus,
     parseOpenCodeNotificationStatus,
+    parseOmpNotificationStatus,
     validateFeishuWebhookUrl,
     normalizeRemoteNotificationsConfig,
     validateRemoteProviderConfig,
@@ -2303,7 +2433,9 @@ module.exports = {
     buildStopHookCommand,
     buildClaudeCommand,
     buildOpenCodePluginContent,
+    buildOmpExtensionContent,
     getOpenCodeManagedPluginPath,
+    getOmpManagedExtensionPath,
     generateNotifyScript,
     generateSystemNotificationCommand,
     emitBrowserNotification,