pikiloom 0.4.26 → 0.4.28

package/dist/dashboard/routes/agents.js

@@ -1,6 +1,3 @@
-/**
- * Dashboard API routes: agent detection, model listing, installation.
- */
 import { Hono } from 'hono';
 import { spawn } from 'node:child_process';
 import fs from 'node:fs';
@@ -15,16 +12,10 @@ import { getActiveProfile, getProvider, peekProviderModelList, prefetchProviderM
 import { DASHBOARD_TIMEOUTS } from '../../core/constants.js';
 import { withTimeoutFallback } from '../../core/utils.js';
 import { runtime } from '../runtime.js';
-// ---------------------------------------------------------------------------
-// Constants
-// ---------------------------------------------------------------------------
 const AGENT_STATUS_MODELS_TIMEOUT_MS = DASHBOARD_TIMEOUTS.agentStatusModels;
 const AGENT_STATUS_USAGE_TIMEOUT_MS = DASHBOARD_TIMEOUTS.agentStatusUsage;
 const AGENT_STATUS_CACHE_TTL_MS = DASHBOARD_TIMEOUTS.agentStatusCacheTtl;
 const AGENT_INSTALL_TIMEOUT_MS = DASHBOARD_TIMEOUTS.agentInstall;
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
 function dedupeModels(models) {
     const seen = new Set();
     const deduped = [];
@@ -78,11 +69,6 @@ function runCommand(cmd, args, opts = {}) {
         });
     });
 }
