coding-tool-x 3.7.0 → 3.7.2

package/src/server/services/oauth-credentials-service.js

@@ -240,6 +240,70 @@ function parseOpenCodeImport(rawText) {
   };
 }
 
+function pickOmpCredentialEntry(parsed) {
+  if (Array.isArray(parsed)) {
+    return parsed.find(item => item && typeof item === 'object') || null;
+  }
+  if (!parsed || typeof parsed !== 'object') {
+    return null;
+  }
+  if (parsed.provider || parsed.providerId || parsed.provider_id || parsed.providerKey || parsed.credential_type || parsed.data) {
+    return parsed;
+  }
+  const entry = Object.entries(parsed).find(([, value]) => value && typeof value === 'object');
+  return entry ? { provider: entry[0], ...entry[1] } : parsed;
+}
+
+function parseOmpImport(rawText) {
+  const parsed = tryParseJson(rawText);
+  if (!parsed || typeof parsed !== 'object') {
+    throw new Error('OMP OAuth 仅支持 JSON 导入。');
+  }
+
+  const entry = pickOmpCredentialEntry(parsed);
+  if (!entry || typeof entry !== 'object') {
+    throw new Error('OMP OAuth 导入缺少 provider。');
+  }
+
+  const data = entry.data && typeof entry.data === 'object' ? entry.data : entry;
+  const providerId = safeString(
+    entry.providerId
+    || entry.provider_id
+    || entry.providerKey
+    || entry.provider
+    || data.providerId
+    || data.provider
+  );
+  if (!providerId) {
+    throw new Error('OMP OAuth 导入缺少 providerId。');
+  }
+
+  const accessToken = safeString(
+    data.accessToken
+    || data.access_token
+    || data.access
+    || data.token
+    || data.authToken
+  );
+  const credentialType = safeString(entry.credentialType || entry.credential_type || data.type || 'oauth') || 'oauth';
+  if (credentialType === 'oauth' && !accessToken && !entry.data) {
+    throw new Error('OMP OAuth 导入缺少 access/accessToken。');
+  }
+
+  return {
+    providerId,
+    credentialType,
+    accessToken,
+    refreshToken: safeString(data.refreshToken || data.refresh_token || data.refresh),
+    expiresAt: safeNumber(data.expiresAt || data.expiry_date || data.expiryDate || data.expires),
+    accountId: safeString(data.accountId || data.account_id || entry.accountId || entry.account_id),
+    accountEmail: safeString(data.accountEmail || data.email || entry.accountEmail || entry.email),
+    identityKey: safeString(entry.identityKey || entry.identity_key || data.identityKey || data.identity_key),
+    importPayload: parsed,
+    primaryToken: accessToken
+  };
+}
+
 function parseCredentialInput(tool, rawText) {
   switch (tool) {
     case 'claude':
@@ -250,6 +314,8 @@ function parseCredentialInput(tool, rawText) {
       return parseGeminiImport(rawText);
     case 'opencode':
       return parseOpenCodeImport(rawText);
+    case 'omp':
+      return parseOmpImport(rawText);
     default:
       throw new Error(`Unsupported OAuth tool: ${tool}`);
   }
@@ -261,7 +327,7 @@ function buildCredentialName(tool, metadata, providedName = '') {
     return explicit;
   }
 
-  if (tool === 'opencode' && safeString(metadata.providerId)) {
+  if ((tool === 'opencode' || tool === 'omp') && safeString(metadata.providerId)) {
     const accountLabel = safeString(metadata.accountId || metadata.accountEmail);
     return accountLabel
       ? `${tool} - ${metadata.providerId} - ${accountLabel}`
@@ -386,6 +452,19 @@ function extractSecrets(tool, metadata) {
         enterpriseUrl: metadata.enterpriseUrl || '',
         primaryToken: metadata.primaryToken || metadata.accessToken || ''
       };
+    case 'omp':
+      return {
+        providerId: metadata.providerId || '',
+        credentialType: metadata.credentialType || 'oauth',
+        accessToken: metadata.accessToken || '',
+        refreshToken: metadata.refreshToken || '',
+        expiresAt: metadata.expiresAt || null,
+        accountId: metadata.accountId || '',
+        accountEmail: metadata.accountEmail || '',
+        identityKey: metadata.identityKey || '',
+        importPayload: metadata.importPayload || null,
+        primaryToken: metadata.primaryToken || metadata.accessToken || ''
+      };
     default:
       return { primaryToken: metadata.primaryToken || metadata.accessToken || '' };
   }
@@ -395,7 +474,7 @@ function stableFingerprintValue(tool, metadata) {
   // 优先使用稳定标识符，避免 access token 轮换导致重复记录
   const stableId = metadata.accountEmail
     || metadata.accountId
-    || (tool === 'opencode' ? metadata.providerId : '')
+    || ((tool === 'opencode' || tool === 'omp') ? metadata.providerId : '')
     || metadata.refreshToken
     || metadata.primaryToken
     || metadata.accessToken
@@ -559,6 +638,11 @@ function cleanupManagedArtifacts(tool) {
 
   if (tool === 'opencode') {
     opencodeSettingsManager.deleteBackup?.();
+    return;
+  }
+
+  if (tool === 'omp') {
+    return;
   }
 }
 
@@ -597,6 +681,14 @@ async function stopProxyIfRunning(tool) {
       }
       return false;
     }
+    case 'omp': {
+      const { stopOmpProxyServer, getOmpProxyStatus } = require('../omp-proxy-server');
+      if (getOmpProxyStatus().running) {
+        await stopOmpProxyServer();
+        return true;
+      }
+      return false;
+    }
     default:
       throw new Error(`Unsupported OAuth tool: ${tool}`);
   }
@@ -625,6 +717,11 @@ function disableAllChannelsForTool(tool) {
         disableAllChannels();
         break;
       }
+      case 'omp': {
+        const { disableAllChannels } = require('./omp-channels');
+        disableAllChannels();
+        break;
+      }
     }
   } catch (err) {
     console.warn(`[OAuth] Failed to disable channels for ${tool}:`, err.message);
@@ -635,7 +732,7 @@ async function applyStoredCredential(tool, credentialId) {
   const entry = findStoredCredential(tool, credentialId);
   const proxyStopped = await stopProxyIfRunning(tool);
   cleanupManagedArtifacts(tool);
-  if (tool !== 'opencode') {
+  if (tool !== 'opencode' && tool !== 'omp') {
     disableAllChannelsForTool(tool);
   }
   applyOAuthCredential(tool, entry.secrets);
@@ -818,6 +915,16 @@ async function fetchCredentialUsage(tool, credentialId) {
         return await fetchCodexUsage(accessToken);
       }
     }
+    case 'omp': {
+      const providerId = entry.providerId || secrets.providerId || '';
+      if (providerId.includes('claude') || providerId.includes('anthropic')) {
+        return await fetchClaudeUsage(accessToken);
+      } else if (providerId.includes('gemini') || providerId.includes('google')) {
+        return await fetchGeminiUsage(accessToken);
+      } else {
+        return await fetchCodexUsage(accessToken);
+      }
+    }
     default:
       return { error: `不支持的工具: ${tool}` };
   }

package/src/server/services/{pi-auth-providers.js → omp-auth-providers.js}

@@ -1,5 +1,5 @@
 const { spawnSync } = require('child_process');
-const piConfig = require('./pi-config');
+const ompConfig = require('./omp-config');
 
 const COMMAND_TIMEOUT_MS = 5000;
 const TOKEN_LIST_TIMEOUT_MS = 3000;
@@ -214,7 +214,7 @@ function getOmpAuthProviderSnapshot(options = {}) {
   }
 
   const env = options.env || process.env;
-  const runtime = options.runtime || piConfig.resolvePiRuntime(env, options.runtimeOptions || {});
+  const runtime = options.runtime || ompConfig.resolveOmpRuntime(env, options.runtimeOptions || {});
   if (!runtime || runtime.runtime !== 'omp' || !runtime.installed) {
     const value = buildEmptySnapshot(runtime || null, 'omp-not-available');
     snapshotCache[cacheKey] = { loadedAt: now, value };

package/src/server/services/{pi-channels.js → omp-channels.js}

@@ -5,13 +5,13 @@ const {
   removeManagedOmpProviders,
   isManagedOmpProvidersActive,
   getLastManagedOmpSyncResult
-} = require('./pi-settings-manager');
+} = require('./omp-settings-manager');
 
-class PiChannelService extends BaseChannelService {
+class OmpChannelService extends BaseChannelService {
   constructor() {
     super({
-      platform: 'pi',
-      channelsFilePath: PATHS.channels.pi,
+      platform: 'omp',
+      channelsFilePath: PATHS.channels.omp,
       defaultGatewaySource: 'openai_compatible',
       isProxyRunning: () => isManagedOmpProvidersActive()
     });
@@ -21,6 +21,11 @@ class PiChannelService extends BaseChannelService {
     const normalized = super._applyDefaults(channel);
     normalized.providerKey = normalized.providerKey || normalized.provider || normalized.name || normalized.id;
     normalized.providerApi = normalized.providerApi || normalized.api || normalized.wireApi || 'openai-completions';
+    normalized.authMode = normalized.authMode === 'oauth' ? 'oauth' : 'api_key';
+    normalized.oauthProviderId = normalized.oauthProviderId || (normalized.authMode === 'oauth' ? normalized.providerKey : '');
+    if (normalized.authMode === 'oauth') {
+      normalized.apiKey = normalized.apiKey || '';
+    }
     normalized.model = normalized.model || null;
     normalized.models = Array.isArray(normalized.models) ? normalized.models : [];
     normalized.allowedModels = Array.isArray(normalized.allowedModels) ? normalized.allowedModels : [];
@@ -69,7 +74,7 @@ class PiChannelService extends BaseChannelService {
   }
 }
 
-const service = new PiChannelService();
+const service = new OmpChannelService();
 
 module.exports = {
   getChannels: () => service.getChannels(),

package/src/server/services/{pi-config.js → omp-config.js}

@@ -2,10 +2,9 @@ const fs = require('fs');
 const path = require('path');
 const { execFileSync } = require('child_process');
 const yaml = require('js-yaml');
-const { HOME_DIR } = require('../../config/paths');
+const { HOME_DIR, PATHS = {} } = require('../../config/paths');
 
 const DEFAULT_OMP_COMMAND = 'omp';
-const LEGACY_PI_COMMAND = 'pi';
 
 function expandHome(input = '') {
   const value = String(input || '').trim();
@@ -22,10 +21,7 @@ function normalizeProfileName(profile = '') {
 }
 
 function getOmpProfile(env = process.env) {
-  if (env.OMP_PROFILE !== undefined) {
-    return normalizeProfileName(env.OMP_PROFILE);
-  }
-  return normalizeProfileName(env.PI_PROFILE);
+  return normalizeProfileName(env.OMP_PROFILE);
 }
 
 function isAbsolutePathLike(value = '') {
@@ -33,7 +29,7 @@ function isAbsolutePathLike(value = '') {
 }
 
 function getOmpConfigRoot(env = process.env) {
-  const configured = expandHome(env.PI_CONFIG_DIR || '');
+  const configured = expandHome(env.OMP_CONFIG_DIR || '');
   if (!configured) return path.join(HOME_DIR, '.omp');
   return isAbsolutePathLike(configured) ? configured : path.join(HOME_DIR, configured);
 }
@@ -46,14 +42,10 @@ function getDefaultOmpAgentDir(env = process.env) {
     : path.join(configRoot, 'agent');
 }
 
-function getLegacyPiAgentDir() {
-  return path.join(HOME_DIR, '.pi', 'agent');
-}
-
-function getFallbackPiAgentDir(runtime, env = process.env) {
-  const configured = expandHome(env.PI_CODING_AGENT_DIR || '');
+function getFallbackOmpAgentDir(runtime, env = process.env) {
+  const configured = expandHome(env.OMP_CODING_AGENT_DIR || '');
   if (configured) return configured;
-  return runtime?.runtime === 'pi' ? getLegacyPiAgentDir(env) : getDefaultOmpAgentDir(env);
+  return getDefaultOmpAgentDir(env);
 }
 
 function buildCommandEnv(env = process.env) {
@@ -63,7 +55,7 @@ function buildCommandEnv(env = process.env) {
   };
 }
 
-function runPiCommand(command, args = [], env = process.env, options = {}, stdio = ['ignore', 'pipe', 'pipe']) {
+function runOmpCommand(command, args = [], env = process.env, options = {}, stdio = ['ignore', 'pipe', 'pipe']) {
   const runner = options.commandRunner || execFileSync;
   return runner(command, args, {
     encoding: 'utf8',
@@ -75,7 +67,7 @@ function runPiCommand(command, args = [], env = process.env, options = {}, stdio
 
 function readOmpAgentDirFromCommand(command, env = process.env, options = {}) {
   try {
-    const output = runPiCommand(command, ['config', 'path'], env, options);
+    const output = runOmpCommand(command, ['config', 'path'], env, options);
     const agentDir = String(output || '').trim().split(/\r?\n/).find(Boolean);
     return agentDir ? path.resolve(expandHome(agentDir)) : '';
   } catch {
@@ -83,20 +75,20 @@ function readOmpAgentDirFromCommand(command, env = process.env, options = {}) {
   }
 }
 
-function getPiAgentDir(env = process.env, options = {}) {
-  const runtime = options.runtime || resolvePiRuntime(env, options);
+function getOmpAgentDir(env = process.env, options = {}) {
+  const runtime = options.runtime || resolveOmpRuntime(env, options);
   if (runtime.runtime === 'omp' && runtime.installed) {
     const commandAgentDir = readOmpAgentDirFromCommand(runtime.command, env, options);
     if (commandAgentDir) {
       return commandAgentDir;
     }
   }
-  return path.resolve(expandHome(getFallbackPiAgentDir(runtime, env)));
+  return path.resolve(expandHome(getFallbackOmpAgentDir(runtime, env)));
 }
 
-function getPiPaths(env = process.env, options = {}) {
-  const runtime = options.runtime || resolvePiRuntime(env, options);
-  const agentDir = getPiAgentDir(env, { ...options, runtime });
+function getOmpPaths(env = process.env, options = {}) {
+  const runtime = options.runtime || resolveOmpRuntime(env, options);
+  const agentDir = getOmpAgentDir(env, { ...options, runtime });
   return {
     agentDir,
     config: path.join(agentDir, 'config.yml'),
@@ -115,11 +107,12 @@ function getPiPaths(env = process.env, options = {}) {
     extensions: path.join(agentDir, 'extensions'),
     themes: path.join(agentDir, 'themes'),
     packages: path.join(agentDir, 'packages'),
-    managedProviderExtension: path.join(agentDir, 'extensions', 'coding-tool-x-provider.ts')
+    managedProviderExtension: path.join(agentDir, 'extensions', 'coding-tool-x-provider.ts'),
+    managedVisibilityState: path.join(PATHS.storage || path.join(HOME_DIR, '.cc-tool', 'storage'), 'omp-managed-visibility.json')
   };
 }
 
-function ensurePiDir(dirPath) {
+function ensureOmpDir(dirPath) {
   if (!fs.existsSync(dirPath)) {
     fs.mkdirSync(dirPath, { recursive: true });
   }
@@ -136,7 +129,7 @@ function readJsonFile(filePath, fallback = {}) {
 }
 
 function writeJsonFile(filePath, data) {
-  ensurePiDir(path.dirname(filePath));
+  ensureOmpDir(path.dirname(filePath));
   fs.writeFileSync(filePath, JSON.stringify(data || {}, null, 2), 'utf8');
 }
 
@@ -153,7 +146,7 @@ function readYamlFile(filePath, fallback = {}) {
 }
 
 function writeYamlFile(filePath, data) {
-  ensurePiDir(path.dirname(filePath));
+  ensureOmpDir(path.dirname(filePath));
   fs.writeFileSync(filePath, yaml.dump(data || {}, {
     lineWidth: 120,
     noRefs: true,
@@ -161,39 +154,38 @@ function writeYamlFile(filePath, data) {
   }), 'utf8');
 }
 
-function readPiSettings() {
-  const paths = getPiPaths();
+function readOmpSettings() {
+  const paths = getOmpPaths();
   return readYamlFile(paths.settings, readJsonFile(paths.settingsJsonLegacy, {}));
 }
 
-function writePiSettings(settings) {
-  writeYamlFile(getPiPaths().settings, settings || {});
+function writeOmpSettings(settings) {
+  writeYamlFile(getOmpPaths().settings, settings || {});
 }
 
-function getPiCommand(env = process.env) {
-  return String(env.OMP_COMMAND || env.PI_COMMAND || DEFAULT_OMP_COMMAND).trim() || DEFAULT_OMP_COMMAND;
+function getOmpCommand(env = process.env) {
+  return String(env.OMP_COMMAND || DEFAULT_OMP_COMMAND).trim() || DEFAULT_OMP_COMMAND;
 }
 
 function commandExists(command, env = process.env, options = {}) {
   try {
-    runPiCommand(command, ['--version'], env, options, 'ignore');
+    runOmpCommand(command, ['--version'], env, options, 'ignore');
     return true;
   } catch {
     return false;
   }
 }
 
-function resolvePiRuntime(env = process.env, options = {}) {
-  const configured = env.OMP_COMMAND || env.PI_COMMAND;
+function resolveOmpRuntime(env = process.env, options = {}) {
+  const configured = env.OMP_COMMAND;
   if (configured) {
-    const command = getPiCommand(env);
-    const source = env.OMP_COMMAND ? 'OMP_COMMAND' : 'PI_COMMAND';
+    const command = getOmpCommand(env);
     return {
       command,
-      runtime: command === LEGACY_PI_COMMAND ? 'pi' : 'omp',
+      runtime: 'omp',
       installed: commandExists(command, env, options),
       configured: true,
-      commandSource: source
+      commandSource: 'OMP_COMMAND'
     };
   }
 
@@ -207,16 +199,6 @@ function resolvePiRuntime(env = process.env, options = {}) {
     };
   }
 
-  if (commandExists(LEGACY_PI_COMMAND, env, options)) {
-    return {
-      command: LEGACY_PI_COMMAND,
-      runtime: 'pi',
-      installed: true,
-      configured: false,
-      commandSource: 'path'
-    };
-  }
-
   return {
     command: DEFAULT_OMP_COMMAND,
     runtime: 'omp',
@@ -226,12 +208,12 @@ function resolvePiRuntime(env = process.env, options = {}) {
   };
 }
 
-function isPiInstalled(env = process.env, options = {}) {
-  const runtime = options.runtime || resolvePiRuntime(env, options);
+function isOmpInstalled(env = process.env, options = {}) {
+  const runtime = options.runtime || resolveOmpRuntime(env, options);
   if (runtime.installed) {
     return true;
   }
-  return fs.existsSync(getPiPaths(env, { ...options, runtime }).agentDir);
+  return fs.existsSync(getOmpPaths(env, { ...options, runtime }).agentDir);
 }
 
 function readTextFile(filePath, fallback = '') {
@@ -243,11 +225,11 @@ function readTextFile(filePath, fallback = '') {
   }
 }
 
-function getPiStatus(env = process.env, options = {}) {
-  const runtime = resolvePiRuntime(env, options);
-  const paths = getPiPaths(env, { ...options, runtime });
+function getOmpStatus(env = process.env, options = {}) {
+  const runtime = resolveOmpRuntime(env, options);
+  const paths = getOmpPaths(env, { ...options, runtime });
   return {
-    installed: isPiInstalled(env, { ...options, runtime }),
+    installed: isOmpInstalled(env, { ...options, runtime }),
     runtime: runtime.runtime,
     command: runtime.command,
     commandSource: runtime.commandSource,
@@ -269,19 +251,19 @@ function getPiStatus(env = process.env, options = {}) {
 
 module.exports = {
   expandHome,
-  getPiAgentDir,
-  getPiPaths,
-  ensurePiDir,
+  getOmpAgentDir,
+  getOmpPaths,
+  ensureOmpDir,
   readJsonFile,
   readYamlFile,
   readTextFile,
   writeJsonFile,
   writeYamlFile,
-  readPiSettings,
-  writePiSettings,
-  getPiCommand,
+  readOmpSettings,
+  writeOmpSettings,
+  getOmpCommand,
   getOmpProfile,
-  resolvePiRuntime,
-  isPiInstalled,
-  getPiStatus
+  resolveOmpRuntime,
+  isOmpInstalled,
+  getOmpStatus
 };

package/src/server/services/{pi-sessions.js → omp-sessions.js}

@@ -2,10 +2,10 @@ const fs = require('fs');
 const path = require('path');
 const { execFileSync } = require('child_process');
 const { PATHS, HOME_DIR } = require('../../config/paths');
-const { getPiCommand, getPiPaths, isPiInstalled, resolvePiRuntime } = require('./pi-config');
+const { getOmpCommand, getOmpPaths, isOmpInstalled, resolveOmpRuntime } = require('./omp-config');
 
-const PROJECT_ORDER_FILE = PATHS.piProjectOrder;
-const SESSION_ORDER_FILE = PATHS.piSessionOrder;
+const PROJECT_ORDER_FILE = PATHS.ompProjectOrder;
+const SESSION_ORDER_FILE = PATHS.ompSessionOrder;
 
 function ensureDir(dirPath) {
   if (!fs.existsSync(dirPath)) {
@@ -52,7 +52,7 @@ function getDisplayName(cwd = '') {
   return path.basename(normalized) || normalized;
 }
 
-function parsePiSessionId(filePath = '') {
+function parseOmpSessionId(filePath = '') {
   const base = path.basename(filePath, '.jsonl');
   const match = base.match(/([0-9a-f]{8}-[0-9a-f-]{8,})$/i);
   if (match) return match[1];
@@ -138,7 +138,7 @@ function readJsonLines(filePath) {
   }
 }
 
-function convertPiEntry(entry = {}, index = 0) {
+function convertOmpEntry(entry = {}, index = 0) {
   if (!entry || entry.type !== 'message') {
     return null;
   }
@@ -174,12 +174,12 @@ function parseSessionFile(filePath) {
   const stat = fs.statSync(filePath);
   const entries = readJsonLines(filePath);
   const header = entries.find(entry => entry?.type === 'session') || {};
-  const messages = entries.map(convertPiEntry).filter(Boolean);
+  const messages = entries.map(convertOmpEntry).filter(Boolean);
   const modelChange = [...entries].reverse().find(entry => entry?.type === 'model_change');
   const firstUser = messages.find(message => message.type === 'user');
   const lastAssistant = [...messages].reverse().find(message => message.type === 'assistant') || {};
   const cwd = header.cwd || messages.find(message => message.cwd)?.cwd || path.dirname(filePath);
-  const sessionId = header.id || parsePiSessionId(filePath);
+  const sessionId = header.id || parseOmpSessionId(filePath);
   const usage = messages.reduce((acc, message) => {
     if (message.type !== 'assistant') return acc;
     const current = parseUsage(message.usage || {});
@@ -207,11 +207,11 @@ function parseSessionFile(filePath) {
     mtime: new Date(stat.mtimeMs).toISOString(),
     mtimeMs: stat.mtimeMs,
     timestamp: header.timestamp || null,
-    source: 'pi'
+    source: 'omp'
   };
 }
 
-function scanSessionFiles(rootDir = getPiPaths().sessions) {
+function scanSessionFiles(rootDir = getOmpPaths().sessions) {
   if (!fs.existsSync(rootDir)) {
     return [];
   }
@@ -273,7 +273,7 @@ function getProjects() {
       latestSession: null,
       mtime: session.mtime,
       mtimeMs: 0,
-      source: 'pi'
+      source: 'omp'
     };
     existing.sessionCount += 1;
     if ((session.mtimeMs || 0) > (existing.mtimeMs || 0)) {
@@ -324,7 +324,7 @@ function normalizeSession(session) {
     firstMessage: session.firstMessage || null,
     gitBranch: null,
     forkedFrom: null,
-    source: 'pi',
+    source: 'omp',
     provider: session.provider || '',
     model: session.model || '',
     size: session.size || 0,
@@ -345,7 +345,7 @@ function getSessionMessages(sessionId) {
   if (!session) {
     throw new Error('Session not found');
   }
-  return readJsonLines(session.filePath).map(convertPiEntry).filter(Boolean);
+  return readJsonLines(session.filePath).map(convertOmpEntry).filter(Boolean);
 }
 
 function getRecentSessions(limit = 5) {
@@ -359,7 +359,7 @@ function searchSessions(keyword, contextLength = 35, projectName = null) {
   return getAllSessions()
     .filter(session => !projectName || session.projectName === projectName)
     .map((session) => {
-      const messages = readJsonLines(session.filePath).map(convertPiEntry).filter(Boolean);
+      const messages = readJsonLines(session.filePath).map(convertOmpEntry).filter(Boolean);
       const matches = [];
       messages.forEach((message) => {
         const text = String(message.content || '');
@@ -412,7 +412,7 @@ function forkSession(sessionId) {
   const forkId = `fork-${Date.now()}`;
   const targetPath = path.join(parsed.dir, `${parsed.name}-${forkId}${parsed.ext}`);
   fs.copyFileSync(session.filePath, targetPath);
-  return { success: true, newSessionId: parsePiSessionId(targetPath), filePath: targetPath };
+  return { success: true, newSessionId: parseOmpSessionId(targetPath), filePath: targetPath };
 }
 
 function saveProjectOrder(order) {
@@ -446,19 +446,19 @@ function buildLaunchCommand(sessionId, cwd, options = {}) {
   } else {
     args.push('--session', shellQuote(sessionId));
   }
-  return `${getPiCommand()} ${args.join(' ')}`;
+  return `${getOmpCommand()} ${args.join(' ')}`;
 }
 
 function shellQuote(value) {
   return `"${String(value).replace(/"/g, '\\"')}"`;
 }
 
-function isPiCliInstalled() {
-  if (isPiInstalled()) return true;
-  const runtime = resolvePiRuntime();
+function isOmpCliInstalled() {
+  if (isOmpInstalled()) return true;
+  const runtime = resolveOmpRuntime();
   if (runtime.installed) return true;
   try {
-    execFileSync(getPiCommand(), ['--version'], { stdio: 'ignore', timeout: 3000 });
+    execFileSync(getOmpCommand(), ['--version'], { stdio: 'ignore', timeout: 3000 });
     return true;
   } catch {
     return false;
@@ -479,7 +479,7 @@ module.exports = {
   getSessionById,
   getSessionMessages,
   getSessionsByProject,
-  isPiInstalled: isPiCliInstalled,
+  isOmpInstalled: isOmpCliInstalled,
   normalizeSession,
   parseSessionFile,
   scanSessionFiles,