aicodeman 1.30.0 → 1.32.0

package/dist/web/server.js

@@ -42,6 +42,7 @@ import { hostname as getHostname, uptime as osUptime } from 'node:os';
 import { looksLikeHostReboot, newestPersistedActivity, planRebootRestore } from '../reboot-restore.js';
 import { rebootRestoreRegistry } from './reboot-restore-registry.js';
 import { dataPath, getDataDir, CODEMAN_INSTANCE } from '../config/instance.js';
+import { readRemoteHosts, rehydrateRemoteHostFields } from '../remote-hosts.js';
 import { normalizeBasePath, stripBasePath, joinBasePath } from '../config/base-path.js';
 import { GLYPH, palette } from '../cli-style.js';
 import { getHookSecret } from '../config/hook-secret.js';
@@ -58,7 +59,7 @@ import { subagentWatcher, } from '../subagent-watcher.js';
 import { imageWatcher } from '../image-watcher.js';
 import { workflowRunWatcher, summarizeRun } from '../workflow-run-watcher.js';
 import { attachmentRegistry, buildFileThumbnailRoute, registerExternalAttachment } from '../attachment-registry.js';
-import { getCli } from '../config/cli-registry/registry.js';
+import { getCli, enabledClis } from '../config/cli-registry/registry.js';
 import { readCustomModelHosts } from '../custom-model-hosts.js';
 import { applyCustomModelInjection, customModelConfigDir, removeConfigDir } from '../custom-model-injection-apply.js';
 import { registerGeneratedArtifactAttachment } from '../generated-artifact-attachments.js';
@@ -113,7 +114,7 @@ import { isMultiUserMode } from '../config/multiuser.js';
 import { bootstrapInitialAdmin, hasUsers, resolveClaudeModeForUsername } from '../user-store.js';
 import { installRouteErrorHandler } from './route-error-handler.js';
 import { isExplicitlyEnabled, isLoopbackBindHost, buildHostPolicy } from './network-auth-policy.js';
-import { registerPushRoutes, registerTeamRoutes, registerMuxRoutes, registerFileRoutes, registerScheduledRoutes, registerHookEventRoutes, registerApprovalRoutes, registerRebootRestoreRoutes, registerReadMyMindRoutes, registerStatusTelemetryRoutes, registerSystemRoutes, registerCaseRoutes, registerSessionRoutes, registerRespawnRoutes, registerRalphRoutes, registerPlanRoutes, registerClipboardRoutes, registerSearchRoutes, registerOrchestratorRoutes, registerCronRoutes, registerMeRoutes, registerAdminRoutes, registerWsRoutes, registerVoiceRoutes, registerWebviewRoutes, registerTabLayoutRoutes, registerCustomModelRoutes, tryWebviewRefererFallback, } from './routes/index.js';
+import { registerPushRoutes, registerTeamRoutes, registerMuxRoutes, registerFileRoutes, registerScheduledRoutes, registerHookEventRoutes, registerApprovalRoutes, registerRebootRestoreRoutes, registerReadMyMindRoutes, registerStatusTelemetryRoutes, registerSystemRoutes, registerCaseRoutes, registerSessionRoutes, registerRespawnRoutes, registerRalphRoutes, registerPlanRoutes, registerClipboardRoutes, registerSearchRoutes, registerOrchestratorRoutes, registerCronRoutes, registerMeRoutes, registerAdminRoutes, registerWsRoutes, registerVoiceRoutes, registerWebviewRoutes, registerTabLayoutRoutes, registerCustomModelRoutes, refreshAllCustomModelHosts, readCustomModelEndpointsEnabled, closeAllLlamaSwapLogTails, detectCustomModelSwapDisplacements, pruneIdleLlamaSwapLogTails, tryWebviewRefererFallback, } from './routes/index.js';
 import { isLostWebviewFrameNavigation } from './webview-proxy.js';
 import { CronService } from '../cron/cron-service.js';
 const __dirname = dirname(fileURLToPath(import.meta.url));
