aicodeman 1.42.0 → 1.44.0

package/dist/web/server.js

@@ -77,7 +77,7 @@ import { createRequire } from 'node:module';
 import { RunSummaryTracker } from '../run-summary.js';
 import { OrchestratorLoop } from '../orchestrator-loop.js';
 import { getLifecycleLog } from '../session-lifecycle-log.js';
-import { applyWorkspaceHooks, pruneAgentSessionPreambles, removeAgentSessionPreamble } from '../hooks-config.js';
+import { applyWorkspaceHooks, pruneAgentSessionPreambles, readKeepWarmSettingsOrThrow, readPlanUsageTelemetryEnabled, removeAgentSessionPreamble, } from '../hooks-config.js';
 import { PushSubscriptionStore } from '../push-store.js';
 import webpush from 'web-push';
 import { SseStreamManager } from './sse-stream-manager.js';
@@ -89,6 +89,9 @@ import { intentStore } from '../intent-store.js';
 import { AI_CHECK_MODEL } from '../config/ai-defaults.js';
 import { approvalInbox } from './approval-inbox.js';
 import { SCREEN_BLOCKED_SOURCE } from './screen-blocked.js';
+import { PromptCacheKeepWarmService } from '../prompt-cache-keepwarm.js';
+import { composerIsEmpty, plainFrame } from '../session-submit-verifier.js';
+import { detectUsageLimitPause } from '../usage-limit-patterns.js';
 import { stopDeepSeekWeb } from '../deepseek-web-server.js';
 import { wireRespawnListeners, setupTimedRespawn, restoreRespawnController, saveRespawnConfig, } from './respawn-event-wiring.js';
 import { reconcileUpdateOnBoot } from './self-update.js';
@@ -114,15 +117,17 @@ import { MAX_PASTE_IMAGE_BYTES } from '../config/buffer-limits.js';
 import { resolveTerminalHistoryConfig } from '../config/terminal-history.js';
 import { SseEvent } from './sse-events.js';
 import { MAX_ROUTE_PARAM_LENGTH } from './route-helpers.js';
-import { getLatestPlanUsage, setLatestCodexPlanUsage } from './plan-usage-latest.js';
+import { getLatestPlanUsage, setLatestCodexPlanUsage, setLatestCopilotPlanUsage } from './plan-usage-latest.js';
 import { telemetrySignature } from '../usage-telemetry.js';
 import { readCodexPlanUsage, resolveCodexBinaryPath } from '../utils/codex-cli-resolver.js';
+import { isCopilotAvailable } from '../utils/copilot-cli-resolver.js';
+import { readCopilotPlanUsage, readCopilotPlanUsageIfEnabled, resolveCopilotToken, } from '../utils/copilot-plan-usage.js';
 import { registerAuthMiddleware, registerSecurityHeaders, registerHostGuard, isLostWebviewRootFrame, sendLostWebviewFramePage, } from './middleware/auth.js';
 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, registerHtmlViewRoutes, registerScheduledRoutes, registerHookEventRoutes, registerApprovalRoutes, registerRebootRestoreRoutes, registerReadMyMindRoutes, registerGitStatusRoutes, registerStatusTelemetryRoutes, registerSystemRoutes, registerCaseRoutes, registerWorktreeRoutes, registerSessionRoutes, registerRespawnRoutes, registerRalphRoutes, registerPlanRoutes, registerClipboardRoutes, registerSearchRoutes, registerOrchestratorRoutes, registerCronRoutes, registerMeRoutes, registerAdminRoutes, registerWsRoutes, registerVoiceRoutes, registerWebviewRoutes, registerTabLayoutRoutes, registerMcpSyncRoutes, registerWebhookRoutes, registerDoctorRoutes, registerCustomModelRoutes, refreshAllCustomModelHosts, readCustomModelEndpointsEnabled, closeAllLlamaSwapLogTails, detectCustomModelSwapDisplacements, pruneIdleLlamaSwapLogTails, tryWebviewRefererFallback, registerCliRegistryRoutes, } from './routes/index.js';
