@yancyyu/openhermit 1.6.41 → 1.6.43

package/src/main/utils/toolApprovalRules.ts

@@ -0,0 +1,151 @@
+import type { ToolApprovalSettings } from '@shared/types/team';
+
+// ---------------------------------------------------------------------------
+// Safe bash command prefixes — commands that never need manual approval
+// ---------------------------------------------------------------------------
+
+const SAFE_PREFIXES: readonly string[] = [
+  // Version control
+  'git ',
+  'git\t',
+  // Package managers
+  'pnpm ',
+  'npm ',
+  'npx ',
+  'yarn ',
+  // File inspection (read-only)
+  'ls',
+  'cat ',
+  'head ',
+  'tail ',
+  'wc ',
+  'less ',
+  'more ',
+  // Output
+  'echo ',
+  'printf ',
+  // System info
+  'pwd',
+  'whoami',
+  'hostname',
+  'date',
+  'uname',
+  // Search & find (read-only)
+  'find ',
+  'grep ',
+  'rg ',
+  'fd ',
+  'ag ',
+  // Directory & file info
+  'tree ',
+  'which ',
+  'type ',
+  'file ',
+  // Text processing (read-only)
+  'diff ',
+  'sort ',
+  'uniq ',
+  'tr ',
+  'cut ',
+  // Path utilities
+  'basename ',
+  'dirname ',
+  'realpath ',
+  'readlink ',
+  // Environment
+  'env',
+  'printenv',
+  // Scripting one-liners (read-only)
+  'node -e',
+  'node --eval',
+  'python -c',
+  'python3 -c',
+];
+
+// ---------------------------------------------------------------------------
+// Dangerous patterns — these OVERRIDE safe prefixes and always need approval
+// ---------------------------------------------------------------------------
+
+const DANGEROUS_PATTERNS: readonly RegExp[] = [
+  /\brm\s/, // rm (with space to avoid false positives like "rmdir" intent)
+  /\brm$/, // bare "rm" at end
+  /\bsudo\b/,
+  /\bchmod\b/,
+  /\bchown\b/,
+  /\bcurl\b.*\|\s*(ba)?sh/,
+  /\bwget\b.*\|\s*(ba)?sh/,
+  /\bmkfs\b/,
+  /\bdd\b/,
+  /\bkill\b/,
+  /\bkillall\b/,
+  /\bpkill\b/,
+  />\s*\//, // redirect to absolute path root
+  /\beval\b/,
+  /\bexec\b/,
+  /\bformat\b/,
+  /\bshutdown\b/,
+  /\breboot\b/,
+];
+
+// ---------------------------------------------------------------------------
+// File edit tools that can be auto-allowed
+// ---------------------------------------------------------------------------
+
+const FILE_EDIT_TOOLS = new Set(['Edit', 'Write', 'NotebookEdit']);
+
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+
+export interface AutoAllowResult {
+  autoAllow: boolean;
+  reason?: string;
+}
+
+/**
+ * Determines whether a tool call should be auto-allowed based on user settings.
+ *
+ * Logic:
+ * 1. File edit tools — auto-allow if `autoAllowFileEdits` is enabled
+ * 2. Bash commands — check dangerous patterns FIRST (always block),
+ *    then check safe prefixes (auto-allow if `autoAllowSafeBash` is enabled)
+ * 3. Everything else — requires manual approval
+ */
+export function shouldAutoAllow(
+  settings: ToolApprovalSettings,
+  toolName: string,
+  toolInput: Record<string, unknown>
+): AutoAllowResult {
+  // Auto-allow ALL tools (overrides everything)
+  if (settings.autoAllowAll) {
+    return { autoAllow: true, reason: 'auto_allow_all' };
+  }
+
+  // File edit auto-allow
+  if (settings.autoAllowFileEdits && FILE_EDIT_TOOLS.has(toolName)) {
+    return { autoAllow: true, reason: 'auto_allow_category' };
+  }
+
+  // Safe bash auto-allow
+  if (settings.autoAllowSafeBash && toolName === 'Bash') {
+    const command = typeof toolInput.command === 'string' ? toolInput.command.trim() : '';
+    if (!command) return { autoAllow: false };
+
+    // Dangerous patterns override safe prefixes — check FIRST
+    for (const pattern of DANGEROUS_PATTERNS) {
+      if (pattern.test(command)) {
+        return { autoAllow: false };
+      }
+    }
+
+    // Check safe prefixes
+    for (const prefix of SAFE_PREFIXES) {
+      const trimmedPrefix = prefix.trimEnd();
+      if (command === trimmedPrefix || command.startsWith(prefix)) {
+        return { autoAllow: true, reason: 'auto_allow_category' };
+      }
+    }
+  }
+
+  return { autoAllow: false };
+}