@@ -122,9 +123,29 @@ const __dirname = dirname(fileURLToPath(import.meta.url));
 // while capping growth of `sseClientsById` and blocking pathological inputs.
 const SSE_CLIENT_ID_RE = /^[A-Za-z0-9_-]{8,64}$/;
 const CODEX_USAGE_POLL_INTERVAL_MS = 5 * 60_000;
+const CUSTOM_MODEL_REDISCOVER_INTERVAL_MS = 5 * 60_000;
+// Much shorter than the model-LIST refresh above on purpose: this catches an actual
+// eviction (a session's model no longer loaded, silently swapped out by another
+// session's use), which the user wants to know about promptly, not once every 5
+// minutes. Cheap either way — one /running GET per distinct endpoint with at least
+// one live custom-model session, not per session.
+const CUSTOM_MODEL_SWAP_CHECK_INTERVAL_MS = 20_000;
 function escapeHtmlText(value) {
     return value.replaceAll('&', '&amp;').replaceAll('<', '&lt;').replaceAll('>', '&gt;');
 }
+/**
+ * Escapes a JSON string for safe embedding as the body of an inline `<script>`
+ * tag: `<` becomes the six-character sequence `<`, which both a JSON
+ * parser and a plain JS string literal decode back to `<` (both treat
+ * `\uXXXX` identically), but which can never itself form the two literal
+ * characters `<` `/` a browser's HTML tokenizer looks for to end the tag. A
+ * value containing a literal `</script>` would otherwise close the tag early
+ * and turn the rest of the document into inert script-body text. Exported so
+ * it unit-tests without constructing a WebServer (which needs a real tmux).
+ */
+export function escapeScriptJson(json) {
+    return json.replace(/</g, '\\u003c');
+}
 import { SESSIONS_LIST_CACHE_TTL, SCHEDULED_CLEANUP_INTERVAL, SCHEDULED_RUN_MAX_AGE, SSE_HEARTBEAT_INTERVAL, SESSION_LIMIT_WAIT_MS, ITERATION_PAUSE_MS, STATS_COLLECTION_INTERVAL_MS, INACTIVITY_TIMEOUT_MS, CRON_TICK_INTERVAL, } from '../config/server-timing.js';
 /**
  * Get or generate a self-signed TLS certificate for HTTPS.
@@ -163,8 +184,18 @@ export class WebServer extends EventEmitter {
     // Store session listener references for explicit cleanup (prevents memory leaks)
     sessionListenerRefs = new Map();
     scheduledRuns = new Map();
+    /** De-dupe state for the swap-displacement sweep — see detectCustomModelSwapDisplacements. */
+    _customModelDisplacedNotified = new Set();
     /** Cron service (assigned in setupRoutes). */
     cronService;
+    /**
+     * Wake-on-LAN registry, returned by `registerSessionRoutes`. Held for its LIFETIME
+     * only — `drop()` on session cleanup, `stop()` on shutdown. Waking from here would
+     * re-wake a host on every timer tick (the invariant `remote-wake.ts` documents), so
+     * the wiring guard in `test/remote-wake.test.ts` pins that this file calls nothing
+     * but `drop`/`stop` on it.
+     */
+    remoteWake = null;
     sse;
     store = getStore();
     tabLayouts;