+import { registerPushRoutes, registerTeamRoutes, registerMuxRoutes, registerFileRoutes, registerHtmlViewRoutes, registerScheduledRoutes, registerHookEventRoutes, registerApprovalRoutes, registerRebootRestoreRoutes, registerReadMyMindRoutes, registerGitStatusRoutes, registerStatusTelemetryRoutes, registerSystemRoutes, registerCaseRoutes, registerWorktreeRoutes, registerSessionRoutes, registerRespawnRoutes, registerRalphRoutes, registerPlanRoutes, registerClipboardRoutes, registerSearchRoutes, registerOrchestratorRoutes, registerCronRoutes, registerMeRoutes, registerAdminRoutes, registerWsRoutes, registerVoiceRoutes, registerWebviewRoutes, registerTabLayoutRoutes, registerMcpSyncRoutes, registerConfigBackupRoutes, runConfigBackup, registerWebhookRoutes, registerDoctorRoutes, registerCustomModelRoutes, refreshAllCustomModelHosts, readCustomModelEndpointsEnabled, closeAllLlamaSwapLogTails, detectCustomModelSwapDisplacements, pruneIdleLlamaSwapLogTails, tryWebviewRefererFallback, registerCliRegistryRoutes, } from './routes/index.js';
 import { isLostWebviewFrameNavigation } from './webview-proxy.js';
 import { CronService } from '../cron/cron-service.js';
 const __dirname = dirname(fileURLToPath(import.meta.url));