package/src/renderer/App.tsx

@@ -1,4 +1,4 @@
-import React, { useEffect, useMemo, useRef, useState } from 'react';
+import React, { useEffect, useMemo } from 'react';
 
 import { TooltipProvider } from '@renderer/components/ui/tooltip';
 
@@ -18,14 +18,6 @@ import type { Tab } from './types/tabs';
 const PERSIST_KEY = 'hermit:lastTeam';
 const DEFAULT_APP_PATH = '/teams';
 
-function safeDecodeURIComponent(value: string): string {
-  try {
-    return decodeURIComponent(value);
-  } catch {
-    return value;
-  }
-}
-
 function getActiveTabFromLayout(activeTabId: string | null, paneLayout: PaneLayout): Tab | null {
   if (!activeTabId) return null;
   for (const pane of paneLayout.panes) {
@@ -57,6 +49,8 @@ function buildPathForTab(activeTab: Tab | null): string {
       return '/tasks';
     case 'dashboard':
       return '/dashboard';
+    case 'society':
+      return '/society';
     case 'session': {
       if (!activeTab.projectId || !activeTab.sessionId) return DEFAULT_APP_PATH;
       return `/session/${encodeURIComponent(activeTab.projectId)}/${encodeURIComponent(activeTab.sessionId)}`;
@@ -115,93 +109,20 @@ function useTabPathPersistence() {
     activeTabId: s.activeTabId,
     paneLayout: s.paneLayout,
   }));
-  const [routeReady, setRouteReady] = useState(false);
-  const didInitialRouteRestoreRef = useRef(false);
-
-  useEffect(() => {
-    if (didInitialRouteRestoreRef.current) return;
-    didInitialRouteRestoreRef.current = true;
-
-    const pathname = window.location.pathname;
-    const segments = pathname
-      .split('/')
-      .map((segment) => segment.trim())
-      .filter((segment) => segment.length > 0)
-      .map(safeDecodeURIComponent);
-    const state = useStore.getState();
-
-    if (segments.length === 0) {
-      setRouteReady(true);
-      return;
-    }
-
-    const [route, arg1, arg2] = segments;
-    switch (route) {
-      case 'team':
-        if (arg1) state.openTeamTab(arg1);
-        break;
-      case 'teams':
-        state.openTeamsTab();
-        break;
-      case 'system-manager':
-        void state.openSystemManager();
-        break;
-      case 'settings':
-        state.openSettingsTab();
-        break;
-      case 'extensions':
-        state.openExtensionsTab();
-        break;
-      case 'schedules':
-        state.openSchedulesTab();
-        break;
-      case 'tasks':
-        state.openTasksTab();
-        break;
-      case 'dashboard':
-        state.openDashboard();
-        break;
-      case 'session':
-        if (arg1 && arg2) {
-          state.navigateToSession(arg1, arg2);
-        }
-        break;
-      case 'notifications':
-        state.openTab({ type: 'notifications', label: '通知' });
-        break;
-      case 'graph':
-        if (arg1) {
-          state.openTab({ type: 'graph', label: arg1, teamName: arg1 });
-        }
-        break;
-      case 'report':
-        if (arg1 && arg2) {
-          state.openTab({
-            type: 'report',
-            label: 'Session Report',
-            projectId: arg1,
-            sessionId: arg2,
-          });
-        }
-        break;
-      default:
-        break;
-    }
-
-    setRouteReady(true);
-  }, []);
 
   const activeTab = useMemo(
     () => getActiveTabFromLayout(activeTabId, paneLayout),
     [activeTabId, paneLayout]
   );
 
+  // The initial route is restored before first render (main.tsx →
+  // restoreInitialRoute), so this hook only keeps the URL in sync as the active
+  // tab changes. No post-mount restore, no routeReady gate.
   useEffect(() => {
-    if (!routeReady) return;
     const nextPath = buildPathForTab(activeTab);
     if (window.location.pathname === nextPath) return;
     window.history.replaceState(null, '', nextPath);
-  }, [activeTab, routeReady]);
+  }, [activeTab]);
 }
 
 declare global {
@@ -215,6 +136,7 @@ declare global {
 const SPLASH_MIN_DURATION_MS = 2800;
 const SPLASH_ENHANCED_HOLD_MS = 800;
 const SPLASH_FADE_MS = 480;
+const SPLASH_ROUTE_RESTORE_FADE_MS = 120;
 const SPLASH_REDUCED_MIN_DURATION_MS = 600;
 const SPLASH_REDUCED_HOLD_MS = 200;
 const SPLASH_REDUCED_FADE_MS = 180;
@@ -240,9 +162,22 @@ export const App = (): React.JSX.Element => {
       const enhancedStartedAt = window.__claudeTeamsSplashEnhancedStartedAt ?? performance.now();
       const elapsed = performance.now() - startedAt;
       const enhancedElapsed = performance.now() - enhancedStartedAt;
-      const minDuration = reducedMotion ? SPLASH_REDUCED_MIN_DURATION_MS : SPLASH_MIN_DURATION_MS;
-      const enhancedHold = reducedMotion ? SPLASH_REDUCED_HOLD_MS : SPLASH_ENHANCED_HOLD_MS;
-      const fadeDuration = reducedMotion ? SPLASH_REDUCED_FADE_MS : SPLASH_FADE_MS;
+      const routeRestored = window.location.pathname !== '/' && window.location.pathname !== '';
+      const minDuration = routeRestored
+        ? 0
+        : reducedMotion
+          ? SPLASH_REDUCED_MIN_DURATION_MS
+          : SPLASH_MIN_DURATION_MS;
+      const enhancedHold = routeRestored
+        ? 0
+        : reducedMotion
+          ? SPLASH_REDUCED_HOLD_MS
+          : SPLASH_ENHANCED_HOLD_MS;
+      const fadeDuration = routeRestored
+        ? SPLASH_ROUTE_RESTORE_FADE_MS
+        : reducedMotion
+          ? SPLASH_REDUCED_FADE_MS
+          : SPLASH_FADE_MS;
       const avatarReadyMaxWait = reducedMotion
         ? SPLASH_REDUCED_AVATAR_READY_MAX_WAIT_MS
         : SPLASH_AVATAR_READY_MAX_WAIT_MS;

package/src/renderer/api/httpClient.ts

@@ -21,6 +21,8 @@ import type {
   BoardTaskLogStreamSummary,
   CcSession,
   CcSessionDetail,
+  LoopSessionRequest,
+  LoopSessionResponse,
   ClaudeMdFileInfo,
   ClaudeRootFolderSelection,
   ClaudeRootInfo,
@@ -34,12 +36,14 @@ import type {
   CrossTeamAPI,
   CrossTeamMessage,
   CrossTeamSendResult,
+  DiscoverableWorker,
   ElectronAPI,
   FileChangeEvent,
   GlobalTask,
   HttpServerAPI,
   HttpServerStatus,
   KanbanColumnId,
+  LoopAssetsSnapshot,
   MachineProfile,
   MachineRuntimeProcess,
   MemberFullStats,
@@ -108,6 +112,12 @@ import type { AgentConfig } from '@shared/types/api';
 import type { CliProviderStatus } from '@shared/types/cliInstaller';
 import type { EditorAPI, ProjectAPI, WorkspaceListResponse } from '@shared/types/editor';
 import type {
+  CapabilityCommandPromptRequest,
+  CapabilityCommandPromptResult,
+  CapabilityPackExportRequest,
+  CapabilityPackImportRequest,
+  CapabilityPackListResult,
+  CapabilityPackMutationResult,
   EnrichedPlugin,
   InstalledMcpEntry,
   McpCatalogItem,
@@ -240,8 +250,8 @@ export class HttpAPIClient implements ElectronAPI {
     return JSON.parse(text, (key, value) => HttpAPIClient.reviveDates(key, value)) as T;
   }
 
-  private async get<T>(path: string): Promise<T> {
-    const { controller, timeout } = this.createTimeoutController(10_000);
+  private async get<T>(path: string, timeoutMs = 10_000): Promise<T> {
+    const { controller, timeout } = this.createTimeoutController(timeoutMs);
     try {
       const res = await fetch(`${this.baseUrl}${path}`, { signal: controller.signal });
       return this.parseJson<T>(res);
@@ -250,8 +260,8 @@ export class HttpAPIClient implements ElectronAPI {
     }
   }
 
-  private async post<T>(path: string, body?: unknown): Promise<T> {
-    const { controller, timeout } = this.createTimeoutController(10_000);
+  private async post<T>(path: string, body?: unknown, timeoutMs = 10_000): Promise<T> {
+    const { controller, timeout } = this.createTimeoutController(timeoutMs);
     try {
       const res = await fetch(`${this.baseUrl}${path}`, {
         method: 'POST',
@@ -280,8 +290,8 @@ export class HttpAPIClient implements ElectronAPI {
     }
   }
 
-  private async del<T>(path: string, body?: unknown): Promise<T> {
-    const { controller, timeout } = this.createTimeoutController(10_000);
+  private async del<T>(path: string, body?: unknown, timeoutMs = 10_000): Promise<T> {
+    const { controller, timeout } = this.createTimeoutController(timeoutMs);
     try {
       const res = await fetch(`${this.baseUrl}${path}`, {
         method: 'DELETE',
@@ -295,8 +305,8 @@ export class HttpAPIClient implements ElectronAPI {
     }
   }
 
-  private async put<T>(path: string, body?: unknown): Promise<T> {
-    const { controller, timeout } = this.createTimeoutController(10_000);
+  private async put<T>(path: string, body?: unknown, timeoutMs = 10_000): Promise<T> {
+    const { controller, timeout } = this.createTimeoutController(timeoutMs);
     try {
       const res = await fetch(`${this.baseUrl}${path}`, {
         method: 'PUT',
@@ -310,8 +320,8 @@ export class HttpAPIClient implements ElectronAPI {
     }
   }
 
-  private async patch<T>(path: string, body?: unknown): Promise<T> {
-    const { controller, timeout } = this.createTimeoutController(10_000);
+  private async patch<T>(path: string, body?: unknown, timeoutMs = 10_000): Promise<T> {
+    const { controller, timeout } = this.createTimeoutController(timeoutMs);
     try {
       const res = await fetch(`${this.baseUrl}${path}`, {
         method: 'PATCH',
@@ -325,8 +335,8 @@ export class HttpAPIClient implements ElectronAPI {
     }
   }
 
-  private async delete<T>(path: string): Promise<T> {
-    const { controller, timeout } = this.createTimeoutController(10_000);
+  private async delete<T>(path: string, timeoutMs = 10_000): Promise<T> {
+    const { controller, timeout } = this.createTimeoutController(timeoutMs);
     try {
       const res = await fetch(`${this.baseUrl}${path}`, {
         method: 'DELETE',
@@ -535,11 +545,11 @@ export class HttpAPIClient implements ElectronAPI {
         work_dir?: string;
         agent_type?: string;
       }
-    ): Promise<{ message: string; restart_required: boolean }> => {
-      const res = await this.post<{
+    ): Promise<{ message: string; restart_required: boolean; restart_handled?: boolean }> => {
+      const res = await this.postLong<{
         ok: boolean;
-        data: { message: string; restart_required: boolean };
-      }>(`/api/projects/${encodeURIComponent(projectName)}/add-platform`, body);
+        data: { message: string; restart_required: boolean; restart_handled?: boolean };
+      }>(`/api/projects/${encodeURIComponent(projectName)}/add-platform`, body, 120_000);
       return res.data;
     },
   };
@@ -1093,11 +1103,25 @@ export class HttpAPIClient implements ElectronAPI {
   };
 
   teams: TeamsAPI = {
-    list: async (): Promise<TeamSummary[]> => this.get<TeamSummary[]>('/api/teams'),
+    list: async (): Promise<TeamSummary[]> => this.get<TeamSummary[]>('/api/teams', 30_000),
     ensureSystemManager: async (): Promise<SystemManagerSummary> =>
       this.post<SystemManagerSummary>('/api/system-manager/ensure'),
     getData: async (teamName: string): Promise<TeamViewSnapshot> =>
-      this.get<TeamViewSnapshot>(`/api/teams/${encodeURIComponent(teamName)}/data`),
+      this.get<TeamViewSnapshot>(`/api/teams/${encodeURIComponent(teamName)}/data`, 30_000),
+    getLoopAssets: async (teamName: string): Promise<LoopAssetsSnapshot> =>
+      this.get<LoopAssetsSnapshot>(
+        `/api/teams/${encodeURIComponent(teamName)}/loop-assets`,
+        30_000
+      ),
+    createLoopSession: async (
+      teamName: string,
+      request: LoopSessionRequest
+    ): Promise<LoopSessionResponse> =>
+      this.postLong<LoopSessionResponse>(
+        `/api/teams/${encodeURIComponent(teamName)}/loop-session`,
+        request,
+        30_000
+      ),
     getTaskChangePresence: async (): Promise<
       Record<string, 'has_changes' | 'no_changes' | 'unknown'>
     > => {
@@ -1395,7 +1419,15 @@ export class HttpAPIClient implements ElectronAPI {
       teamName: string,
       config: TeamUpdateConfigRequest
     ): Promise<TeamConfig> => {
-      return this.put(`/api/teams/${encodeURIComponent(teamName)}/config`, config);
+      const result = await this.put<TeamConfig>(
+        `/api/teams/${encodeURIComponent(teamName)}/config`,
+        config,
+        120_000
+      );
+      if (result.ccSyncError) {
+        throw new Error(`配置已保存到本地，但同步到运行时失败：${result.ccSyncError}`);
+      }
+      return result;
     },
     addTaskComment: async (
       teamName: string,
@@ -1477,7 +1509,9 @@ export class HttpAPIClient implements ElectronAPI {
     },
     restartMember: async (teamName: string, memberName: string): Promise<void> => {
       await this.post(
-        `/api/teams/${encodeURIComponent(teamName)}/members/${encodeURIComponent(memberName)}/restart`
+        `/api/teams/${encodeURIComponent(teamName)}/members/${encodeURIComponent(memberName)}/restart`,
+        undefined,
+        30_000
       );
     },
     skipMemberForLaunch: async (teamName: string, memberName: string): Promise<void> => {
@@ -1654,6 +1688,28 @@ export class HttpAPIClient implements ElectronAPI {
       this.get<CrossTeamMessage[]>(`/api/cross-team/outbox/${encodeURIComponent(teamName)}`),
   };
 
+  workers = {
+    list: () => this.get<{ workers: DiscoverableWorker[] }>('/api/workers'),
+    invoke: (
+      workerId: string,
+      request: {
+        fromTeam?: string;
+        text: string;
+        summary?: string;
+        sessionName?: string;
+        reuse?: boolean;
+        sessionKey?: string;
+      }
+    ) =>
+      this.postLong<{
+        ok: boolean;
+        worker: DiscoverableWorker;
+        session: CcSession;
+        reused: boolean;
+        messageSent: boolean;
+      }>(`/api/workers/${encodeURIComponent(workerId)}/invoke`, request, 30_000),
+  };
+
   // Collaboration board API
   collab = {
     getBoard: () => this.get<{ tasks: CollabTask[] }>('/api/collab/board'),
@@ -2015,14 +2071,19 @@ export class HttpAPIClient implements ElectronAPI {
       if (forceRefresh) params.set('forceRefresh', 'true');
       const qs = params.toString();
       const result = await this.get<{ success: boolean; data?: EnrichedPlugin[]; error?: string }>(
-        `/api/extensions/plugins${qs ? `?${qs}` : ''}`
+        `/api/extensions/plugins${qs ? `?${qs}` : ''}`,
+        // Catalog assembly scans local installs + remote registries (GitHub),
+        // which routinely exceeds the default 10s — match the team-endpoint
+        // 30s budget so the Extensions store doesn't time out on first open.
+        30_000
       );
       if (!result.success) throw new Error(result.error ?? 'Failed to get plugins');
       return result.data ?? [];
     },
     getReadme: async (pluginId: string) => {
       const result = await this.get<{ success: boolean; data?: string | null; error?: string }>(
-        `/api/extensions/plugins/${encodeURIComponent(pluginId)}/readme`
+        `/api/extensions/plugins/${encodeURIComponent(pluginId)}/readme`,
+        30_000
       );
       if (!result.success) throw new Error(result.error ?? 'Failed to get readme');
       return result.data ?? null;
@@ -2178,6 +2239,47 @@ export class HttpAPIClient implements ElectronAPI {
     },
   };
 
+  capabilityPacks = {
+    list: async () => {
+      const result = await this.get<{
+        success: boolean;
+        data?: CapabilityPackListResult;
+        error?: string;
+      }>('/api/extensions/capability-packs');
+      if (!result.success)
+        return { packs: [], warnings: result.error ? [result.error] : [], rootDir: '' };
+      return result.data ?? { packs: [], warnings: [], rootDir: '' };
+    },
+    importPack: async (request: CapabilityPackImportRequest) => {
+      const result = await this.post<{
+        success: boolean;
+        data?: CapabilityPackMutationResult;
+        error?: string;
+      }>('/api/extensions/capability-packs/import', request);
+      if (!result.success) throw new Error(result.error ?? 'Import capability pack failed');
+      return result.data ?? { pack: null, warnings: [] };
+    },
+    exportPack: async (request: CapabilityPackExportRequest) => {
+      const result = await this.post<{
+        success: boolean;
+        data?: CapabilityPackMutationResult;
+        error?: string;
+      }>('/api/extensions/capability-packs/export', request);
+      if (!result.success) throw new Error(result.error ?? 'Export capability pack failed');
+      return result.data ?? { pack: null, warnings: [] };
+    },
+    getCommandPrompt: async (request: CapabilityCommandPromptRequest) => {
+      const result = await this.post<{
+        success: boolean;
+        data?: CapabilityCommandPromptResult;
+        error?: string;
+      }>('/api/extensions/capability-packs/command-prompt', request);
+      if (!result.success) throw new Error(result.error ?? 'Load capability command failed');
+      if (!result.data) throw new Error('Load capability command failed');
+      return result.data;
+    },
+  };
+
   skills = {
     list: async (projectPath?: string) => {
       const params = new URLSearchParams();
@@ -2305,44 +2407,22 @@ export class HttpAPIClient implements ElectronAPI {
     getConfig: () => this.get('/api/system-manager/config'),
     updateConfig: (patch) => this.put('/api/system-manager/config', patch),
     listWorkflowPrompts: (folder) => this.post('/api/system-manager/workflows/list', { folder }),
-    readWorkflowPrompt: (_folder, id) => this.post('/api/system-manager/workflows/read', { id }),
+    readWorkflowPrompt: (folder, id) =>
+      this.post('/api/system-manager/workflows/read', { folder, id }),
   };
 
   // ---------------------------------------------------------------------------
-  // Terminal (HTTP/SSE-backed browser mode)
+  // Terminal (system/default terminal)
   // ---------------------------------------------------------------------------
 
   terminal: TerminalAPI = {
-    spawn: async (options = {}): Promise<string> => {
-      const result = await this.post<{ ptyId: string }>('/api/terminal/spawn', options);
-      return result.ptyId;
-    },
-    write: (ptyId: string, data: string): void => {
-      void this.post(`/api/terminal/${encodeURIComponent(ptyId)}/write`, { data });
-    },
-    resize: (ptyId: string, cols: number, rows: number): void => {
-      void this.post(`/api/terminal/${encodeURIComponent(ptyId)}/resize`, { cols, rows });
-    },
-    kill: async (ptyId: string): Promise<void> => {
-      await this.del(`/api/terminal/${encodeURIComponent(ptyId)}`);
-    },
-    openExternal: async (options: { command: string; args?: string[]; cwd?: string }): Promise<void> => {
+    openExternal: async (options: {
+      command: string;
+      args?: string[];
+      cwd?: string;
+    }): Promise<void> => {
       await this.post('/api/terminal/open-external', options);
     },
-    onData: (callback): (() => void) =>
-      this.addEventListener('terminal:data', (data: unknown) => {
-        const event = data as { ptyId?: string; data?: string };
-        if (event.ptyId && typeof event.data === 'string') {
-          callback(null, event.ptyId, event.data);
-        }
-      }),
-    onExit: (callback): (() => void) =>
-      this.addEventListener('terminal:exit', (data: unknown) => {
-        const event = data as { ptyId?: string; exitCode?: number };
-        if (event.ptyId && typeof event.exitCode === 'number') {
-          callback(null, event.ptyId, event.exitCode);
-        }
-      }),
   };
 
   // ---------------------------------------------------------------------------

package/src/renderer/api/providers.ts

@@ -5,11 +5,7 @@
  * cc-connect sidecar is the source of truth for provider/channel management.
  */
 
-import type {
-  CCSwitchListResponse,
-  GlobalProvider,
-  ProviderPresetsResponse,
-} from '@shared/types/providers';
+import type { GlobalProvider, ProviderPresetsResponse } from '@shared/types/providers';
 
 function stringifyProviderPatch(patch: Partial<GlobalProvider>): string {
   return JSON.stringify(patch, (_key, value: unknown) => (value === undefined ? null : value));
@@ -45,7 +41,7 @@ async function request<T>(path: string, init?: RequestInit & { timeoutMs?: numbe
     if (!contentType.includes('json') || !text.trim().startsWith('{')) {
       throw new Error(
         `Provider API ${path} 返回了非 JSON 响应 (HTTP ${res.status})。` +
-        '请检查 cc-connect 是否正在运行且支持该端点。'
+          '请检查 cc-connect 是否正在运行且支持该端点。'
       );
     }
 
@@ -53,7 +49,9 @@ async function request<T>(path: string, init?: RequestInit & { timeoutMs?: numbe
     try {
       json = JSON.parse(text) as typeof json;
     } catch (e) {
-      throw new Error(`Provider API ${path} 返回了无效 JSON: ${e instanceof Error ? e.message : String(e)}`);
+      throw new Error(
+        `Provider API ${path} 返回了无效 JSON: ${e instanceof Error ? e.message : String(e)}`
+      );
     }
 
     if (!res.ok || json.ok === false) {
@@ -86,13 +84,4 @@ export const providersApi = {
       timeoutMs: 20_000,
     });
   },
-  listCCSwitch(): Promise<CCSwitchListResponse> {
-    return request('/providers/cc-switch');
-  },
-  importCCSwitch(names: string[]): Promise<{ imported: string[]; skipped: string[] }> {
-    return request('/providers/cc-switch', {
-      method: 'POST',
-      body: JSON.stringify({ names }),
-    });
-  },
 };