@@ -902,7 +933,9 @@ export class WebServer extends EventEmitter {
         registerStatusTelemetryRoutes(this.app, ctx);
         registerSystemRoutes(this.app, ctx);
         registerCaseRoutes(this.app, ctx);
-        registerSessionRoutes(this.app, ctx);
+        // The registry's lifetime is the server's: it drops per-session wake state on every
+        // cleanup path and resolves in-flight wakes on shutdown.
+        this.remoteWake = registerSessionRoutes(this.app, ctx);
         registerRespawnRoutes(this.app, ctx);
         registerRalphRoutes(this.app, ctx);
         registerPlanRoutes(this.app, ctx);
@@ -1027,7 +1060,7 @@ export class WebServer extends EventEmitter {
             return undefined;
         }
         try {
-            return applyCustomModelInjection(entry, endpoint, saved.modelId, session.id)?.envOverrides;
+            return applyCustomModelInjection(entry, endpoint, saved.modelId, session.id, endpoint.modelContextLengths?.[saved.modelId])?.envOverrides;
         }
         catch (err) {
             console.warn('[WebServer] Failed to rebuild custom-model env on recovery:', err);
@@ -1112,6 +1145,9 @@ export class WebServer extends EventEmitter {
         if (session) {
             session.ralphTracker.stopWatchingFixPlan();
         }
+        // Custom Model Endpoint Profiles: drop this session's swap-displacement notify flag
+        // (see _checkCustomModelSwapDisplacements below) so it can't linger in that Set forever.
+        this._customModelDisplacedNotified.delete(sessionId);
         // Kill all subagents spawned by this session (scoped to sessionId to avoid cross-session kills)
         if (session && killMux) {
             try {
@@ -1251,6 +1287,11 @@ export class WebServer extends EventEmitter {
         sessionWaits.notifySignal(sessionId, 'exit');
         sessionWaits.cancelAll(sessionId);
         approvalInbox.resolveForSession(sessionId, 'session_ended');
+        // Wake state goes with the session on EVERY cleanup path (delete routes, the cron
+        // and admin paths, scheduled-run teardown, error paths) — that is why it lives here
+        // rather than in the two delete routes, where it left an entry behind, including up
+        // to 4 KB of the user's buffered keystrokes.
+        this.remoteWake?.drop(sessionId);
         this.broadcast(SseEvent.SessionDeleted, { id: sessionId });
     }
     async renderIndexHtml(soloSessionId) {
@@ -1307,9 +1348,17 @@ export class WebServer extends EventEmitter {
         // the /session/:id URL path; this global is a belt-and-suspenders fallback.
         // The id is gated to JSON + <-escaped so it can't break out of the inline
         // <script> (ids are UUIDs in practice, but defense-in-depth is cheap).
+        //
+        // Every `</head>` injection below passes a replacer FUNCTION, never a
+        // replacement STRING: `String.replace` interprets `$&`, `$'`, `` $` `` and
+        // `$<n>` inside a string replacement, so a payload carrying `$'` would splice
+        // the rest of the document (the whole <body>) into the inline script, past
+        // any escaping applied to the payload itself. The custom-model list below
+        // carries a user-settable `label` (clis.json), which is the site that made
+        // this real; the others follow the same rule so the class of bug stays out.
         if (soloSessionId) {
             const safeId = JSON.stringify(soloSessionId).replace(/</g, '\\u003c');
-            html = html.replace('</head>', `<script>window.__CODEMAN_SOLO__=${safeId};</script>\n</head>`);
+            html = html.replace('</head>', () => `<script>window.__CODEMAN_SOLO__=${safeId};</script>\n</head>`);
         }
         // Gesture-control overlay (Phase 5): dashboard only (not solo popups, which
         // have no tab strip). `CODEMAN_GESTURE=1` makes the feature *available* on
@@ -1367,15 +1416,29 @@ export class WebServer extends EventEmitter {
                 // keep without git (issue #236), same reasoning as cloudflared above.
                 git: isGitAvailable(),
             };
-            html = html.replace('</head>', `<script>window.__codemanCliAvailable=${JSON.stringify(available)};</script>\n</head>`);
+            html = html.replace('</head>', () => `<script>window.__codemanCliAvailable=${JSON.stringify(available)};</script>\n</head>`);
+            // Which run modes the Run-menu picker (docs/custom-model-endpoints-plan.md) may
+            // generate an entry for: read generically off the registry's `capabilities`
+            // (never an id list here) so a CLI whose customModelInjection lands later shows
+            // up in the picker with no frontend change, and one that ships `unsupported`
+            // (antigravity, and `shell`'s `kind !== 'agent'`) never does.
+            const customModelClis = enabledClis()
+                .filter((entry) => entry.kind === 'agent' && entry.capabilities.customModelInjection.kind !== 'unsupported')
+                .map((entry) => ({ id: entry.id, label: entry.label }));
+            // Unlike the boolean-only __codemanCliAvailable above, this payload carries
+            // `label`, a string a user's own clis.json can set (CliEntry.label, up to 60
+            // chars) — see escapeScriptJson's own doc comment for why that needs escaping
+            // and __codemanCliAvailable's booleans never did.
+            const customModelClisJson = escapeScriptJson(JSON.stringify(customModelClis));
+            html = html.replace('</head>', () => `<script>window.__codemanCustomModelClis=${customModelClisJson};</script>\n</head>`);
         }
         if (!soloSessionId && process.env.CODEMAN_GESTURE === '1') {
-            html = html.replace('</head>', `<script>window.__codemanGestureAvailable=true;</script>\n</head>`);
+            html = html.replace('</head>', () => `<script>window.__codemanGestureAvailable=true;</script>\n</head>`);
             if (settings.gestureControlEnabled === true) {
                 const v = this.gestureBundleVersion();
                 // Relative src so the injected `<base href>` resolves it under the mount
                 // prefix (a root-absolute `/gesture/...` would escape a sub-path mount).
-                html = html.replace('</head>', `<script type="module" src="gesture/gesture-codeman.js${v}"></script>\n</head>`);
+                html = html.replace('</head>', () => `<script type="module" src="gesture/gesture-codeman.js${v}"></script>\n</head>`);
             }
         }
         return html;
@@ -2019,11 +2082,20 @@ export class WebServer extends EventEmitter {
             'scheduled:',
             'team:',
             'case:',
+            'remote:',
+            'custom-model:',
         ];
         if (SESSION_PREFIXES.some((p) => event.startsWith(p))) {
             const d = (data ?? {});
             const sessionId = d.sessionId ?? d.id ?? d.session?.id;
             const owner = sessionId ? this.sessions.get(sessionId)?.owner : undefined;
+            // `remote:hostWaking` / `remote:hostWakeFailed` for a create/attach wake have no
+            // session yet (nothing exists until the host is up), so the registry names the
+            // requesting user instead; the payload carries `hostId`/`label`, which non-admins
+            // are not shown elsewhere. No session and no requester: admins only (fail closed).
+            if (!sessionId && event.startsWith('remote:') && d.username) {
+                return { username: d.username, sessionScoped: true };
+            }
             return { owner, sessionScoped: true };
         }
         // #20/#38: clipboard:write writes into the receiver's OS clipboard — route it to
@@ -2343,6 +2415,55 @@ export class WebServer extends EventEmitter {
                 description: 'Codex plan-usage refresh',
             });
         }
+        // Custom Model Endpoint Profiles (docs/custom-model-endpoints-plan.md): keeps
+        // each saved endpoint's discovered model list current with no manual
+        // "Discover" click, so a model added on the server side (or one that drops
+        // off) shows up in the Run-menu picker within one cycle. Best-effort per
+        // endpoint (refreshAllCustomModelHosts skips one that's unreachable rather
+        // than failing the sweep) and off in tests for the same reason the Codex
+        // poll above is — no real network to hit, no server instance to keep alive.
+        if (!this.testMode) {
+            this.cleanup.setInterval(() => {
+                // Reads the setting fresh on every tick, same reasoning as
+                // readPlanUsageTelemetryEnabled() beside it: a live toggle takes effect
+                // on the very next cycle, not just at server boot, and turning the
+                // feature off actually stops the polling instead of only hiding the UI.
+                void readCustomModelEndpointsEnabled()
+                    .then((enabled) => {
+                    if (!enabled)
+                        return;
+                    return refreshAllCustomModelHosts();
+                })
+                    .catch((err) => {
+                    console.error('[custom-model] periodic re-discovery failed:', getErrorMessage(err));
+                });
+            }, CUSTOM_MODEL_REDISCOVER_INTERVAL_MS, { description: 'custom model endpoint re-discovery' });
+        }
+        // Custom Model Endpoint Profiles: the swap-conflict check on the apply/create routes
+        // only ever runs at THAT session's own launch/apply moment — it cannot catch a LATER
+        // eviction triggered by a different session's normal use, since llama-swap has no push
+        // notification of its own and only swaps in response to a real inference request
+        // (confirmed live: a session created while nothing else conflicted at that instant can
+        // still get silently displaced afterward). This periodic sweep is what catches that
+        // case after the fact and tells the displaced session's user, rather than leaving them
+        // to discover it only when their next prompt behaves unexpectedly.
+        if (!this.testMode) {
+            this.cleanup.setInterval(() => {
+                detectCustomModelSwapDisplacements(this.sessions.values(), this._customModelDisplacedNotified)
+                    .then((displacements) => {
+                    for (const displacement of displacements) {
+                        this.broadcast(SseEvent.CustomModelSwappedOut, displacement);
+                    }
+                })
+                    .catch((err) => {
+                    console.error('[custom-model] swap-displacement check failed:', getErrorMessage(err));
+                });
+                // Same cadence, unrelated concern: close any /api/events tail (see
+                // getLatestLlamaSwapLogLine) nothing has polled in a while, so a loading banner
+                // that finished (or was abandoned) doesn't leave a connection open forever.
+                pruneIdleLlamaSwapLogTails();
+            }, CUSTOM_MODEL_SWAP_CHECK_INTERVAL_MS, { description: 'custom model swap-displacement check' });
+        }
         // Start scheduled runs cleanup timer
         this.cleanup.setInterval(() => {
             this.cleanupScheduledRuns();
@@ -2718,6 +2839,9 @@ export class WebServer extends EventEmitter {
                 console.log(`[Server] Found ${alive.length + discovered.length} alive mux session(s) from previous run`);
                 // For each alive mux session, create a Session object if it doesn't exist
                 const muxSessions = this.mux.getSessions();
+                // Host-level config lives in remote-hosts.json, not in the persisted session
+                // snapshot, so refresh the fields that only exist there (see the helper).
+                const remoteHostsById = new Map((await readRemoteHosts(getDataDir())).map((host) => [host.id, host]));
                 for (const muxSession of muxSessions) {
                     if (!this.sessions.has(muxSession.sessionId)) {
                         // Restore session settings from state.json (single source of truth)
@@ -2792,7 +2916,9 @@ export class WebServer extends EventEmitter {
                             // respawn rebuilds a LOCAL command, breaking the pane and silently
                             // erasing `remote` from state.json on the next persist. mux-sessions.json
                             // round-trips MuxSession.remote; state.json carries SessionState.remote.
-                            remote: muxSession.remote ?? savedState?.remote,
+                            // Host-level fields are refreshed from remote-hosts.json on top, or a
+                            // field added to the host config after launch would never arrive.
+                            remote: rehydrateRemoteHostFields(muxSession.remote ?? savedState?.remote, remoteHostsById),
                             // Docker metadata round-trips the same way (mux-sessions.json carries
                             // MuxSession.docker; state.json carries SessionState.docker), so recovery
                             // rebuilds the `docker exec` launch instead of a broken local command.
@@ -3137,6 +3263,9 @@ export class WebServer extends EventEmitter {
         // port against the next start — the exact EADDRINUSE this feature already
         // got wrong once.
         void stopDeepSeekWeb();
+        // Same teardown rule: the per-endpoint llama-swap log tails are otherwise closed
+        // only by the periodic idle sweep, whose interval is disposed just below.
+        closeAllLlamaSwapLogTails();
         // Dispose all managed timers (intervals + resettable timeouts)
         this.cleanup.dispose();
         // Gracefully close all SSE connections and clear batching state
@@ -3146,6 +3275,10 @@ export class WebServer extends EventEmitter {
         // response), so without this a 10-minute wait holds shutdown open.
         sessionWaits.cancelEverything();
         approvalInbox.stop();
+        // Same reason as `cancelEverything` above: an in-flight wake is awaited by a request,
+        // and `app.close()` (the last line of this method) does not abort in-flight requests —
+        // so without this a restart during a wake waits out the readiness poll.
+        this.remoteWake?.stop();
         this.lastRecordedTokens.clear();
         // Stop multiplexer and flush pending saves
         this.mux.destroy();