-/**
- * Parse `ENOTEMPTY: ... rename 'A' -> 'B'` paths out of npm stderr and remove
- * any staging dirs (siblings of the package dir whose name starts with `.`).
- * Never touches the live package dir itself.
- */
 function cleanupNpmStagingFromError(stderr) {
     const removed = [];
     const re = /rename\s+'([^']+)'\s+->\s+'([^']+)'/g;
@@ -99,16 +85,11 @@ function cleanupNpmStagingFromError(stderr) {
             fs.rmSync(p, { recursive: true, force: true });
             removed.push(p);
         }
-        catch { /* best effort */ }
+        catch { }
     }
     return removed;
 }
 async function installAgentViaNpm(agent, log) {
-    // Only npm-published agents can be installed unattended. Manual agents
-    // (e.g. Hermes — a Python CLI with its own installer) surface their command
-    // + docs in the dashboard instead; the UI never POSTs here for them, but we
-    // still guard with an actionable message rather than an opaque
-    // "Unsupported agent" in case the endpoint is hit directly (CLI/API).
     const spec = getAgentInstall(agent);
     if (!spec)
         throw new Error(`Unknown agent: ${agent}`);
@@ -134,9 +115,6 @@ async function installAgentViaNpm(agent, log) {
         throw new Error(result.error || `Failed to install ${pkg}`);
     log(`${getAgentLabel(agent)} installation complete.`);
 }
-// ---------------------------------------------------------------------------
-// Agent status builder
-// ---------------------------------------------------------------------------
 function emptyUsage(agent, error) {
     return { ok: false, agent, source: null, capturedAt: null, status: null, windows: [], error };
 }
@@ -169,17 +147,10 @@ async function buildAgentStatusResponse(config = loadUserConfig(), agentOptions
                     try {
                         nativeConfig = driver.getNativeConfig();
                     }
-                    catch { /* tolerate driver errors */ }
+                    catch { }
                 }
                 const modelFallback = runtimeSelectedModel ? [{ id: runtimeSelectedModel, alias: null }] : [];
                 const cachedUsage = driver.getUsage({ agent: agentId, model: runtimeSelectedModel });
-                // The dashboard agent card lets the user *edit* the binding — when
-                // they toggle the provider to "Native", the model field must show
-                // the agent CLI's own catalogue, not the provider's. We deliberately
-                // call the driver's `listModels` directly (bypassing
-                // `resolveAgentModels`'s BYOK substitution) so `models` is always the
-                // native list; the BYOK catalogue is exposed separately as
-                // `byokModels` below.
                 const [resolvedModels, resolvedUsage] = await Promise.all([
                     withTimeoutFallback(driver.listModels({ workdir, currentModel: runtimeSelectedModel }).then(result => dedupeModels([
                         ...modelFallback,
@@ -198,33 +169,13 @@ async function buildAgentStatusResponse(config = loadUserConfig(), agentOptions
             }
         }
         const updateState = getAgentUpdateState(agentId);
-        // BYOK binding — when an active Profile exists, it overrides the native
-        // model/effort surfaces. Otherwise the values fall through to the user's
-        // runtime override and then to the driver's native config.
         const activeProfile = getActiveProfile(agentId);
         const byokProvider = activeProfile ? getProvider(activeProfile.providerId) : null;
         const byokProviderName = byokProvider?.name || null;
-        // Native model/effort — what the user would run under the agent CLI's
-        // own auth, independent of any active BYOK Profile. AgentTab uses these
-        // as defaults when the user toggles a card's provider back to "Native".
         const nativeSelectedModel = runtimeSelectedModel || nativeConfig?.model || null;
         const nativeSelectedEffort = runtimeSelectedEffort || nativeConfig?.effort || null;
-        // The BYOK-bound model is what the agent will ACTUALLY run (the injector
-        // overrides `--model`/codex `model` at spawn). Surface it everywhere the
-        // UI quotes "current model" — the InputComposer pill, the cascade label,
-        // the agent card. Falling back to the native values when no Profile is
-        // bound preserves the existing native-auth path.
         const selectedModel = activeProfile?.modelId || nativeSelectedModel;
         const selectedEffort = activeProfile?.effort || nativeSelectedEffort;
-        // Likewise, the InputComposer cascade should list the bound provider's
-        // catalogue — those are the models the agent can actually serve through
-        // BYOK, not the native CLI's hardcoded list. We expose it as a SEPARATE
-        // `byokModels` field rather than overwriting `models`, because AgentTab's
-        // provider/model row falls back to `models` whenever the user temporarily
-        // switches the editor to the native provider — we mustn't silently leak
-        // BYOK ids into that view. Read from the provider-models cache
-        // synchronously; miss triggers a background refresh and we degrade to the
-        // bound model id alone so the user can at least see it selected.
         let byokModels = null;
         if (activeProfile && byokProvider) {
             const cachedList = peekProviderModelList(byokProvider.id);
@@ -282,9 +233,6 @@ function invalidateAgentStatus(config, opts) {
     return refreshStatusCache(config, opts);
 }
 export function preloadAgentStatus() { void refreshStatusCache(); }
-// ---------------------------------------------------------------------------
-// Routes
-// ---------------------------------------------------------------------------
 const app = new Hono();
 app.get('/api/agent-status', async (c) => {
     return c.json(await getCachedAgentStatus());
@@ -294,9 +242,6 @@ app.post('/api/agent-install', async (c) => {
     const agent = String(body?.agent || '').trim();
     if (!runtime.isAgent(agent))
         return c.json({ ok: false, error: 'Invalid agent' }, 400);
-    // Manual-install agents (e.g. Hermes) aren't npm-installable — the dashboard
-    // shows their command + docs instead of an Install button, so this is a bad
-    // request rather than a server error. Return the actionable command.
     const installSpec = getAgentInstall(agent);
     if (installSpec && installSpec.method !== 'npm') {
         const docs = installSpec.docsUrl ? ` See ${installSpec.docsUrl}.` : '';
@@ -316,7 +261,6 @@ app.post('/api/agent-install', async (c) => {
         return c.json({ ok: false, error: detail }, 500);
     }
 });
-// Agent list (lightweight)
 app.get('/api/agents', (c) => {
     return c.json({ agents: runtime.getSetupState(loadUserConfig(), { includeVersion: true }).agents });
 });
@@ -372,9 +316,6 @@ app.post('/api/runtime-agent', async (c) => {
     const targetAgent = body?.agent;
     const model = typeof body?.model === 'string' ? body.model.trim() : '';
     const rawEffort = typeof body?.effort === 'string' ? body.effort.trim().toLowerCase() : '';
-    // "ultra" folds max depth + Workflow orchestration into one rung; decompose
-    // so the stored effort is always a real --effort value and orchestration
-    // follows the pick (any concrete rung ⇒ off). Mirrors Bot.switchEffortForChat.
     const { effort, workflow: effortWorkflow } = decomposeEffortSelection(rawEffort);
     const hasEffort = rawEffort !== '';
     const botRef = runtime.getBotRef();
@@ -400,9 +341,6 @@ app.post('/api/runtime-agent', async (c) => {
             if (targetAgent === 'gemini')
                 nextConfig.geminiModel = model;
             if (targetAgent === 'hermes') {
-                // Prefer the active BYOK Profile (the only surface `hermes acp` honors
-                // at runtime); fall back to the legacy `hermesModel` field only when no
-                // Profile is bound, so older configs keep working.
                 if (!setAgentBoundModelId('hermes', model))
                     nextConfig.hermesModel = model;
             }
@@ -422,9 +360,6 @@ app.post('/api/runtime-agent', async (c) => {
                 nextConfig.hermesReasoningEffort = effort;
             if (botRef)
                 botRef.setEffortForAgent(targetAgent, effort);
-            // The effort pick is also the single knob for orchestration: Ultra turns
-            // it on, any concrete rung turns it off (mutual exclusion). Only claude
-            // advertises the capability today.
             if (targetAgent === 'claude') {
                 runtime.runtimePrefs.workflow.claude = effortWorkflow;
                 runtime.setWorkflowEnv('claude', effortWorkflow);
@@ -434,8 +369,6 @@ app.post('/api/runtime-agent', async (c) => {
             }
         }
     }
-    // Workflow orchestration toggle — independent of model/effort (orthogonal
-    // axis), gated to drivers that advertise the capability.
     if (typeof body?.workflow === 'boolean') {
         if (!runtime.isAgent(targetAgent))
             return c.json({ ok: false, error: 'Invalid agent' }, 400);
@@ -450,8 +383,6 @@ app.post('/api/runtime-agent', async (c) => {
         if (botRef)
             botRef.setWorkflowEnabledForAgent(targetAgent, enabled);
     }
-    // Access mode — Claude only (subscription TUI vs `claude -p` API credits).
-    // Persisted preference; takes effect on the next spawned turn.
     if (typeof body?.accessMode === 'string') {
         if (targetAgent !== 'claude')
             return c.json({ ok: false, error: 'accessMode is only supported for claude' }, 400);

package/dist/dashboard/routes/cli.js

@@ -1,26 +1,7 @@
-/**
- * Dashboard API routes for CLI extension management.
- *
- *   GET  /api/extensions/cli/catalog           — merged recommended + detection
- *   POST /api/extensions/cli/refresh           — { id } re-detect one entry
- *   POST /api/extensions/cli/auth/start        — { id } start oauth-web flow
- *   GET  /api/extensions/cli/auth/stream       — SSE stream of a running session
- *   POST /api/extensions/cli/auth/cancel       — { sessionId } kill the child
- *   POST /api/extensions/cli/auth/token        — { id, values } token auth
- *   POST /api/extensions/cli/install           — { id } start auto-install (npm-only)
- *   POST /api/extensions/cli/logout            — { id } sign out
- *
- * Install sessions share the same SESSIONS map and event protocol as the
- * oauth-web flow — the frontend connects to `/auth/stream` and cancels via
- * `/auth/cancel` regardless of how the session was started.
- */
 import { Hono } from 'hono';
 import { stream } from 'hono/streaming';
 import { getCliCatalog, refreshCliStatus, startCliAuthSession, getAuthSession, cancelAuthSession, applyCliToken, logoutCli, startCliInstallSession, } from '../../agent/index.js';
 const app = new Hono();
-// ---------------------------------------------------------------------------
-// Catalog
-// ---------------------------------------------------------------------------
 app.get('/api/extensions/cli/catalog', async (c) => {
     try {
         const items = await getCliCatalog();
@@ -44,9 +25,6 @@ app.post('/api/extensions/cli/refresh', async (c) => {
         return c.json({ ok: false, error: e?.message || 'refresh failed' }, 500);
     }
 });
-// ---------------------------------------------------------------------------
-// OAuth-web auth flow
-// ---------------------------------------------------------------------------
 app.post('/api/extensions/cli/auth/start', async (c) => {
     try {
         const { id } = await c.req.json();
@@ -74,7 +52,6 @@ app.get('/api/extensions/cli/auth/stream', (c) => {
     c.header('X-Accel-Buffering', 'no');
     return stream(c, async (s) => {
         const format = (ev) => `data: ${JSON.stringify(ev)}\n\n`;
-        // Replay backlog so a late client still sees what has been printed.
         if (session.backlog.length) {
             for (const chunk of session.backlog) {
                 await s.write(format({ type: 'output', chunk }));
@@ -101,7 +78,6 @@ app.get('/api/extensions/cli/auth/stream', (c) => {
             await onEvent({ type: 'done', ok: session.ok, exitCode: session.exitCode });
             return;
         }
-        // Heartbeat every 15s so proxies don't close the stream on us.
         const heartbeat = setInterval(() => {
             if (closed) {
                 clearInterval(heartbeat);
@@ -142,9 +118,6 @@ app.post('/api/extensions/cli/auth/cancel', async (c) => {
         return c.json({ ok: false, error: e?.message || 'cancel failed' }, 500);
     }
 });
-// ---------------------------------------------------------------------------
-// Token auth
-// ---------------------------------------------------------------------------
 app.post('/api/extensions/cli/auth/token', async (c) => {
     try {
         const { id, values } = await c.req.json();

package/dist/dashboard/routes/config.js

@@ -1,6 +1,3 @@
-/**
- * Dashboard API routes: configuration, channels, extensions, permissions.
- */
 import { Hono } from 'hono';
 import fs from 'node:fs';
 import path from 'node:path';
@@ -20,14 +17,8 @@ import { getPermissionsStatus, getHostTerminalApp, isValidPermissionKey, request
 import { VERSION } from '../../core/version.js';
 import { runtime } from '../runtime.js';
 import { writeScopedLog } from '../../core/logging.js';
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
 export async function buildBrowserStatusResponse(config = loadUserConfig(), browserState = getManagedBrowserStatus()) {
     const gui = resolveGuiIntegrationConfig(config);
-    // In remote mode the local Chrome state is irrelevant — pikiloom attaches to
-    // the external CDP endpoint and never launches/manages a local browser. Report
-    // the endpoint so the dashboard shows the truth instead of "Chrome missing".
     const remoteCdpUrl = gui.browserEnabled ? getConfiguredRemoteCdpUrl() : null;
     return {
         browser: {
@@ -238,11 +229,7 @@ function openPathWithTarget(filePath, target, isDirectory, location) {
             return;
     }
 }
-// ---------------------------------------------------------------------------
-// Routes
-// ---------------------------------------------------------------------------
 const app = new Hono();
-// Full state (config from file only)
 app.get('/api/state', async (c) => {
     const config = loadUserConfig();
     const setupState = await runtime.buildValidatedSetupState(config);
@@ -271,7 +258,6 @@ app.get('/api/state', async (c) => {
         } : null,
     });
 });
-// Host info
 app.get('/api/host', (c) => {
     const botRef = runtime.getBotRef();
     if (botRef)
@@ -285,15 +271,10 @@ app.get('/api/host', (c) => {
         platform: process.platform, arch: os.arch(),
     });
 });
-// Permissions
 app.get('/api/permissions', (c) => {
     const data = { ...getPermissionsStatus(), hostApp: getHostTerminalApp() };
     return c.json(data);
 });
-// Save config (to ~/.pikiloom/setting.json). Channel reconciliation is
-// handled by ChannelSupervisor via the onUserConfigChange listener — adding,
-// removing, or swapping credentials of an IM channel takes effect in-process
-// without restarting pikiloom.
 app.post('/api/config', async (c) => {
     const body = await c.req.json();
     const merged = { ...loadUserConfig(), ...body };
@@ -301,7 +282,6 @@ app.post('/api/config', async (c) => {
     applyUserConfig(loadUserConfig());
     return c.json({ ok: true, configPath });
 });
-// Validate Telegram token
 app.post('/api/validate-telegram-token', async (c) => {
     const body = await c.req.json();
     const result = await validateTelegramConfig(body.token || '', body.allowedChatIds || '');
@@ -312,7 +292,6 @@ app.post('/api/validate-telegram-token', async (c) => {
         normalizedAllowedChatIds: result.normalizedAllowedChatIds,
     });
 });
-// Validate Feishu credentials
 app.post('/api/validate-feishu-config', async (c) => {
     const body = await c.req.json();
     const startedAt = Date.now();
@@ -331,7 +310,6 @@ app.post('/api/validate-feishu-config', async (c) => {
         app: result.app,
     });
 });
-// Validate Weixin credentials
 app.post('/api/validate-weixin-config', async (c) => {
     const body = await c.req.json();
     const result = await validateWeixinConfig(body.baseUrl || '', body.botToken || '', body.accountId || '');
@@ -342,7 +320,6 @@ app.post('/api/validate-weixin-config', async (c) => {
         normalizedBaseUrl: result.normalizedBaseUrl,
     });
 });
-// Validate Slack credentials
 app.post('/api/validate-slack-config', async (c) => {
     const body = await c.req.json();
     const result = await validateSlackConfig(body.botToken || '', body.appToken || '');
@@ -352,7 +329,6 @@ app.post('/api/validate-slack-config', async (c) => {
         bot: result.bot,
     });
 });
-// Validate Discord credentials
 app.post('/api/validate-discord-config', async (c) => {
     const body = await c.req.json();
     const result = await validateDiscordConfig(body.botToken || '');
@@ -362,7 +338,6 @@ app.post('/api/validate-discord-config', async (c) => {
         bot: result.bot,
     });
 });
-// Validate DingTalk credentials
 app.post('/api/validate-dingtalk-config', async (c) => {
     const body = await c.req.json();
     const result = await validateDingtalkConfig(body.clientId || '', body.clientSecret || '');
@@ -372,7 +347,6 @@ app.post('/api/validate-dingtalk-config', async (c) => {
         app: result.app,
     });
 });
-// Validate WeChat Work (企业微信) credentials
 app.post('/api/validate-wecom-config', async (c) => {
     const body = await c.req.json();
     const result = await validateWecomConfig(body.botId || '', body.botSecret || '');
@@ -382,7 +356,6 @@ app.post('/api/validate-wecom-config', async (c) => {
         bot: result.bot,
     });
 });
-// Start Weixin QR login
 app.post('/api/weixin-login/start', async (c) => {
     const body = await c.req.json();
     const result = await startWeixinQrLogin({
@@ -391,7 +364,6 @@ app.post('/api/weixin-login/start', async (c) => {
     });
     return c.json(result, result.ok ? 200 : 500);
 });
-// Wait for Weixin QR login
 app.post('/api/weixin-login/wait', async (c) => {
     const body = await c.req.json();
     const result = await waitForWeixinQrLogin({
@@ -400,7 +372,6 @@ app.post('/api/weixin-login/wait', async (c) => {
     });
     return c.json(result, result.ok ? 200 : 500);
 });
-// Open macOS preferences
 app.post('/api/open-preferences', async (c) => {
     const body = await c.req.json();
     const permission = String(body.permission || '');
@@ -417,15 +388,7 @@ app.post('/api/open-preferences', async (c) => {
     runtime.log(`[permissions] permission=${permission} action=${result.action} granted=${result.granted} manual=${result.requiresManualGrant} ok=${result.ok}`);
     return c.json(result, result.ok ? 200 : 500);
 });
-// Restart process
 app.post('/api/restart', (c) => {
-    // A successful restart exits this process, so its result can never reach the
-    // client — the route fires it async and returns ok:true. But the restart is
-    // REFUSED while any turn is still running (requestProcessRestart guards on
-    // active tasks so it won't kill in-flight work). Surface that refusal
-    // synchronously: otherwise the dashboard sends ok:true into a "reconnecting"
-    // wait for a restart that never happens and shows a generic failure, with no
-    // hint that a running task is the reason.
     const activeTasks = getActiveTaskCount();
     if (activeTasks > 0) {
         return c.json({
@@ -439,7 +402,6 @@ app.post('/api/restart', (c) => {
     }, 50);
     return c.json({ ok: true });
 });
-// Switch workdir
 app.post('/api/switch-workdir', async (c) => {
     const body = await c.req.json();
     const newPath = body.path;
@@ -455,13 +417,11 @@ app.post('/api/switch-workdir', async (c) => {
     const saved = setUserWorkdir(resolvedPath);
     return c.json({ ok: true, workdir: saved.workdir });
 });
-// Browser profile status
 app.get('/api/browser', async (c) => {
     const config = loadUserConfig();
     const data = await buildBrowserStatusResponse(config);
     return c.json(data);
 });
-// Launch managed browser profile for login/setup
 app.post('/api/browser/setup', async (c) => {
     runtime.log('[browser] setup requested');
     try {
@@ -473,9 +433,6 @@ app.post('/api/browser/setup', async (c) => {
                 error: 'Browser automation is disabled. Enable it first if you want pikiloom to launch the managed browser profile.',
             }, 400);
         }
-        // Remote mode: pikiloom attaches to an external CDP endpoint and owns no
-        // local Chrome. There is nothing to launch — return the (enabled) status as
-        // a clean no-op instead of failing with "Chrome is not available".
         if (getConfiguredRemoteCdpUrl()) {
             runtime.log('[browser] setup skipped: PIKILOOM_BROWSER_CDP_URL configured (external CDP, no local browser to launch)');
             return c.json({ ok: true, ...(await buildBrowserStatusResponse(config)) });
@@ -499,7 +456,6 @@ app.post('/api/browser/setup', async (c) => {
         return c.json({ ok: false, error: detail }, 500);
     }
 });
-// List directory entries for tree browser
 app.get('/api/ls-dir', (c) => {
     const dir = c.req.query('path') || os.homedir();
     const includeFiles = c.req.query('files') === '1';
@@ -521,7 +477,6 @@ app.get('/api/ls-dir', (c) => {
         return c.json({ ok: false, error: err instanceof Error ? err.message : String(err) }, 400);
     }
 });
-// Git changes for a directory (uncommitted + staged)
 app.get('/api/git-changes', (c) => {
     const dir = c.req.query('path');
     if (!dir)
@@ -530,7 +485,6 @@ app.get('/api/git-changes', (c) => {
         if (!fs.existsSync(path.join(dir, '.git'))) {
             return c.json({ ok: true, changes: [], isGit: false });
         }
-        // --no-optional-locks avoids contention with other git processes
         const result = spawnSync('git', ['diff', '--name-status', 'HEAD', '--no-renames'], {
             cwd: dir,
             timeout: 5_000,
@@ -555,8 +509,6 @@ app.get('/api/git-changes', (c) => {
         return c.json({ ok: false, error: err instanceof Error ? err.message : String(err) }, 500);
     }
 });
-// Git status summary for a workspace: branch, ahead/behind, dirty count.
-// Backed by the same readGitStatus helper that feeds the IM /status command.
 app.get('/api/workspace-git', (c) => {
     const dir = c.req.query('path');
     if (!dir)
@@ -564,7 +516,6 @@ app.get('/api/workspace-git', (c) => {
     const git = readGitStatus(dir);
     return c.json({ ok: true, isGit: git !== null, git });
 });
-// Open file/directory in a selected editor or file browser
 app.post('/api/open-in-editor', async (c) => {
     try {
         const body = await c.req.json();
@@ -590,7 +541,6 @@ app.post('/api/open-in-editor', async (c) => {
         return c.json({ ok: false, error: detail }, 500);
     }
 });
-// Open git diff for a file in the selected editor
 app.post('/api/open-diff', async (c) => {
     try {
         const body = await c.req.json();
@@ -600,7 +550,6 @@ app.post('/api/open-diff', async (c) => {
             return c.json({ ok: false, error: 'filePath is required' }, 400);
         const dir = path.dirname(filePath);
         const relFile = path.basename(filePath);
-        // Write the original (HEAD) version to a temp file
         const origResult = spawnSync('git', ['show', `HEAD:${path.relative(findGitRoot(dir), filePath)}`], {
             cwd: dir,
             timeout: 5_000,
@@ -608,14 +557,12 @@ app.post('/api/open-diff', async (c) => {
             env: { ...process.env, GIT_OPTIONAL_LOCKS: '0' },
         });
         if (origResult.status !== 0) {
-            // New file — no HEAD version, just open the file
             openPathWithTarget(filePath, target, false);
             return c.json({ ok: true });
         }
         const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pikiloom-diff-'));
         const origPath = path.join(tmpDir, `${relFile}.orig`);
         fs.writeFileSync(origPath, origResult.stdout);
-        // Use editor CLI diff command (fire-and-forget)
         const cli = target === 'cursor' ? 'cursor' : target === 'windsurf' ? 'windsurf' : 'code';
         const child = spawn(cli, ['--diff', origPath, filePath], {
             cwd: dir,
@@ -623,7 +570,6 @@ app.post('/api/open-diff', async (c) => {
             detached: true,
         });
         child.unref();
-        // Clean up temp after a delay
         setTimeout(() => fs.promises.rm(tmpDir, { recursive: true, force: true }).catch(() => { }), 30_000);
         return c.json({ ok: true });
     }