coding-tool-x 3.6.12 → 3.7.0

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

@@ -0,0 +1,154 @@
+const express = require('express');
+const fs = require('fs');
+const path = require('path');
+const router = express.Router();
+const {
+  startPiProxyServer,
+  stopPiProxyServer,
+  getPiProxyStatus
+} = require('../pi-proxy-server');
+const {
+  getChannels,
+  getEnabledChannels,
+  markChannelAsRecentlyUsed
+} = require('../services/pi-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.pi;
+  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.pi)) return null;
+    const data = JSON.parse(fs.readFileSync(PATHS.activeChannel.pi, 'utf8'));
+    return data.activeChannelId || null;
+  } catch {
+    return null;
+  }
+}
+
+function removeActiveChannelFile() {
+  ensureStorageDirMigrated();
+  if (fs.existsSync(PATHS.activeChannel.pi)) {
+    fs.unlinkSync(PATHS.activeChannel.pi);
+  }
+}
+
+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 = getPiProxyStatus();
+    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 startPiProxyServer();
+    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 = getPiProxyStatus();
+    const { channels: latestChannels } = getChannels();
+    const activeChannel = latestChannels.find(channel => channel.id === currentChannel.id) || currentChannel;
+    broadcastProxyState('pi', updatedStatus, activeChannel, latestChannels);
+    broadcastSchedulerState('pi', getSchedulerState('pi'));
+
+    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 stopPiProxyServer();
+    removeActiveChannelFile();
+    const { broadcastProxyState, broadcastSchedulerState } = require('../websocket-server');
+    const { channels } = getChannels();
+    broadcastProxyState('pi', getPiProxyStatus(), null, channels);
+    broadcastSchedulerState('pi', getSchedulerState('pi'));
+    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/pi-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,
+  isPiInstalled,
+  HOME_DIR
+} = require('../services/pi-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 (!isPiInstalled()) {
+        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: 'pi' });
+    } 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 (!isPiInstalled()) {
+        return res.status(404).json({ error: 'OMP CLI not installed' });
+      }
+      const limit = parseInt(req.query.limit, 10) || 5;
+      res.json({ sessions: getRecentSessions(limit), source: 'pi' });
+    } 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 (!isPiInstalled()) {
+        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 (!isPiInstalled()) {
+        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 (!isPiInstalled()) {
+        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 (!isPiInstalled()) {
+        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 (!isPiInstalled()) {
+        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 || 'pi'
+        },
+        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 (!isPiInstalled()) {
+        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 (!isPiInstalled()) {
+        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 (!isPiInstalled()) {
+        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 (!isPiInstalled()) {
+        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 (!isPiInstalled()) {
+        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: 'pi',
+        toolType: 'pi',
+        source: 'pi',
+        timestamp: Date.now()
+      });
+
+      res.json({
+        success: true,
+        cwd,
+        sessionFile: session.filePath,
+        sessionId,
+        tool: 'pi',
+        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/pi-statistics.js

@@ -0,0 +1,40 @@
+const express = require('express');
+const router = express.Router();
+const {
+  getStatistics,
+  getDailyStatistics,
+  getTodayStatistics
+} = require('../services/pi-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', 'pi'];
 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/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', 'pi'];
 const skillServices = new Map();
 
 function resolvePlatform(rawPlatform) {

package/src/server/api/workspaces.js

@@ -135,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 {
@@ -411,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' | 'pi' | 'omp', projectName?: string }
  */
 router.post('/:id/launch', (req, res) => {
   try {

package/src/server/index.js

@@ -23,6 +23,8 @@ const { startProxyServer } = require('./proxy-server');
 const { startCodexProxyServer } = require('./codex-proxy-server');
 const { startGeminiProxyServer } = require('./gemini-proxy-server');
 const { startOpenCodeProxyServer, collectProxyModelList } = require('./opencode-proxy-server');
+const { startPiProxyServer } = require('./pi-proxy-server');
+const { createRemoteMutationGuard } = require('./services/network-access');
 const { createApiRequestLogger } = require('./services/request-logger');
 const { inspectWebBuildState, ensureWebDistReady } = require('./services/web-build');
 const { ensureHttpsCredentials } = require('./services/https-cert');
@@ -148,6 +150,8 @@ async function startServer(port, host = '127.0.0.1', options = {}) {
 
   const app = express();
   const useHttps = options.useHttps === true || process.argv.includes('--https');
+  const lanMode = host === '0.0.0.0';
+  const allowRemoteMutation = process.env.CC_TOOL_ALLOW_REMOTE_WRITE === 'true';
 
   // Middleware
   app.use(express.json({ limit: '100mb' }));
@@ -167,6 +171,15 @@ async function startServer(port, host = '127.0.0.1', options = {}) {
   // API 请求日志（由 CC_TOOL_LOG_API_REQUESTS=true 环境变量控制，默认关闭）
   app.use('/api', createApiRequestLogger());
 
+  if (lanMode) {
+    app.use('/api', createRemoteMutationGuard({
+      enabled: true,
+      allowRemoteMutation,
+      message: '出于安全考虑，LAN 模式默认仅允许本机执行写操作。可设置 CC_TOOL_ALLOW_REMOTE_WRITE=true 覆盖。'
+    }));
+
+  }
+
   // API Routes
   app.use('/api/projects', require('./api/projects')(config));
   app.use('/api/sessions', require('./api/sessions')(config));
@@ -189,6 +202,14 @@ async function startServer(port, host = '127.0.0.1', options = {}) {
   app.use('/api/opencode/proxy', require('./api/opencode-proxy'));
   app.use('/api/opencode/statistics', require('./api/opencode-statistics'));
 
+  // OMP API Routes
+  app.use('/api/pi/projects', require('./api/pi-projects')(config));
+  app.use('/api/pi/sessions', require('./api/pi-sessions')(config));
+  app.use('/api/pi/channels', require('./api/pi-channels')(config));
+  app.use('/api/pi/proxy', require('./api/pi-proxy'));
+  app.use('/api/pi/statistics', require('./api/pi-statistics'));
+  app.use('/api/pi/config', require('./api/pi-config'));
+
   app.use('/api/aliases', require('./api/aliases')());
   app.use('/api/favorites', require('./api/favorites'));
   app.use('/api/ui-config', require('./api/ui-config'));
@@ -304,6 +325,9 @@ async function startServer(port, host = '127.0.0.1', options = {}) {
     console.log(chalk.gray('   [TIP] 首次访问自签名证书时，浏览器可能会提示手动信任本地证书'));
   }
 
+  if (host === '0.0.0.0' && !allowRemoteMutation) {
+    console.log(chalk.yellow('   [LOCK] 已启用 LAN 安全保护：远程写操作默认禁用'));
+  }
   // 自动恢复代理状态
   autoRestoreProxies();
 
@@ -425,6 +449,23 @@ function autoRestoreProxies() {
         console.error(chalk.red(`[ERROR] OpenCode 代理启动失败: ${err.message}`));
       });
   }
+
+  // 检查 OMP 受管 provider 配置状态文件
+  const piActiveFile = PATHS.activeChannel.pi;
+  if (fs.existsSync(piActiveFile)) {
+    console.log(chalk.cyan('\n[SYNC] 检测到 OMP 受管渠道状态文件，正在自动恢复...'));
+    startPiProxyServer({ preserveStartTime: true })
+      .then((result) => {
+        if (result.success) {
+          console.log(chalk.green(`[OK] OMP models.yml 受管 provider 已自动启用，端口: ${result.port}`));
+        } else {
+          console.error(chalk.red(`[ERROR] OMP models.yml 受管 provider 恢复失败: ${result.error || 'Unknown error'}`));
+        }
+      })
+      .catch((err) => {
+        console.error(chalk.red(`[ERROR] OMP models.yml 受管 provider 恢复失败: ${err.message}`));
+      });
+  }
 }
 
 // 启动时执行健康检查