aicodeman 1.5.0 → 1.6.0

package/dist/web/routes/session-routes.js

@@ -12,7 +12,8 @@ import { randomBytes } from 'node:crypto';
 import { ApiErrorCode, createErrorResponse, getErrorMessage, } from '../../types.js';
 import { Session, isAltScreenStripMode } from '../../session.js';
 import { SseEvent } from '../sse-events.js';
-import { CreateSessionSchema, SessionNameSchema, SessionColorSchema, RunPromptSchema, SessionInputWithLimitSchema, ResizeSchema, AutoClearSchema, AutoCompactSchema, AutoResumeSchema, ImageWatcherSchema, FlickerFilterSchema, QuickRunSchema, QuickStartSchema, InteractiveStartSchema, } from '../schemas.js';
+import { CreateSessionSchema, SessionNameSchema, SessionColorSchema, RunPromptSchema, SessionInputWithLimitSchema, ResizeSchema, AutoClearSchema, AutoCompactSchema, AutoResumeSchema, PinSessionSchema, ImageWatcherSchema, FlickerFilterSchema, QuickRunSchema, QuickStartSchema, InteractiveStartSchema, SessionOrderUpdateSchema, } from '../schemas.js';
+import { mergeSessionOrder } from '../../session-order.js';
 import { autoConfigureRalph, canAccessOwned, CASES_DIR, findSessionOrFail, getAuthUser, isAdmin, isWorkingDirAllowed, ownerFor, parseBody, persistAndBroadcastSession, resolveCasesDir, sessionCapacityMessage, SETTINGS_PATH, validatePathWithinBase, } from '../route-helpers.js';
 import { canUsernameRunPrivilegedCommands, resolveClaudeModeForUsername } from '../../user-store.js';
 import { isMultiUserMode } from '../../config/multiuser.js';
@@ -27,8 +28,8 @@ import { RunSummaryTracker } from '../../run-summary.js';
 import { MAX_INPUT_LENGTH, MAX_SESSION_NAME_LENGTH } from '../../config/terminal-limits.js';
 import { MAX_PASTE_IMAGE_BYTES } from '../../config/buffer-limits.js';
 import { dataPath, getDataDir } from '../../config/instance.js';
-import { checkRemoteTmuxAvailable, readRemoteCases, readRemoteHosts, toSessionRemote } from '../../remote-hosts.js';
-import { checkDockerAvailable, checkDockerTmuxAvailable, ensureAgentBaseImage, DEFAULT_AGENT_IMAGE, readDockerCases, readDockerHosts, toSessionDocker, } from '../../docker-hosts.js';
+import { checkRemoteTmuxAvailable, readRemoteCases, readRemoteHosts, toAttachedSessionRemote, toSessionRemote, } from '../../remote-hosts.js';
+import { checkDockerAvailable, checkDockerConfigDrift, checkDockerTmuxAvailable, ensureAgentBaseImage, DEFAULT_AGENT_IMAGE, persistDockerCaseClaudeSessionId, readDockerCases, readDockerHosts, toSessionDocker, } from '../../docker-hosts.js';
 import { LRUMap } from '../../utils/lru-map.js';
 // Path to linked-cases registry (same file used by case-routes resolveCasePath)
 const LINKED_CASES_FILE = dataPath('linked-cases.json');
@@ -244,6 +245,16 @@ export function registerSessionRoutes(app, ctx) {
             return list;
         return list.filter((s) => canAccessOwned(user, s.owner));
     });
