coding-tool-x 3.6.13 → 3.7.1

package/src/server/api/omp-proxy.js

@@ -0,0 +1,154 @@
+const express = require('express');
+const fs = require('fs');
+const path = require('path');
+const router = express.Router();
+const {
+  startOmpProxyServer,
+  stopOmpProxyServer,
+  getOmpProxyStatus
+} = require('../omp-proxy-server');
+const {
+  getChannels,
+  getEnabledChannels,
+  markChannelAsRecentlyUsed
+} = require('../services/omp-channels');
+const { getSchedulerState } = require('../services/channel-scheduler');
+const { PATHS, ensureStorageDirMigrated } = require('../../config/paths');
+
+function sanitizeChannel(channel) {
+  if (!channel) return null;
+  return {
+    id: channel.id,
+    name: channel.name,
+    baseUrl: channel.baseUrl,
+    websiteUrl: channel.websiteUrl
+  };
+}
+
+function selectLatestEnabledChannel(channels) {
+  const enabledChannels = (channels || []).filter(ch => ch.enabled !== false);
+  if (enabledChannels.length === 0) return null;
+  return enabledChannels.reduce((latest, current) => {
+    const latestTs = Number(latest?.updatedAt || latest?.createdAt || 0);
+    const currentTs = Number(current?.updatedAt || current?.createdAt || 0);
+    return currentTs > latestTs ? current : latest;
+  }, enabledChannels[0]);
+}
+
+function saveActiveChannelId(channelId) {
+  ensureStorageDirMigrated();
+  const filePath = PATHS.activeChannel.omp;
+  const dir = path.dirname(filePath);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+  fs.writeFileSync(filePath, JSON.stringify({ activeChannelId: channelId }, null, 2), 'utf8');
+}
+
+function loadActiveChannelId() {
+  ensureStorageDirMigrated();
+  try {
+    if (!fs.existsSync(PATHS.activeChannel.omp)) return null;
+    const data = JSON.parse(fs.readFileSync(PATHS.activeChannel.omp, 'utf8'));
+    return data.activeChannelId || null;
+  } catch {
+    return null;
+  }
+}
+
+function removeActiveChannelFile() {
+  ensureStorageDirMigrated();
+  if (fs.existsSync(PATHS.activeChannel.omp)) {
+    fs.unlinkSync(PATHS.activeChannel.omp);
+  }
+}
+
+function resolveActiveChannel(channels, activeChannelId = null) {
+  if (!Array.isArray(channels) || channels.length === 0) return null;
+  if (activeChannelId) {
+    const matched = channels.find(channel => channel.id === activeChannelId);
+    if (matched) return matched;
+  }
+  return selectLatestEnabledChannel(channels)
+    || channels.find(channel => channel.enabled !== false)
+    || channels[0]
+    || null;
+}
+
+router.get('/status', (req, res) => {
+  try {
+    const proxy = getOmpProxyStatus();
+    const { channels } = getChannels();
+    const enabledChannels = channels.filter(ch => ch.enabled !== false);
+    const activeChannel = resolveActiveChannel(channels, loadActiveChannelId());
+    res.json({
+      proxy,
+      config: {
+        mode: 'models-yml-provider-config',
+        nativeProxyProtocol: false
+      },
+      activeChannel: sanitizeChannel(activeChannel),
+      enabledChannelsCount: enabledChannels.length,
+      totalChannelsCount: channels.length
+    });
+  } catch (error) {
+    res.status(500).json({ error: error.message });
+  }
+});
+
+router.post('/start', async (req, res) => {
+  try {
+    const enabledChannels = getEnabledChannels();
+    if (enabledChannels.length === 0) {
+      return res.status(400).json({
+        error: 'No enabled OMP channel found. Please create and enable a channel first.'
+      });
+    }
+
+    let currentChannel = selectLatestEnabledChannel(enabledChannels) || enabledChannels[0];
+    currentChannel = markChannelAsRecentlyUsed(currentChannel.id);
+    saveActiveChannelId(currentChannel.id);
+
+    const proxyResult = await startOmpProxyServer();
+    if (!proxyResult.success) {
+      return res.status(500).json({ error: 'Failed to enable OMP models.yml provider config' });
+    }
+
+    const { broadcastProxyState, broadcastSchedulerState } = require('../websocket-server');
+    const updatedStatus = getOmpProxyStatus();
+    const { channels: latestChannels } = getChannels();
+    const activeChannel = latestChannels.find(channel => channel.id === currentChannel.id) || currentChannel;
+    broadcastProxyState('omp', updatedStatus, activeChannel, latestChannels);
+    broadcastSchedulerState('omp', getSchedulerState('omp'));
+
+    res.json({
+      success: true,
+      port: proxyResult.port,
+      activeChannel: sanitizeChannel(activeChannel),
+      mode: 'models-yml-provider-config',
+      sync: proxyResult.sync || null,
+      warnings: proxyResult.warnings || [],
+      message: `OMP models.yml provider config enabled, active channel: ${activeChannel.name}`
+    });
+  } catch (error) {
+    console.error('[OMP Proxy] Start failed:', error);
+    res.status(500).json({ error: error.message });
+  }
+});
+
+router.post('/stop', async (req, res) => {
+  try {
+    const result = await stopOmpProxyServer();
+    removeActiveChannelFile();
+    const { broadcastProxyState, broadcastSchedulerState } = require('../websocket-server');
+    const { channels } = getChannels();
+    broadcastProxyState('omp', getOmpProxyStatus(), null, channels);
+    broadcastSchedulerState('omp', getSchedulerState('omp'));
+    res.json({ success: true, ...result });
+  } catch (error) {
+    console.error('[OMP Proxy] Stop failed:', error);
+    res.status(500).json({ error: error.message });
+  }
+});
+
+module.exports = router;

