aicodeman 1.28.2 → 1.29.0

package/dist/web/server.js

@@ -56,6 +56,9 @@ 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 { readCustomModelHosts } from '../custom-model-hosts.js';
+import { applyCustomModelInjection, customModelConfigDir, removeConfigDir } from '../custom-model-injection-apply.js';
 import { registerGeneratedArtifactAttachment } from '../generated-artifact-attachments.js';
 import { buildDetectedAttachmentHistoryItem, buildExternalAttachmentHistoryItem, } from '../session-attachment-history.js';
 import { TranscriptWatcher } from '../transcript-watcher.js';
@@ -103,12 +106,13 @@ import { SseEvent } from './sse-events.js';
 import { getLatestPlanUsage, setLatestCodexPlanUsage } from './plan-usage-latest.js';
 import { telemetrySignature } from '../usage-telemetry.js';
 import { readCodexPlanUsage, resolveCodexBinaryPath } from '../utils/codex-cli-resolver.js';
-import { registerAuthMiddleware, registerSecurityHeaders, registerHostGuard } from './middleware/auth.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, registerScheduledRoutes, registerHookEventRoutes, registerApprovalRoutes, registerReadMyMindRoutes, registerStatusTelemetryRoutes, registerSystemRoutes, registerCaseRoutes, registerSessionRoutes, registerRespawnRoutes, registerRalphRoutes, registerPlanRoutes, registerClipboardRoutes, registerSearchRoutes, registerOrchestratorRoutes, registerCronRoutes, registerMeRoutes, registerAdminRoutes, registerWsRoutes, registerVoiceRoutes, registerWebviewRoutes, registerTabLayoutRoutes, tryWebviewRefererFallback, } from './routes/index.js';
+import { registerPushRoutes, registerTeamRoutes, registerMuxRoutes, registerFileRoutes, registerScheduledRoutes, registerHookEventRoutes, registerApprovalRoutes, 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 { isLostWebviewFrameNavigation } from './webview-proxy.js';
 import { CronService } from '../cron/cron-service.js';
 const __dirname = dirname(fileURLToPath(import.meta.url));
 // Bounded, predictable shape for SSE client identifiers: alphanumerics, `_`, `-`.
@@ -648,7 +652,15 @@ export class WebServer extends EventEmitter {
         });
         // Security headers + CORS
         registerSecurityHeaders(this.app, this.https, this.basePath);