+    // ========== Session Tab Order (global sync, COD-131) ==========
+    app.put('/api/session-order', async (req) => {
+        const { order } = parseBody(SessionOrderUpdateSchema, req.body, 'Invalid session order');
+        // Server is authoritative but never drops ids it knows about that the
+        // pushing device hadn't loaded yet — those fall to the end (mergeSessionOrder).
+        const merged = mergeSessionOrder(order, ctx.store.getSessionOrder());
+        ctx.store.setSessionOrder(merged);
+        ctx.broadcast(SseEvent.SessionOrderChanged, { order: merged });
+        return { success: true, data: { order: merged } };
+    });
     // ========== Session Creation ==========
     app.post('/api/sessions', async (req) => {
         const owner = ownerFor(req);
@@ -252,7 +263,21 @@ export function registerSessionRoutes(app, ctx) {
         if (capMsg)
             return createErrorResponse(ApiErrorCode.OPERATION_FAILED, capMsg);
         const body = parseBody(CreateSessionSchema, req.body);
-        const workingDir = body.workingDir || process.cwd();
+        let workingDir = body.workingDir || process.cwd();
+        let remote = undefined;
+        // COD-105 — attach to a discovered (non-owned) remote tmux session. The
+        // remote session is already running, so we skip the tmux-prereq probe and
+        // build a NON-owned SessionRemote (detach-not-kill on close). Remote CASE
+        // creation (owned durable sessions) is handled by the dedicated case-create
+        // endpoint below, which #145 consolidated remote-host resolution into.
+        if (body.attachRemoteSession) {
+            const { hostId, remoteSessionName } = body.attachRemoteSession;
+            const host = (await readRemoteHosts(CODEMAN_CONFIG_DIR)).find((item) => item.id === hostId);
+            if (!host)
+                return createErrorResponse(ApiErrorCode.NOT_FOUND, 'Remote host not found');
+            workingDir = `${host.username}@${host.host}:${remoteSessionName}`;
+            remote = toAttachedSessionRemote(host, remoteSessionName, workingDir);
+        }
         // Multi-user: shell mode is arbitrary command execution as the host account,
         // gated behind the same grant as bypass (section 6.3). Resolve the owner's grant
         // from the store so a GRANTED regular user is not wrongly denied (AuthUser role alone can't tell).
@@ -407,6 +432,7 @@ export function registerSessionRoutes(app, ctx) {
             envOverrides: body.envOverrides,
             effort: body.effort,
             tmuxHistoryLimit: terminalHistoryConfig.tmuxHistoryLimit,
+            remote,
             owner,
         });
         ctx.addSession(session);
@@ -821,6 +847,10 @@ export function registerSessionRoutes(app, ctx) {
         const activeId = await resolveActiveClaudeSessionIdFromHistory(session, projectsDir);
         if (activeId && activeId !== session.claudeSessionId) {
             session.adoptClaudeSessionId(activeId);
+            // Docker sessions: keep the case's resume seed following the live conversation.
+            if (session.docker) {
+                void persistDockerCaseClaudeSessionId(CODEMAN_CONFIG_DIR, session.docker.containerName, activeId).catch(() => { });
+            }
         }
         // The Claude conversation ID (used as JSONL filename)
         const claudeSessionId = session.claudeSessionId || session.id;
@@ -1399,6 +1429,45 @@ export function registerSessionRoutes(app, ctx) {
             },
         };
     });