@@ -131,6 +136,11 @@ 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;
+// Copilot's quota is read over the network from GitHub, and a monthly figure moves slowly.
+const COPILOT_USAGE_POLL_INTERVAL_MS = 10 * 60_000;
+// Config backups: one cheap read-and-hash of a handful of small files; a snapshot is written only when
+// their content changed since the latest one, so this is one entry per real change, not per tick.
+const CONFIG_BACKUP_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
@@ -196,6 +206,50 @@ export class WebServer extends EventEmitter {
     _customModelDisplacedNotified = new Set();
     /** Cron service (assigned in setupRoutes). */
     cronService;
+    // Prompt-cache keep-warm (prompt-cache-keepwarm.ts): the rulebook and timers live in the
+    // service; the server only lends it the facts a decision needs. A field initializer, not a
+    // setupRoutes() step: cleanup and listener wiring reach it on servers that never set up routes
+    // (the pane-exit and discard tests build a bare WebServer), and every port reads `this.*` lazily.
+    keepWarmService = new PromptCacheKeepWarmService({
+        getSession: (id) => this.sessions.get(id),
+        sessionIds: () => this.sessions.keys(),
+        readSettings: readKeepWarmSettingsOrThrow,
+        isAutomationActive: (id) => {
+            const session = this.sessions.get(id);
+            if (!session)
+                return true;
+            return ((this.respawnControllers.get(id)?.isRunning ?? false) ||
+                session.ralphTracker.loopState.active ||
+                session.currentTaskId !== null ||
+                sessionWaits.signalWaiterCount(id) > 0);
+        },
+        hasPendingApproval: (id) => approvalInbox.listPending().some((item) => item.sessionId === id && item.kind !== 'idle'),
+        readPane: (view) => {
+            const session = view;
+            const muxName = session.muxName;
+            // `capture-pane -p -e`: the visible frame with its styles, which is how `composerIsEmpty()`
+            // tells Claude Code's faint prompt suggestion from a typed draft.
+            const text = muxName ? (this.mux.capturePaneText?.(muxName, undefined, { styles: true }) ?? null) : null;
+            if (!text)
+                return { composerEmpty: null, limitShown: false };
+            const limit = detectUsageLimitPause(plainFrame(text));
+            return {
+                composerEmpty: composerIsEmpty(text, getCli(session.mode)?.capabilities.workDetect?.promptGlyph ?? '') ?? null,
+                limitShown: limit !== null && limit.resetAt > Date.now(),
+            };
+        },
+        publish: (id, status) => {
+            const session = this.sessions.get(id);
+            if (!session?.setKeepWarmStatus(status))
+                return;
+            this.broadcast(SseEvent.SessionKeepWarm, { sessionId: id, ...status });
+            // Change-only, so one line per transition names whichever guard holds it now.
+            if (status.state !== 'off' || status.reason !== 'off') {
+                console.log(`[KeepWarm] ${id.slice(0, 8)}: ${status.state}${status.reason ? ` (${status.reason})` : ''}`);
+            }
+        },
+        log: (message) => console.log(message),
+    });
     /**
      * Wake-on-LAN registry, returned by `registerSessionRoutes`. Held for its LIFETIME
      * only — `drop()` on session cleanup, `stop()` on shutdown. Waking from here would
@@ -232,6 +286,8 @@ export class WebServer extends EventEmitter {
     lastRecordedTokens = new Map();
     codexUsageRefreshInFlight = false;
     lastCodexUsageSignature = null;
+    copilotUsageRefreshInFlight = false;
+    lastCopilotUsageSignature = null;
     // Server startup time for respawn grace period calculation
     serverStartTime = Date.now();
     // Pending respawn start timers (for cleanup on shutdown)
@@ -315,6 +371,7 @@ export class WebServer extends EventEmitter {
             // Fresh, not the 2s cache: the settings PUT does not invalidate it, and a
             // flip must apply to the very next spawn.
             childrenFollowParent: async () => (await this.readSettings(true)).spawnedTabsFollowParent === true,
+            caseDefaults: this.store,
         });
         if (this.testMode)
             this.tabLayouts.markRestorationSkipped();
@@ -551,8 +608,8 @@ export class WebServer extends EventEmitter {
     /**
      * Add a tentative session only after its owner layout accepts the creation.
      * The session enters the live map inside the layout service's owner lock, so
-     * the placement it asked for (`tabGroupId`) lands in the same versioned write
-     * that first records it.
+     * the placement it asked for (`tabGroupId`, else its case's default group)
+     * lands in the same versioned write that first records it.
      */
     async registerSessionWithLayout(session, placement) {
         return this.tabLayouts.sessionCreated(ownerLayoutKey(session.owner), session.id, placement, () => {
@@ -573,6 +630,7 @@ export class WebServer extends EventEmitter {
         return {
             // SessionPort
             sessions: this.sessions,
+            keepWarm: this.keepWarmService,
             addSession: this.registerSessionWithLayout.bind(this),
             tabLayouts: this.tabLayouts,
             cleanupSession: this.cleanupSession.bind(this),
@@ -782,7 +840,7 @@ export class WebServer extends EventEmitter {
             // `ServerResponse` to a `FastifyReply`, so it is `reply.header()` here and
             // NOT `res.setHeader()`. A v9-style body throws TypeError on every static
             // request, which is every page load. See the v10.0.0 release notes.
-            setHeaders: (reply) => {
+            setHeaders: (reply, filePath) => {
                 // ⚠️ That same change ALSO flipped precedence, and silently. Under v9 this
                 // callback wrote to the raw response and Fastify's staged reply headers then
                 // overwrote it, so a route that set its own Cache-Control before .sendFile()
@@ -792,6 +850,15 @@ export class WebServer extends EventEmitter {
                 // So: a route that already decided keeps its answer.
                 if (reply.getHeader('Cache-Control') !== undefined)
                     return;
+                // A JSON file here is DATA the page fetches at runtime (whats-new.json is rewritten every
+                // release, security-notices.json by hand, manifest.json), never content-hashed and never
+                // `?v=`-busted, so it must revalidate. Under `immutable` a browser may keep last release's
+                // copy for a year, and the page's `fetch(..., { cache: 'no-cache' })` is the only thing
+                // asking it not to; the response header is what every browser honours.
+                if (filePath.endsWith('.json')) {
+                    reply.header('Cache-Control', 'no-cache');
+                    return;
+                }
                 reply.header('Cache-Control', 'public, max-age=31536000, immutable');
             },
         });
@@ -984,6 +1051,7 @@ export class WebServer extends EventEmitter {
         registerWebviewRoutes(this.app, ctx, this.basePath);
         registerTabLayoutRoutes(this.app, ctx);
         registerMcpSyncRoutes(this.app);
+        registerConfigBackupRoutes(this.app);
         registerWebhookRoutes(this.app, {
             notifier: this.webhookNotifier,
             configDir: getDataDir(),
@@ -1194,6 +1262,7 @@ export class WebServer extends EventEmitter {
     }
     async _doCleanupSession(sessionId, killMux, reason, coordinateLayout = true) {
         const session = this.sessions.get(sessionId);
+        this.keepWarmService.remove(sessionId);
         const pinned = session?.pinned === true || this.store.getSession(sessionId)?.pinned === true;
         if (coordinateLayout && session && killMux && !pinned) {
             return this.tabLayouts.runSessionDeletion([{ id: sessionId, owner: session.owner }], () => this._doCleanupSession(sessionId, killMux, reason, false));
@@ -1616,6 +1685,9 @@ export class WebServer extends EventEmitter {
         });
     }
     async setupSessionListeners(session) {
+        // First keep-warm evaluation: publishes the effective opt-in for the Session Options
+        // readout even before any cache report arrives.
+        void this.keepWarmService.schedule(session.id);
         // Idempotent: the wiring exit handler detaches ALL listeners on every PTY exit
         // (removeSessionListenerRefs), so the re-attach routes (/interactive,
         // /interactive-respawn, /shell) call this again to restore observability
@@ -1644,6 +1716,7 @@ export class WebServer extends EventEmitter {
     buildSessionListenerDeps() {
         return {
             broadcast: this.broadcast.bind(this),
+            keepWarmSchedule: (id) => void this.keepWarmService.schedule(id),
             batchTerminalData: this.batchTerminalData.bind(this),
             batchTaskUpdate: this.batchTaskUpdate.bind(this),
             broadcastSessionStateDebounced: this.broadcastSessionStateDebounced.bind(this),
@@ -2543,6 +2616,36 @@ export class WebServer extends EventEmitter {
             this.codexUsageRefreshInFlight = false;
         }
     }
+    /**
+     * Copilot's monthly premium-request quota for the shared plan-usage chip. Host-scoped and read-only
+     * like the Codex poll, and additionally gated by `readCopilotPlanUsageIfEnabled()`: only while
+     * plan-usage display is on (so turning the chip off also stops the outbound request), only with a
+     * sign-in token and only with the Copilot CLI installed; nothing is sent to GitHub otherwise.
+     */
+    async refreshCopilotPlanUsage() {
+        if (this.copilotUsageRefreshInFlight)
+            return;
+        this.copilotUsageRefreshInFlight = true;
+        try {
+            // A null clears the row, so switching the chip off also takes the last quota off the page.
+            const usage = await readCopilotPlanUsageIfEnabled({
+                planUsageEnabled: readPlanUsageTelemetryEnabled,
+                resolveToken: () => resolveCopilotToken(),
+                copilotInstalled: isCopilotAvailable,
+                read: (token) => readCopilotPlanUsage({ token }),
+            });
+            const signature = usage ? telemetrySignature(usage) : '';
+            if (signature === this.lastCopilotUsageSignature)
+                return;
+            this.lastCopilotUsageSignature = signature;
+            const snapshot = setLatestCopilotPlanUsage(usage);
+            this.cachedLightState = null;
+            this.broadcast(SseEvent.SessionStatusTelemetry, snapshot);
+        }
+        finally {
+            this.copilotUsageRefreshInFlight = false;
+        }
+    }
     async start() {
         // Multi-user first boot: create the initial admin from CODEMAN_USERNAME/PASSWORD
         // if there are no users yet, else refuse to start (there would be no way in).
@@ -2674,6 +2777,14 @@ export class WebServer extends EventEmitter {
         // Ensure the COD-54 hook secret exists on disk before any session exports
         // $CODEMAN_HOOK_SECRET_FILE — hook curls cat that path at execution time.
         getHookSecret();
+        // Config backups: a snapshot at start (the state the process found) and then on change.
+        if (!this.testMode) {
+            const backup = (reason) => void runConfigBackup(reason).catch((err) => console.warn('[config-backup] snapshot failed:', err instanceof Error ? err.message : err));
+            backup('startup');
+            this.cleanup.setInterval(() => backup('auto'), CONFIG_BACKUP_INTERVAL_MS, {
+                description: 'Config backup',
+            });
+        }
         // Main Codex subscription limits come from the signed-in local CLI. Keep
         // this read-only and host-scoped; multi-user SSE routing makes it admin-only.
         if (!this.testMode) {
@@ -2681,6 +2792,10 @@ export class WebServer extends EventEmitter {
             this.cleanup.setInterval(() => void this.refreshCodexPlanUsage(), CODEX_USAGE_POLL_INTERVAL_MS, {
                 description: 'Codex plan-usage refresh',
             });
+            void this.refreshCopilotPlanUsage();
+            this.cleanup.setInterval(() => void this.refreshCopilotPlanUsage(), COPILOT_USAGE_POLL_INTERVAL_MS, {
+                description: 'Copilot 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
@@ -3161,6 +3276,7 @@ export class WebServer extends EventEmitter {
                             antigravityConfig: muxSession.mode === 'antigravity' ? savedState?.antigravityConfig : undefined,
                             piConfig: muxSession.mode === 'pi' ? savedState?.piConfig : undefined,
                             grokConfig: muxSession.mode === 'grok' ? savedState?.grokConfig : undefined,
+                            copilotConfig: muxSession.mode === 'copilot' ? savedState?.copilotConfig : undefined,
                             deepSeekConfig: muxSession.mode === 'deepseek' ? savedState?.deepSeekConfig : undefined,
                             ompConfig: muxSession.mode === 'omp' ? savedState?.ompConfig : undefined,
                             envOverrides: savedEnvOverrides,
@@ -3172,6 +3288,10 @@ export class WebServer extends EventEmitter {
                             // the launch conversation until the user types again, even though
                             // the re-attached CLI is on a post-`/clear` one.
                             lastSubmitAt: savedState?.lastSubmitAt,
+                            // The keep-warm choice and its cap's clock; with the restored `promptCache`
+                            // below, a future `expiresAt` re-arms the timer once the pane is attached.
+                            lastRealPromptAt: savedState?.lastRealPromptAt,
+                            keepWarmEnabled: savedState?.keepWarmEnabled,
                             // Conversations this pane provably owned, oldest first. Its tail is
                             // the conversation the CLI was on when the server stopped, which is
                             // what a re-attach must point the viewer at instead of the launch id.
@@ -3584,6 +3704,7 @@ export class WebServer extends EventEmitter {
         // response), so without this a 10-minute wait holds shutdown open.
         sessionWaits.cancelEverything();
         approvalInbox.stop();
+        this.keepWarmService.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.