package/src/server/api/omp-sessions.js

@@ -0,0 +1,334 @@
+const express = require('express');
+const router = express.Router();
+const {
+  buildLaunchCommand,
+  getProjects,
+  getSessionsByProject,
+  getSessionById,
+  getSessionMessages,
+  getRecentSessions,
+  searchSessions,
+  deleteSession,
+  forkSession,
+  saveSessionOrder,
+  isOmpInstalled,
+  HOME_DIR
+} = require('../services/omp-sessions');
+const { loadAliases } = require('../services/alias');
+const { broadcastLog } = require('../websocket-server');
+
+function isNotFoundError(error) {
+  if (!error || !error.message) return false;
+  return error.message === 'Session not found' || error.message === 'Project not found';
+}
+
+function quoteForShell(value) {
+  return `"${String(value).replace(/"/g, '\\"')}"`;
+}
+
+module.exports = () => {
+  router.get('/search/global', (req, res) => {
+    try {
+      if (!isOmpInstalled()) {
+        return res.status(404).json({ error: 'OMP CLI not installed' });
+      }
+      const { keyword } = req.query;
+      const parsedContextLength = req.query.context ? parseInt(req.query.context, 10) : 35;
+      const contextLength = Number.isFinite(parsedContextLength) ? parsedContextLength : 35;
+      if (!keyword) {
+        return res.status(400).json({ error: 'Keyword is required' });
+      }
+      const sessions = searchSessions(keyword, contextLength);
+      const totalMatches = sessions.reduce((sum, session) => sum + (session.matchCount || 0), 0);
+      res.json({ keyword, totalMatches, sessions, source: 'omp' });
+    } catch (err) {
+      console.error('[OMP API] Failed to search sessions:', err);
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  router.get('/recent/list', (req, res) => {
+    try {
+      if (!isOmpInstalled()) {
+        return res.status(404).json({ error: 'OMP CLI not installed' });
+      }
+      const limit = parseInt(req.query.limit, 10) || 5;
+      res.json({ sessions: getRecentSessions(limit), source: 'omp' });
+    } catch (err) {
+      console.error('[OMP API] Failed to get recent sessions:', err);
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  router.get('/:projectName/search', (req, res) => {
+    try {
+      if (!isOmpInstalled()) {
+        return res.status(404).json({ error: 'OMP CLI not installed' });
+      }
+      const { projectName } = req.params;
+      const { keyword } = req.query;
+      const parsedContextLength = req.query.context ? parseInt(req.query.context, 10) : 35;
+      const contextLength = Number.isFinite(parsedContextLength) ? parsedContextLength : 35;
+      if (!keyword) {
+        return res.status(400).json({ error: 'Keyword is required' });
+      }
+      const sessions = searchSessions(keyword, contextLength, projectName);
+      const totalMatches = sessions.reduce((sum, session) => sum + (session.matchCount || 0), 0);
+      res.json({ keyword, totalMatches, sessions });
+    } catch (err) {
+      console.error('[OMP API] Failed to search project sessions:', err);
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  router.get('/:projectName', (req, res) => {
+    try {
+      if (!isOmpInstalled()) {
+        return res.status(404).json({ error: 'OMP CLI not installed' });
+      }
+      const { projectName } = req.params;
+      const sessions = getSessionsByProject(projectName);
+      const aliases = loadAliases();
+      const project = getProjects().find(p => p.name === projectName);
+      const totalSize = sessions.reduce((sum, session) => sum + (session.size || 0), 0);
+      res.json({
+        sessions,
+        totalSize,
+        aliases,
+        projectInfo: {
+          name: projectName,
+          fullPath: project?.fullPath || project?.path || projectName,
+          path: project?.path || projectName,
+          displayName: project?.displayName || projectName
+        }
+      });
+    } catch (err) {
+      console.error('[OMP API] Failed to get sessions:', err);
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  router.get('/:projectName/:sessionId/status', (req, res) => {
+    try {
+      if (!isOmpInstalled()) {
+        return res.status(404).json({ error: 'OMP CLI not installed' });
+      }
+      const session = getSessionById(req.params.sessionId);
+      if (!session) {
+        return res.status(404).json({ error: 'Session not found' });
+      }
+      res.json({
+        sessionId: req.params.sessionId,
+        lastModified: session.mtime || null,
+        size: session.size || 0
+      });
+    } catch (err) {
+      console.error('[OMP API] Failed to get session status:', err);
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  router.get('/:projectName/:sessionId/outline', (req, res) => {
+    try {
+      if (!isOmpInstalled()) {
+        return res.status(404).json({ error: 'OMP CLI not installed' });
+      }
+      const session = getSessionById(req.params.sessionId);
+      if (!session) {
+        return res.status(404).json({ error: 'Session not found' });
+      }
+      let userMessageNumber = 0;
+      const items = [];
+      for (const msg of getSessionMessages(req.params.sessionId)) {
+        if (msg.type !== 'user') continue;
+        const preview = typeof msg.content === 'string' ? msg.content.trim() : '';
+        if (!preview) continue;
+        userMessageNumber += 1;
+        items.push({
+          userMessageNumber,
+          preview: preview.length > 42 ? `${preview.slice(0, 42)}...` : preview,
+          timestamp: msg.timestamp || null
+        });
+      }
+      res.json({ sessionId: req.params.sessionId, items });
+    } catch (err) {
+      console.error('[OMP API] Failed to get session outline:', err);
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  router.get('/:projectName/:sessionId/messages', (req, res) => {
+    try {
+      if (!isOmpInstalled()) {
+        return res.status(404).json({ error: 'OMP CLI not installed' });
+      }
+      const { sessionId } = req.params;
+      const { page = 1, limit = 20, order = 'desc' } = req.query;
+      const session = getSessionById(sessionId);
+      if (!session) {
+        return res.status(404).json({ error: 'Session not found' });
+      }
+      let userMessageNumber = 0;
+      const convertedMessages = getSessionMessages(sessionId).map((message) => {
+        if (message.type !== 'user') return message;
+        userMessageNumber += 1;
+        return { ...message, userMessageNumber };
+      });
+      const pageNum = parseInt(page, 10) || 1;
+      const limitNum = parseInt(limit, 10) || 20;
+      const orderedMessages = order === 'desc' ? [...convertedMessages].reverse() : convertedMessages;
+      const start = (pageNum - 1) * limitNum;
+      const end = start + limitNum;
+      res.json({
+        messages: orderedMessages.slice(start, end),
+        metadata: {
+          gitBranch: null,
+          gitRepository: null,
+          cwd: session?.directory || null,
+          provider: session?.provider || '',
+          model: session?.model || 'omp'
+        },
+        pagination: {
+          page: pageNum,
+          limit: limitNum,
+          total: orderedMessages.length,
+          hasMore: end < orderedMessages.length
+        }
+      });
+    } catch (err) {
+      console.error('[OMP API] Failed to get session messages:', err);
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  router.delete('/:projectName/:sessionId', (req, res) => {
+    try {
+      if (!isOmpInstalled()) {
+        return res.status(404).json({ error: 'OMP CLI not installed' });
+      }
+      res.json(deleteSession(req.params.sessionId));
+    } catch (err) {
+      if (isNotFoundError(err)) {
+        return res.status(404).json({ error: err.message });
+      }
+      console.error('[OMP API] Failed to delete session:', err);
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  router.post('/:projectName/batch-delete', (req, res) => {
+    try {
+      if (!isOmpInstalled()) {
+        return res.status(404).json({ error: 'OMP CLI not installed' });
+      }
+      const { sessionIds } = req.body || {};
+      if (!Array.isArray(sessionIds) || sessionIds.length === 0) {
+        return res.status(400).json({ error: 'sessionIds must be a non-empty array' });
+      }
+      const uniqueSessionIds = Array.from(new Set(
+        sessionIds
+          .filter(sessionId => typeof sessionId === 'string')
+          .map(sessionId => sessionId.trim())
+          .filter(Boolean)
+      ));
+      if (uniqueSessionIds.length === 0) {
+        return res.status(400).json({ error: 'sessionIds must be a non-empty array' });
+      }
+      const deletedSessionIds = [];
+      const failed = [];
+      uniqueSessionIds.forEach((sessionId) => {
+        try {
+          deleteSession(sessionId);
+          deletedSessionIds.push(sessionId);
+        } catch (err) {
+          failed.push({ sessionId, error: err.message });
+        }
+      });
+      res.json({
+        success: failed.length === 0,
+        requestedCount: uniqueSessionIds.length,
+        deletedCount: deletedSessionIds.length,
+        deletedSessionIds,
+        failed
+      });
+    } catch (err) {
+      console.error('[OMP API] Failed to batch delete sessions:', err);
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  router.post('/:projectName/:sessionId/fork', (req, res) => {
+    try {
+      if (!isOmpInstalled()) {
+        return res.status(404).json({ error: 'OMP CLI not installed' });
+      }
+      res.json(forkSession(req.params.sessionId, req.body || {}));
+    } catch (err) {
+      if (isNotFoundError(err)) {
+        return res.status(404).json({ error: err.message });
+      }
+      console.error('[OMP API] Failed to fork session:', err);
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  router.post('/:projectName/order', (req, res) => {
+    try {
+      if (!isOmpInstalled()) {
+        return res.status(404).json({ error: 'OMP CLI not installed' });
+      }
+      const { order } = req.body || {};
+      if (!Array.isArray(order)) {
+        return res.status(400).json({ error: 'order must be an array' });
+      }
+      saveSessionOrder(req.params.projectName, order);
+      res.json({ success: true });
+    } catch (err) {
+      console.error('[OMP API] Failed to save session order:', err);
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  router.post('/:projectName/:sessionId/launch', (req, res) => {
+    try {
+      if (!isOmpInstalled()) {
+        return res.status(404).json({ error: 'OMP CLI not installed' });
+      }
+      const { projectName, sessionId } = req.params;
+      const session = getSessionById(sessionId);
+      if (!session) {
+        return res.status(404).json({ error: 'Session not found' });
+      }
+      const project = getProjects().find(p => p.name === projectName);
+      const cwd = session.directory || project?.fullPath || HOME_DIR;
+      const command = buildLaunchCommand(sessionId, cwd, req.body || {});
+      const copyCommand = `cd ${quoteForShell(cwd)} && ${command}`;
+
+      broadcastLog({
+        type: 'action',
+        action: 'launch_pi_session',
+        message: `复制 OMP 会话启动命令 ${sessionId.substring(0, 8)}`,
+        sessionId,
+        tool: 'omp',
+        toolType: 'omp',
+        source: 'omp',
+        timestamp: Date.now()
+      });
+
+      res.json({
+        success: true,
+        cwd,
+        sessionFile: session.filePath,
+        sessionId,
+        tool: 'omp',
+        command,
+        copyCommand
+      });
+    } catch (err) {
+      console.error('[OMP API] Failed to prepare launch command:', err);
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  return router;
+};

package/src/server/api/omp-statistics.js

@@ -0,0 +1,40 @@
+const express = require('express');
+const router = express.Router();
+const {
+  getStatistics,
+  getDailyStatistics,
+  getTodayStatistics
+} = require('../services/omp-statistics-service');
+
+router.get('/summary', (req, res) => {
+  try {
+    res.json(getStatistics());
+  } catch (error) {
+    console.error('[OMP] Failed to get statistics:', error);
+    res.status(500).json({ error: 'Failed to get statistics' });
+  }
+});
+
+router.get('/today', (req, res) => {
+  try {
+    res.json(getTodayStatistics());
+  } catch (error) {
+    console.error('[OMP] Failed to get today statistics:', error);
+    res.status(500).json({ error: 'Failed to get today statistics' });
+  }
+});
+
+router.get('/daily/:date', (req, res) => {
+  try {
+    const { date } = req.params;
+    if (!/^\d{4}-\d{2}-\d{2}$/.test(date)) {
+      return res.status(400).json({ error: 'Invalid date format. Expected YYYY-MM-DD' });
+    }
+    res.json(getDailyStatistics(date));
+  } catch (error) {
+    console.error('[OMP] Failed to get daily statistics:', error);
+    res.status(500).json({ error: 'Failed to get daily statistics' });
+  }
+});
+
+module.exports = router;

package/src/server/api/plugins.js

@@ -10,7 +10,7 @@ const { maskToken } = require('../services/oauth-utils');
 const { sendApiError } = require('./validation-errors');
 
 const router = express.Router();
-const SUPPORTED_PLATFORMS = ['claude', 'codex', 'gemini', 'opencode'];
+const SUPPORTED_PLATFORMS = ['claude', 'codex', 'gemini', 'opencode', 'omp'];
 const pluginServices = new Map();
 
 function resolvePlatform(rawPlatform) {

package/src/server/api/prompts.js

@@ -5,6 +5,7 @@
 const express = require('express');
 const router = express.Router();
 const promptsService = require('../services/prompts-service');
+const PROMPT_FILE_PLATFORMS = ['claude', 'codex', 'gemini', 'opencode'];
 
 /**
  * GET /api/prompts/presets
@@ -203,7 +204,7 @@ router.get('/platform/:platform', (req, res) => {
   try {
     const { platform } = req.params;
 
-    if (!['claude', 'codex', 'gemini', 'opencode'].includes(platform)) {
+    if (!PROMPT_FILE_PLATFORMS.includes(platform)) {
       return res.status(400).json({
         success: false,
         error: `无效的平台: ${platform}`
@@ -234,7 +235,7 @@ router.post('/import/:platform', (req, res) => {
     const { platform } = req.params;
     const { name } = req.body;
 
-    if (!['claude', 'codex', 'gemini', 'opencode'].includes(platform)) {
+    if (!PROMPT_FILE_PLATFORMS.includes(platform)) {
       return res.status(400).json({
         success: false,
         error: `无效的平台: ${platform}`

package/src/server/api/settings.js

@@ -90,6 +90,7 @@ function handleSaveModelSettings(req, res) {
     const config = loadConfig();
     const newConfig = {
       ...config,
+      projectsDir: config.projectsDir.replace(require('os').homedir(), '~'),
       modelMetadataOverrides: overrides && typeof overrides === 'object'
         ? overrides
         : (config.modelMetadataOverrides || {})
@@ -123,6 +124,7 @@ function handleDeleteModelOverride(req, res) {
 
     const newConfig = {
       ...config,
+      projectsDir: config.projectsDir.replace(require('os').homedir(), '~'),
       modelMetadataOverrides: overrides
     };
     saveConfig(newConfig);

package/src/server/api/skills.js

@@ -8,7 +8,7 @@ const { maskToken } = require('../services/oauth-utils');
 const { sendApiError } = require('./validation-errors');
 
 const router = express.Router();
-const SUPPORTED_PLATFORMS = ['claude', 'codex', 'gemini', 'opencode'];
+const SUPPORTED_PLATFORMS = ['claude', 'codex', 'gemini', 'opencode', 'omp'];
 const skillServices = new Map();
 
 function resolvePlatform(rawPlatform) {

package/src/server/api/workspaces.js

@@ -33,24 +33,6 @@ function validateBranchName(branchName) {
   }
 }
 
-function normalizeBranchMode(branchMode) {
-  if (typeof branchMode !== 'string' || !branchMode.trim()) {
-    return '';
-  }
-  return branchMode.trim();
-}
-
-function validateBranchMode(branchMode) {
-  const normalized = normalizeBranchMode(branchMode);
-  if (!normalized) {
-    return { valid: true, normalized: '' };
-  }
-  if (normalized !== 'existing' && normalized !== 'new') {
-    return { valid: false, normalized, message: `分支模式不合法: ${normalized}` };
-  }
-  return { valid: true, normalized };
-}
-
 /**
  * GET /api/workspaces
  * 获取所有工作区列表
@@ -153,7 +135,7 @@ router.get('/check-git/*', (req, res) => {
 
 /**
  * GET /api/workspaces/available-projects
- * 获取所有渠道（Claude/Codex/Gemini）的项目并集
+ * 获取所有渠道（Claude/Codex/Gemini/OpenCode/OMP）的项目并集
  */
 router.get('/available-projects', async (req, res) => {
   try {
@@ -244,17 +226,6 @@ router.post('/', (req, res) => {
         });
       }
 
-      const branchModeValidation = validateBranchMode(proj.branchMode);
-      if (!branchModeValidation.valid) {
-        return res.status(400).json({
-          success: false,
-          message: branchModeValidation.message
-        });
-      }
-      if (branchModeValidation.normalized) {
-        proj.branchMode = branchModeValidation.normalized;
-      }
-
       const normalizedBranch = normalizeBranchName(proj.branch);
       if (normalizedBranch) {
         const branchValidation = validateBranchName(normalizedBranch);
@@ -358,10 +329,9 @@ router.put('/:id/last-used', (req, res) => {
 router.post('/:id/projects', (req, res) => {
   try {
     const { id } = req.params;
-    const { sourcePath, name, createWorktree, branch, baseBranch, branchMode } = req.body;
+    const { sourcePath, name, createWorktree, branch, baseBranch } = req.body;
     const normalizedBranch = normalizeBranchName(branch);
     const normalizedBaseBranch = normalizeBranchName(baseBranch);
-    const branchModeValidation = validateBranchMode(branchMode);
 
     if (!sourcePath || !sourcePath.trim()) {
       return res.status(400).json({
@@ -370,13 +340,6 @@ router.post('/:id/projects', (req, res) => {
       });
     }
 
-    if (!branchModeValidation.valid) {
-      return res.status(400).json({
-        success: false,
-        message: branchModeValidation.message
-      });
-    }
-
     if (normalizedBranch) {
       const branchValidation = validateBranchName(normalizedBranch);
       if (!branchValidation.valid) {
@@ -401,7 +364,6 @@ router.post('/:id/projects', (req, res) => {
       sourcePath,
       name,
       createWorktree,
-      branchMode: branchModeValidation.normalized || branchMode,
       branch: normalizedBranch || branch,
       baseBranch: normalizedBaseBranch || baseBranch
     });
@@ -449,7 +411,7 @@ router.delete('/:id/projects/:projectName', (req, res) => {
 /**
  * POST /api/workspaces/:id/launch
  * 获取在工作区启动 CLI 工具的命令
- * Body: { tool: 'claude' | 'codex' | 'gemini', projectName?: string }
+ * Body: { tool: 'claude' | 'codex' | 'gemini' | 'opencode' | 'omp' | 'omp', projectName?: string }
  */
 router.post('/:id/launch', (req, res) => {
   try {