+    // ========== Pin (float to top of the session manager list, COD-139) ==========
+    app.post('/api/sessions/:id/pin', async (req) => {
+        const { id } = req.params;
+        const body = parseBody(PinSessionSchema, req.body, 'Invalid request body');
+        const session = ctx.sessions.get(id);
+        if (session) {
+            if (!canAccessOwned(getAuthUser(req), session.owner)) {
+                return createErrorResponse(ApiErrorCode.NOT_FOUND, `Session ${id} not found`);
+            }
+            session.setPinned(body.pinned);
+            // Persist + broadcast session:updated (keeps tabs/state consistent), then a
+            // dedicated session:pinned event so the session manager list re-sorts live.
+            persistAndBroadcastSession(ctx, session);
+            ctx.broadcast(SseEvent.SessionPinned, {
+                id,
+                pinned: session.pinned,
+                pinnedAt: session.pinnedAt ?? undefined,
+            });
+            return {
+                success: true,
+                data: {
+                    pinned: session.pinned,
+                    pinnedAt: session.pinnedAt ?? undefined,
+                },
+            };
+        }
+        // COD-142 keeps a pinned session's record after kill (demoteOrRemoveSession),
+        // so pin toggles must also work WITHOUT a live Session — otherwise a
+        // pinned-then-killed record could never be unpinned (cleanup skips pinned
+        // records, and the record has no live session to route through).
+        const persisted = ctx.store.getSession(id);
+        if (!persisted || !canAccessOwned(getAuthUser(req), persisted.owner)) {
+            return createErrorResponse(ApiErrorCode.NOT_FOUND, `Session ${id} not found`);
+        }
+        const pinnedAt = body.pinned ? Date.now() : undefined;
+        ctx.store.setSession(id, { ...persisted, pinned: body.pinned || undefined, pinnedAt });
+        ctx.broadcast(SseEvent.SessionPinned, { id, pinned: body.pinned, pinnedAt });
+        return { success: true, data: { pinned: body.pinned, pinnedAt } };
+    });
     // ========== Image Watcher ==========
     app.post('/api/sessions/:id/image-watcher', async (req) => {
         const { id } = req.params;
@@ -1505,7 +1574,7 @@ export function registerSessionRoutes(app, ctx) {
         const capMsg = sessionCapacityMessage(ctx.sessions, owner);
         if (capMsg)
             return createErrorResponse(ApiErrorCode.SESSION_BUSY, capMsg);
-        const { caseName = 'testcase', sessionName, mode = 'claude', openCodeConfig, codexConfig, geminiConfig, envOverrides, effort, } = parseBody(QuickStartSchema, req.body);
+        const { caseName = 'testcase', sessionName, mode = 'claude', modelOverride, openCodeConfig, codexConfig, geminiConfig, envOverrides, effort, } = parseBody(QuickStartSchema, req.body);
         // Multi-user: shell mode is arbitrary host-account execution, gated by the grant.
         // Resolve the owner's grant from the store so a GRANTED regular user is not wrongly denied.
         if (mode === 'shell' && !(await canUsernameRunPrivilegedCommands(owner))) {
@@ -1538,10 +1607,11 @@ export function registerSessionRoutes(app, ctx) {
             // remote command/env customization goes through the per-host command override.
             if ((envOverrides && Object.keys(envOverrides).length > 0) ||
                 effort ||
+                modelOverride !== undefined ||
                 codexConfig ||
                 geminiConfig ||
                 openCodeConfig) {
-                return createErrorResponse(ApiErrorCode.INVALID_INPUT, 'envOverrides, effort, and per-CLI config are not supported for remote cases (they do not cross ssh). Configure the remote command via the host command override instead.');
+                return createErrorResponse(ApiErrorCode.INVALID_INPUT, 'envOverrides, effort, modelOverride, and per-CLI config are not supported for remote cases (they do not cross ssh). Configure the remote command via the host command override instead.');
             }
             // tmux is a hard prerequisite on the remote host (the agent runs inside a remote
             // tmux server so it survives ssh drops). Probe before spawning so a missing tmux
@@ -1576,7 +1646,7 @@ export function registerSessionRoutes(app, ctx) {
             // Ensure the base image exists, auto-building the default image on first use so
             // it is never a blocker. Dedup'd with any build kicked off at case-create, so
             // this awaits the SAME in-flight build rather than starting a second one.
-            const ensured = await ensureAgentBaseImage(sessionDocker.engine, sessionDocker.image, {
+            const ensured = await ensureAgentBaseImage(sessionDocker, sessionDocker.image, {
                 onProgress: (line) => ctx.broadcast(SseEvent.DockerImageBuildProgress, { name: dockerCase.name, line }),
             });
             if (!ensured.ok) {
@@ -1594,6 +1664,15 @@ export function registerSessionRoutes(app, ctx) {
                     return createErrorResponse(ApiErrorCode.OPERATION_FAILED, tmuxCheck.error || 'base image is missing tmux');
                 }
             }
+            // Config drift (docs/docker-cases-plan.md §4): the desired create-config no
+            // longer matches the existing container's codeman.confighash label. Refuse to
+            // silently launch into the stale container — the frontend confirms a recreate
+            // (POST /api/docker-cases/:name/recreate; workspace + transcripts ride bind
+            // mounts and the conversation resumes), or the user reverts the host edit.
+            const drift = await checkDockerConfigDrift(sessionDocker);
+            if (drift.exists && drift.drifted) {
+                return createErrorResponse(ApiErrorCode.CONFLICT, `Container config for case "${dockerCase.name}" changed since the container was created. Recreate the container to apply it (workspace and conversation survive), or revert the docker host edit.`);
+            }
             casePath = dockerCase.hostWorkspacePath; // a REAL host dir (bind-mounted into the container)
             docker = sessionDocker;
             // Seed resume so a relaunch resumes the case's last conversation from the
@@ -1704,6 +1783,12 @@ export function registerSessionRoutes(app, ctx) {
                 /* non-fatal — the session still runs, hooks may be degraded */
             }
         }
+        // Model override → <case>/.claude/settings.local.json (claude-mode; local AND
+        // docker — the docker workspace is a real host dir, so the settings file crosses
+        // the bind mount and the in-container claude reads it). Remote was rejected above.
+        if (mode === 'claude' && modelOverride !== undefined) {
+            await updateCaseModel(resolvedCasePath, modelOverride || null);
+        }
         // Strip stale disk entries for keys this request is actively setting (Claude only —
         // see POST /api/sessions for full rationale).
         if (mode !== 'opencode' &&
@@ -1797,6 +1882,14 @@ export function registerSessionRoutes(app, ctx) {
                 ctx.broadcast(SseEvent.SessionInteractive, { id: session.id, mode });
             }
             ctx.broadcast(SseEvent.SessionUpdated, { session: ctx.getSessionStateWithRespawn(session) });
+            // Docker + claude: the pane command pins the conversation id (--session-id /
+            // --resume, claudeDockerPaneCommand), so persist it as the case's resume seed
+            // NOW — a later container stop/reboot relaunch resumes this conversation even
+            // if no in-container hook ever reaches the host (loopback bind, no bridge
+            // listener). Hook/last-response adoption updates it again after /clear.
+            if (docker && mode === 'claude') {
+                void persistDockerCaseClaudeSessionId(CODEMAN_CONFIG_DIR, docker.containerName, session.claudeSessionId || session.id).catch(() => { });
+            }
             // Save lastUsedCase to settings for TUI/web sync
             try {
                 const settingsFilePath = SETTINGS_PATH;
@@ -1891,6 +1984,63 @@ export function registerSessionRoutes(app, ctx) {
         }
         return undefined;
     }
+    /**
+     * Extract the text of the LAST user message from a JSONL transcript chunk
+     * (COD-145). Mirrors `extractFirstUserPrompt` exactly — same user-message
+     * detection, same noise/secret/slash-command filters, same 120-char cap — but
+     * keeps the last qualifying match instead of returning on the first. Scan the
+     * file tail for this (the most recent prompt lives near the end).
+     */
+    function extractLastUserPrompt(text) {
+        const MAX_PROMPT_LEN = 120;
+        let result;
+        let start = 0;
+        while (start < text.length) {
+            const end = text.indexOf('\n', start);
+            const line = end === -1 ? text.slice(start) : text.slice(start, end);
+            start = end === -1 ? text.length : end + 1;
+            if (!line.includes('"type":"user"'))
+                continue;
+            try {
+                const entry = JSON.parse(line);
+                if (entry.type !== 'user' || !entry.message)
+                    continue;
+                const content = entry.message.content;
+                let msgText;
+                if (typeof content === 'string') {
+                    msgText = content;
+                }
+                else if (Array.isArray(content)) {
+                    const textBlock = content.find((b) => b.type === 'text');
+                    if (textBlock)
+                        msgText = textBlock.text;
+                }
+                if (!msgText)
+                    continue;
+                msgText = msgText
+                    .replace(/<[^>]+>/g, '')
+                    .replace(new RegExp(String.raw `\x1b\[[0-9;]*[a-zA-Z]`, 'g'), '')
+                    .trim()
+                    .replace(/\s+/g, ' ');
+                if (!msgText)
+                    continue;
+                if (/^(Caveat:|init\b|clear\b|resume\b|\/[a-z][\w-]*\b|You are a |\[Request |Set model to )/i.test(msgText) ||
+                    /^(Please )?(analyze|review) this codebase/i.test(msgText) ||
+                    /^(Read|Implement the following) .+, then (search|list|check) /i.test(msgText) ||
+                    /^\d+ vulnerabilit/i.test(msgText) ||
+                    /\btoolu_/.test(msgText) ||
+                    /^[A-Za-z0-9_-]{20,}\.[A-Za-z0-9_-]+/.test(msgText) ||
+                    /\b(sk-ant-|ANTHROPIC_API_KEY|API_KEY=|SECRET|TOKEN=)/i.test(msgText) ||
+                    msgText.length < 8)
+                    continue;
+                result = msgText.length > MAX_PROMPT_LEN ? msgText.slice(0, MAX_PROMPT_LEN) + '…' : msgText;
+            }
+            catch {
+                // Malformed line — skip
+            }
+        }
+        return result;
+    }
     /**
      * Decode a Claude project key (e.g. "-Users-teigen-Documents-Workspace-AI-project-Mirror")
      * back to a filesystem path ("/Users/teigen/Documents/Workspace/AI_project/Mirror").
@@ -2068,6 +2218,15 @@ export function registerSessionRoutes(app, ctx) {
                 if (tail)
                     firstPrompt = extractFirstUserPrompt(tail);
             }
+            // COD-145: last (most recent) user prompt lives near the END of the file, so
+            // prefer the tail. For large files where no tail was read yet, read one
+            // (mirrors the firstPrompt > 65536 block). Small files fit in `head`, which
+            // then contains the whole transcript — scan it for the last match instead.
+            if (!tail && fileStat.size > 65536) {
+                const tailBuf = Buffer.alloc(32768);
+                tail = await readFileTail(filePath, tailBuf, fileStat.size);
+            }
+            const lastPrompt = (tail ? extractLastUserPrompt(tail) : undefined) ?? (head ? extractLastUserPrompt(head) : undefined);
             out.push({
                 sessionId,
                 workingDir,
@@ -2075,6 +2234,7 @@ export function registerSessionRoutes(app, ctx) {
                 sizeBytes: fileStat.size,
                 lastModified: fileStat.mtime.toISOString(),
                 firstPrompt,
+                lastPrompt,
             });
         }
         return out;
@@ -2146,6 +2306,8 @@ export function registerSessionRoutes(app, ctx) {
                 createdAt: st.createdAt,
                 lastActivityAt: st.lastActivityAt,
                 claudeSessionId: s.claudeSessionId ?? undefined,
+                pinned: st.pinned,
+                pinnedAt: st.pinnedAt,
             };
         });
         // Persisted sessions (state.json). resumeSessionId is the Claude
@@ -2160,6 +2322,8 @@ export function registerSessionRoutes(app, ctx) {
             createdAt: p.createdAt,
             lastActivityAt: p.lastActivityAt,
             claudeSessionId: p.resumeSessionId,
+            pinned: p.pinned,
+            pinnedAt: p.pinnedAt,
         }));
         // Lifecycle audit log (newest-first, capped).
         let lifecycle = [];
@@ -2192,6 +2356,7 @@ export function registerSessionRoutes(app, ctx) {
                         sizeBytes: h.sizeBytes,
                         lastModified: h.lastModified,
                         firstPrompt: h.firstPrompt,
+                        lastPrompt: h.lastPrompt,
                         projectKey: h.projectKey,
                     });
                 }