-        this.app.get('/', async (_req, reply) => {
+        this.app.get('/', async (req, reply) => {
+            // A web-tab frame that reloaded on its dashboard's landing page. The proxy's
+            // runtime shim maps `/webview/<cap>/` to exactly `/`, so that reload asks for
+            // Codeman's own root as an iframe navigation, and it used to get the app
+            // shell rendered inside the web tab. Only the credential-free form is taken
+            // (nothing in Codeman frames its root; the sandboxed frame has no cookie and
+            // no Authorization); under a password the auth hook has answered it already.
+            if (isLostWebviewRootFrame(req))
+                return sendLostWebviewFramePage(reply);
             return reply
                 .header('Cache-Control', 'no-cache')
                 .type('text/html; charset=utf-8')
@@ -813,6 +825,12 @@ export class WebServer extends EventEmitter {
             // genuinely unknown `/api` paths still get the envelope below.
             if (await tryWebviewRefererFallback(req, reply, this.basePath))
                 return reply;
+            // An authenticated web-tab frame (Basic auth, or trusted mode with a cookie)
+            // that navigated itself off its proxy prefix: the runtime shim masks the
+            // prefix so the page's router sees its own path, and a reload of that page
+            // lands here. The unauthenticated form is answered in the auth middleware.
+            if (!req.url.startsWith('/api') && isLostWebviewFrameNavigation(req))
+                return sendLostWebviewFramePage(reply);
             if (req.url.startsWith('/api')) {
                 return reply.code(404).send(createErrorResponse(ApiErrorCode.NOT_FOUND, notFound));
             }
@@ -890,6 +908,7 @@ export class WebServer extends EventEmitter {
         registerOrchestratorRoutes(this.app, ctx);
         registerWebviewRoutes(this.app, ctx, this.basePath);
         registerTabLayoutRoutes(this.app, ctx);
+        registerCustomModelRoutes(this.app);
         // Cron: build the service from the same context, recompute
         // due times for any persisted jobs, then expose it to its routes.
         this.cronService = new CronService(ctx);
@@ -986,6 +1005,30 @@ export class WebServer extends EventEmitter {
             }
         });
     }
+    /**
+     * Recovery half of Custom Model Endpoint Profiles: the env values a selection injects
+     * are never persisted (they carry the API key), so they are computed again from the
+     * endpoint store, through the SAME apply path the route uses. Undefined when the
+     * endpoint is gone or the CLI is unregistered: the bookkeeping is still restored so
+     * the selection can be cleared, and the pane keeps running on tmux's retained env.
+     */
+    async _rebuildCustomModelEnv(session, saved) {
+        const entry = getCli(session.mode);
+        if (!entry)
+            return undefined;
+        const endpoint = (await readCustomModelHosts(getDataDir())).find((h) => h.id === saved.endpointId);
+        if (!endpoint) {
+            console.warn(`[WebServer] custom-model endpoint ${saved.endpointId} no longer exists; selection kept for clearing`);
+            return undefined;
+        }
+        try {
+            return applyCustomModelInjection(entry, endpoint, saved.modelId, session.id)?.envOverrides;
+        }
+        catch (err) {
+            console.warn('[WebServer] Failed to rebuild custom-model env on recovery:', err);
+            return undefined;
+        }
+    }
     /** Persists full session state including respawn config to state.json */
     _persistSessionStateNow(session) {
         // See session-manager.updateSessionState: __envOverrides is an internal disk-only
@@ -995,10 +1038,14 @@ export class WebServer extends EventEmitter {
         // __attachmentHistory keeps the private (externalPath-bearing) history on disk,
         // separate from the sanitized public attachmentHistory in toState().
         const attachmentHistory = session.getAttachmentHistoryForPersist();
+        // __customModel keeps the selection's bookkeeping (injected env KEYS, config dir,
+        // launch model; never the values) so recovery can restore and later clear it.
+        const customModel = session.getCustomModelForPersist();
         const state = {
             ...base,
             ...(envOverrides ? { __envOverrides: envOverrides } : {}),
             ...(attachmentHistory ? { __attachmentHistory: attachmentHistory } : {}),
+            ...(customModel ? { __customModel: customModel } : {}),
         };
         const controller = this.respawnControllers.get(session.id);
         if (controller) {
@@ -1177,6 +1224,9 @@ export class WebServer extends EventEmitter {
             // come back to a loader whose file we deleted.
             if (killMux) {
                 void removeAgentSessionPreamble(sessionId);
+                // The per-session custom-model config dir carries the endpoint's API key (pi and
+                // omp embed it literally); it must not outlive the session it was written for.
+                removeConfigDir(customModelConfigDir(sessionId));
             }
             await session.stop(killMux);
             this.sessions.delete(sessionId);
@@ -1465,10 +1515,12 @@ export class WebServer extends EventEmitter {
                 sessionId,
                 filePath,
                 sessionWorkingDir: session.workingDir,
+                remote: session.remote,
             })
             : await registerExternalAttachment(sessionId, filePath, {
                 sessionWorkingDir: session.workingDir,
                 forceWorkspaceConfinement: true,
+                remote: session.remote,
             });
         const record = attachmentRegistry.get(sessionId, event.attachmentId);
         if (record) {
@@ -2449,6 +2501,7 @@ export class WebServer extends EventEmitter {
                         // Note: a legacy CLAUDE_CODE_EFFORT_LEVEL entry is auto-migrated to `effort`
                         // by the Session constructor (env var would hard-lock /effort switching).
                         const savedEnvOverrides = savedState?.__envOverrides;
+                        const savedCustomModel = savedState?.__customModel;
                         // Prefer the private (externalPath-bearing) history; fall back to the
                         // sanitized public copy for sessions persisted before that split.
                         const savedAttachmentHistory = savedState?.__attachmentHistory ??
@@ -2509,6 +2562,15 @@ export class WebServer extends EventEmitter {
                             // when both tabs are on screen.
                             parentSessionId: savedState?.parentSessionId,
                         });
+                        // Custom-model selection survives the restart. The tmux session still carries
+                        // the injected `setenv`s (that is what kept the pane on the endpoint across the
+                        // restart), but `_envOverrides` is rebuilt from a persist that deliberately
+                        // excludes them, so re-derive the values from the endpoint store and re-write
+                        // the isolated config dir; an endpoint that has since been deleted still gets
+                        // the bookkeeping restored, which is what a later clear needs to unset.
+                        if (savedCustomModel) {
+                            session.setCustomModel(savedCustomModel, await this._rebuildCustomModelEnv(session, savedCustomModel));
+                        }
                         // Update session name if it was a "Restored:" placeholder or doesn't match saved name
                         if (savedState?.name && muxSession.name !== savedState.name) {
                             this.mux.updateSessionName(muxSession.sessionId, savedState.name);