@lelouchhe/webagent 0.8.0 → 0.9.0

package/lib/files/limits.js

@@ -0,0 +1,15 @@
+/**
+ * File viewer size limits.
+ *
+ * Kept as plain exported constants for now so the routes have a single,
+ * testable knob; wiring these into `[limits]` config is a later milestone.
+ * Values stay in the same order of magnitude as attachment limits and keep
+ * rendered previews bounded. Files outside preview limits stream as downloads
+ * instead of being buffered in server or browser memory.
+ */
+/** Directory listings cap — beyond this the response is truncated + flagged. */
+export const MAX_LIST_ITEMS = 2000;
+/** Text/Markdown/code preview + highlight cap; larger files download. */
+export const MAX_TEXT_PREVIEW_BYTES = 1024 * 1024; // 1 MiB
+/** Image render cap — larger images stream as downloads. */
+export const MAX_IMAGE_BYTES = 20 * 1024 * 1024; // 20 MB

package/lib/files/paths.js

@@ -0,0 +1,155 @@
+/**
+ * Path resolution and directory listing helpers for the file viewer.
+ *
+ * Contract (confirmed design): the viewer accepts *absolute* paths or `~`
+ * prefixes only — relative paths are rejected outright so there is no base
+ * ambiguity to exploit. `~` expands to HOME, then `realpath` canonicalizes
+ * symlinks and `..` segments once; every path on the system is legal by
+ * design (single-owner personal tool), so there is deliberately no escape
+ * rejection logic — the guards here prevent blocking on special files,
+ * unbounded directory scans, and whole-file buffering.
+ */
+import { constants } from "node:fs";
+import { open, opendir, realpath, stat, } from "node:fs/promises";
+import { homedir } from "node:os";
+import { isAbsolute, join, basename } from "node:path";
+import { expandHomePath } from "../home-path.js";
+import { MAX_LIST_ITEMS } from "./limits.js";
+/** HTTP status-backed error; routes map it to a JSON error response. */
+export class FilePathError extends Error {
+    status;
+    constructor(status, message) {
+        super(message);
+        this.status = status;
+    }
+}
+/**
+ * Expand a user-supplied path string into an absolute path.
+ * Accepts `/absolute/path` and `~/...` / `~`. Everything else (including
+ * `~user` and bare relative paths) is rejected with 400.
+ */
+export function expandPath(raw, home = homedir()) {
+    if (raw.length === 0)
+        throw new FilePathError(400, "Missing path");
+    if (raw.includes("\0"))
+        throw new FilePathError(400, "Invalid path");
+    const expanded = expandHomePath(raw, home);
+    if (raw.startsWith("~") && expanded === raw) {
+        throw new FilePathError(400, "Unsupported ~user expansion");
+    }
+    if (!isAbsolute(expanded)) {
+        throw new FilePathError(400, "Path must be absolute or start with ~");
+    }
+    return expanded;
+}
+/** realpath canonicalization; missing paths map to 404. */
+export async function canonicalize(target) {
+    try {
+        return await realpath(target);
+    }
+    catch (err) {
+        if (err.code === "ENOENT") {
+            throw new FilePathError(404, "Path does not exist");
+        }
+        throw err;
+    }
+}
+/** stat a canonical path; non-regular files (fifo/socket/device) → 400. */
+export async function statMeta(path) {
+    const s = await stat(path);
+    let kind;
+    if (s.isFile())
+        kind = "file";
+    else if (s.isDirectory())
+        kind = "dir";
+    else
+        throw new FilePathError(400, "Not a regular file or directory");
+    return {
+        path,
+        name: basename(path),
+        kind,
+        size: s.size,
+        mtime: s.mtimeMs,
+    };
+}
+/**
+ * List one directory: scan at most MAX_LIST_ITEMS plus one sentinel raw entry,
+ * omit dotfiles/special nodes, then sort the bounded result dirs-first and
+ * lexicographically. Entries that vanish mid-list are skipped.
+ */
+export async function listDirectory(target) {
+    const dir = await opendir(target);
+    const entries = [];
+    let scanned = 0;
+    let truncated = false;
+    // Dir's async iterator closes the descriptor both at EOF and on break.
+    for await (const entry of dir) {
+        scanned++;
+        // Read one sentinel beyond the cap so `truncated` is authoritative,
+        // but never materialize/sort an unbounded directory.
+        if (scanned > MAX_LIST_ITEMS) {
+            truncated = true;
+            break;
+        }
+        if (entry.name.startsWith("."))
+            continue;
+        try {
+            const s = await stat(join(target, entry.name));
+            // Only expose targets the viewer can actually open. Symlinks to
+            // regular files/dirs pass because stat follows them; fifos, sockets,
+            // and devices are omitted rather than mislabelled as files.
+            if (!s.isDirectory() && !s.isFile())
+                continue;
+            entries.push({
+                name: entry.name,
+                kind: s.isDirectory() ? "dir" : "file",
+                size: s.isFile() ? s.size : null,
+                mtime: s.mtimeMs,
+            });
+        }
+        catch {
+            // Raced deletion — skip rather than fail the whole listing.
+        }
+    }
+    entries.sort(compareEntries);
+    return { entries, truncated };
+}
+function compareEntries(a, b) {
+    if (a.kind !== b.kind)
+        return a.kind === "dir" ? -1 : 1;
+    return a.name < b.name ? -1 : a.name > b.name ? 1 : 0;
+}
+/** Read up to `n` bytes from the head of a regular file (mime sniffing). */
+export async function readHead(file, n = 4096) {
+    const h = await open(file, "r");
+    try {
+        const st = await h.stat();
+        const len = Math.min(st.size, n);
+        const buf = Buffer.alloc(len);
+        if (len > 0)
+            await h.read(buf, 0, len, 0);
+        return buf;
+    }
+    finally {
+        await h.close();
+    }
+}
+/**
+ * Open without following a final symlink and without blocking on a FIFO.
+ * Windows lacks equivalent POSIX flags; fstat below remains authoritative.
+ */
+export function openForStreaming(file) {
+    const safeFlags = process.platform === "win32"
+        ? constants.O_RDONLY
+        : constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK;
+    return open(file, safeFlags);
+}
+/** Read mime-sniff bytes from an already validated descriptor. */
+export async function readHandleHead(handle, size, n = 4096) {
+    const len = Math.min(size, n);
+    const buf = Buffer.alloc(len);
+    if (len === 0)
+        return buf;
+    const { bytesRead } = await handle.read(buf, 0, len, 0);
+    return buf.subarray(0, bytesRead);
+}

package/lib/files/routes.js

@@ -0,0 +1,232 @@
+/**
+ * File viewer HTTP routes — read-only access to arbitrary local files.
+ *
+ * URL space claimed: `/api/v1/files/{info,list,content}`.
+ * Sessionless by design (confirmed): the caller passes an absolute or
+ * `~`-prefixed path; the server own `~` expansion + realpath canonicalization.
+ * Relative paths are rejected. Bearer auth is enforced by the shared
+ * `/api/**` gate in routes.ts — these paths are deliberately NOT in the
+ * public whitelist, with one exception: `content` IS whitelisted so
+ * `<img>` / `<a download>` can fetch without an Authorization header, and
+ * it instead requires an HMAC sig+exp signed URL (issued by `info`),
+ * mirroring the attachment scheme.
+ *
+ * Guards (see paths.ts + limits.ts): only regular files/dirs are served
+ * (no fifos/sockets/devices), directory scans and inline previews are bounded,
+ * downloads stream with backpressure, and responses carry nosniff + a
+ * restrictive CSP. The viewer renders text/markdown/image only — nothing here
+ * executes content.
+ */
+import { basename, dirname } from "node:path";
+import { pipeline } from "node:stream/promises";
+import { signAttachmentUrl, verifyAttachmentSig } from "../auth.js";
+import { buildContentDisposition, sniffMime } from "../attachments.js";
+import { HTTP_STATUS } from "../http-status.js";
+import { abbreviateHomePath } from "../home-path.js";
+import { log } from "../log.js";
+import { MAX_IMAGE_BYTES, MAX_TEXT_PREVIEW_BYTES } from "./limits.js";
+import { canonicalize, expandPath, FilePathError, listDirectory, openForStreaming, readHandleHead, readHead, statMeta, } from "./paths.js";
+const flog = log.scope("files");
+const CONTENT_TTL_SECONDS = 3600; // signed URLs live 1h, like attachments
+const SNIFF_BYTES = 4096;
+function fileSystemError(err) {
+    const code = err?.code;
+    if (code === "EACCES" || code === "EPERM") {
+        return new FilePathError(HTTP_STATUS.FORBIDDEN, "Permission denied");
+    }
+    if (code === "ENOENT" || code === "ENOTDIR") {
+        return new FilePathError(HTTP_STATUS.NOT_FOUND, "Path does not exist");
+    }
+    if (code === "ELOOP" ||
+        code === "EINVAL" ||
+        code === "ENAMETOOLONG" ||
+        code === "ERR_INVALID_ARG_VALUE") {
+        return new FilePathError(HTTP_STATUS.BAD_REQUEST, "Invalid path");
+    }
+    return null;
+}
+function json(res, status, body) {
+    res.writeHead(status, {
+        "Content-Type": "application/json",
+        "Cache-Control": "no-store",
+    });
+    res.end(JSON.stringify(body));
+}
+function previewLimitFor(mime) {
+    const m = mime.toLowerCase();
+    if (m.startsWith("image/"))
+        return MAX_IMAGE_BYTES;
+    if (m.startsWith("text/"))
+        return MAX_TEXT_PREVIEW_BYTES;
+    return null;
+}
+/** Expand + canonicalize a caller-supplied path; 400 on empty/relative. */
+async function resolvePath(raw) {
+    if (!raw)
+        throw new FilePathError(400, "Missing path");
+    return canonicalize(expandPath(raw));
+}
+function contentBasePath(pathRaw) {
+    return `/api/v1/files/content?path=${encodeURIComponent(pathRaw)}`;
+}
+async function streamHandle(res, handle, size) {
+    const stream = handle.createReadStream({
+        autoClose: false,
+        start: 0,
+        ...(size > 0 ? { end: size - 1 } : {}),
+    });
+    try {
+        await pipeline(stream, res);
+    }
+    catch (err) {
+        // Headers are already committed. A client disconnect or disk read error
+        // must terminate the stream, never fall through to a second JSON response.
+        if (!res.destroyed) {
+            res.destroy(err instanceof Error ? err : undefined);
+        }
+    }
+}
+export async function handleFileRoutes(req, res, deps) {
+    const url = req.url ?? "/";
+    if (!url.startsWith("/api/v1/files"))
+        return false;
+    const m = url.match(/^\/api\/v1\/files\/(info|list|content)(?:\?(.*))?$/);
+    if (!m)
+        return false;
+    const method = req.method ?? "GET";
+    if (method !== "GET") {
+        res.setHeader("Allow", "GET");
+        json(res, HTTP_STATUS.METHOD_NOT_ALLOWED, {
+            error: "Read-only: GET only",
+        });
+        return true;
+    }
+    try {
+        const params = new URLSearchParams(m[2]);
+        const pathRaw = params.get("path") ?? "";
+        switch (m[1]) {
+            case "info":
+                await handleInfo(res, deps, pathRaw);
+                return true;
+            case "list":
+                await handleList(res, pathRaw);
+                return true;
+            case "content":
+                await handleContent(res, deps, pathRaw, params);
+                return true;
+        }
+    }
+    catch (err) {
+        if (err instanceof FilePathError) {
+            json(res, err.status, { error: err.message });
+            return true;
+        }
+        const fsError = fileSystemError(err);
+        if (fsError) {
+            json(res, fsError.status, { error: fsError.message });
+            return true;
+        }
+        flog.error("file route failed", { url, error: String(err) });
+        json(res, HTTP_STATUS.INTERNAL_SERVER_ERROR, { error: "internal_error" });
+        return true;
+    }
+    return false;
+}
+async function handleInfo(res, deps, pathRaw) {
+    const canonical = await resolvePath(pathRaw);
+    const meta = await statMeta(canonical);
+    const out = {
+        path: meta.path,
+        pathDisplay: abbreviateHomePath(meta.path),
+        name: meta.name,
+        kind: meta.kind,
+        size: meta.size,
+        mtime: meta.mtime,
+    };
+    if (meta.kind === "file") {
+        const mime = await sniffMime(await readHead(canonical, SNIFF_BYTES));
+        const previewLimit = previewLimitFor(mime);
+        out.mime = mime;
+        if (previewLimit !== null)
+            out.maxBytes = previewLimit;
+        if (deps.secret) {
+            const basePath = contentBasePath(canonical);
+            out.contentUrl = `${basePath}&${signAttachmentUrl(basePath, deps.secret, CONTENT_TTL_SECONDS)}`;
+        }
+    }
+    json(res, HTTP_STATUS.OK, out);
+}
+async function handleList(res, pathRaw) {
+    const canonical = await resolvePath(pathRaw);
+    const meta = await statMeta(canonical);
+    if (meta.kind !== "dir") {
+        throw new FilePathError(HTTP_STATUS.BAD_REQUEST, "Not a directory");
+    }
+    const { entries, truncated } = await listDirectory(canonical);
+    const parent = dirname(canonical);
+    json(res, HTTP_STATUS.OK, {
+        path: canonical,
+        pathDisplay: abbreviateHomePath(canonical),
+        parent,
+        parentDisplay: abbreviateHomePath(parent),
+        truncated,
+        entries,
+    });
+}
+async function handleContent(res, deps, pathRaw, params) {
+    const basePath = contentBasePath(pathRaw);
+    const sig = params.get("sig") ?? "";
+    const exp = params.get("exp") ?? "";
+    // content is whitelisted in auth-middleware.ts (media tags / downloads
+    // cannot send Authorization headers), so it must verify its own URL.
+    // Unlike the older attachment route, this new security-sensitive route
+    // fails closed when no signing secret is wired.
+    if (!deps.secret) {
+        json(res, HTTP_STATUS.SERVICE_UNAVAILABLE, {
+            error: "file_content_signing_unavailable",
+        });
+        return;
+    }
+    if (!sig || !exp || !verifyAttachmentSig(basePath, exp, sig, deps.secret)) {
+        res.writeHead(HTTP_STATUS.UNAUTHORIZED, {
+            "Content-Type": "application/json",
+        });
+        res.end(JSON.stringify({ error: "Unauthorized" }));
+        return;
+    }
+    const canonical = await resolvePath(pathRaw);
+    // `info` signs the realpath-canonical string. If that path now resolves to
+    // another target (for example it was replaced by a symlink), the old
+    // capability must not silently acquire authority over the new target.
+    if (canonical !== pathRaw) {
+        json(res, HTTP_STATUS.UNAUTHORIZED, { error: "Unauthorized" });
+        return;
+    }
+    const handle = await openForStreaming(canonical);
+    try {
+        const stats = await handle.stat();
+        if (!stats.isFile()) {
+            throw new FilePathError(HTTP_STATUS.BAD_REQUEST, "Not a regular file");
+        }
+        const mime = await sniffMime(await readHandleHead(handle, stats.size, SNIFF_BYTES));
+        const previewLimit = previewLimitFor(mime);
+        const disposition = previewLimit !== null && stats.size <= previewLimit
+            ? "inline"
+            : "attachment";
+        res.writeHead(HTTP_STATUS.OK, {
+            "Content-Type": mime,
+            "X-Content-Type-Options": "nosniff",
+            // Ordinary project files change in place; never let reopening show a
+            // cached pre-edit body under the same path-bound signed URL.
+            "Cache-Control": "no-store",
+            // Belt-and-braces: even if a mime mis-sniff ever lets a browser
+            // interpret this body as HTML, it can't load any subresource.
+            "Content-Security-Policy": "default-src 'none'",
+            "Content-Disposition": buildContentDisposition(disposition, basename(canonical)),
+        });
+        await streamHandle(res, handle, stats.size);
+    }
+    finally {
+        await handle.close().catch(() => { });
+    }
+}

package/lib/home-path.js

@@ -0,0 +1,35 @@
+import { homedir } from "node:os";
+import { isAbsolute, join, relative, sep } from "node:path";
+const NATIVE_PATH = { isAbsolute, join, relative, sep };
+function portableDisplayPath(input, path) {
+    return path.sep === "\\" ? input.replace(/\\/g, "/") : input;
+}
+/**
+ * Expand the current user's HOME shorthand with one authoritative grammar.
+ * Both `~/` and `~\` are accepted; named-user forms stay untouched.
+ */
+export function expandHomePath(input, home = homedir(), path = NATIVE_PATH) {
+    if (input === "~")
+        return home;
+    if (input.startsWith("~/") || input.startsWith("~\\")) {
+        const tail = input.slice(2).replace(/[\\/]/g, path.sep);
+        return path.join(home, tail);
+    }
+    return input;
+}
+/**
+ * Abbreviate HOME and normalize Windows display paths to portable `/`
+ * separators. Canonical filesystem paths remain native and are stored/signed
+ * separately; this function is exclusively for UI round-tripping.
+ */
+export function abbreviateHomePath(input, home = homedir(), path = NATIVE_PATH) {
+    const relativePath = path.relative(home, input);
+    if (relativePath === "")
+        return "~";
+    if (relativePath === ".." ||
+        relativePath.startsWith(`..${path.sep}`) ||
+        path.isAbsolute(relativePath)) {
+        return portableDisplayPath(input, path);
+    }
+    return `~/${portableDisplayPath(relativePath, path)}`;
+}

package/lib/http-status.js

@@ -7,6 +7,7 @@ export const HTTP_STATUS = Object.freeze({
     UNAUTHORIZED: 401,
     FORBIDDEN: 403,
     NOT_FOUND: 404,
+    METHOD_NOT_ALLOWED: 405,
     CONFLICT: 409,
     GONE: 410,
     PAYLOAD_TOO_LARGE: 413,

package/lib/routes.js

@@ -8,9 +8,11 @@ import { interruptBashProc, InvalidSessionDirectoryError, } from "./session-mana
 import { randomUUID } from "node:crypto";
 import { createWriteStream } from "node:fs";
 import { handleShareRoutes } from "./share/routes.js";
+import { handleFileRoutes } from "./files/routes.js";
 import { authenticate, isWhitelistedPath } from "./auth-middleware.js";
 import { enrichStoredEventsForDisplay } from "./attachment-labels.js";
 import { agentCommandToken, resolveAgentCommand } from "./agent-commands.js";
+import { abbreviateHomePath } from "./home-path.js";
 import { log } from "./log.js";
 const rlog = log.scope("routes");
 const plog = rlog.scope("prompt");
@@ -403,6 +405,7 @@ async function handleAttachmentUpload(req, res, sessionId, deps) {
 }
 export function createRequestHandler(deps) {
     const { store, sessions, getBridge, sseManager, titleService } = deps;
+    let bootstrapSessionPromise = null;
     // eslint-disable-next-line complexity -- TODO: refactor main route handler into smaller handlers
     return async (req, res) => {
         const url = req.url ?? "/";
@@ -440,6 +443,14 @@ export function createRequestHandler(deps) {
             }))) {
             return;
         }
+        // File viewer — sessionless read-only access to arbitrary local paths.
+        // Claims /api/v1/files/{info,list,content} before the generic /api/v1
+        // branch. info/list use the Bearer gate above; content is whitelisted
+        // only because its handler requires an HMAC-signed URL for headerless
+        // media/download fetches (see src/files/routes.ts).
+        if (await handleFileRoutes(req, res, { secret: deps.attachmentSecret })) {
+            return;
+        }
         // --- API routes ---
         if (url === "/api/v1" || url.startsWith("/api/v1/")) {
             res.setHeader("Content-Type", "application/json");
@@ -450,6 +461,7 @@ export function createRequestHandler(deps) {
                     endpoints: {
                         sessions: "/api/v1/sessions",
                         paths: "/api/v1/recent-paths",
+                        files: "/api/v1/files",
                         config: "/api/v1/config",
                         events_stream: "/api/v1/events/stream",
                         prompt: "/api/beta/prompt",
@@ -487,7 +499,10 @@ export function createRequestHandler(deps) {
                     limit: isNaN(limit) ? 0 : limit,
                     ttlDays,
                 });
-                json(res, HTTP_STATUS.OK, paths);
+                json(res, HTTP_STATUS.OK, paths.map((entry) => ({
+                    ...entry,
+                    cwdDisplay: abbreviateHomePath(entry.cwd),
+                })));
                 return;
             }
             // GET /api/v1/version
@@ -888,6 +903,7 @@ export function createRequestHandler(deps) {
                         id: session.id,
                         title: session.title,
                         cwd: session.cwd,
+                        cwdDisplay: abbreviateHomePath(session.cwd),
                         model: session.model,
                         mode: session.mode,
                         createdAt: session.created_at,
@@ -1149,6 +1165,11 @@ export function createRequestHandler(deps) {
                         },
                     ];
                 });
+                // A background task can trigger unsolicited Main-agent output after
+                // the foreground ACP prompt has ended. Its chunks remain buffered
+                // until a real protocol boundary arrives; seal them before this user
+                // row so they cannot merge into the next turn's assistant response.
+                sessions.flushBuffers(sessionId);
                 const eventClientOpId = opId ?? randomUUID();
                 store.saveEvent(sessionId, "user_message", {
                     text: body.text,
@@ -1429,6 +1450,76 @@ export function createRequestHandler(deps) {
                 json(res, HTTP_STATUS.OK, { title: body.value });
                 return;
             }
+            // POST /api/v1/sessions/bootstrap — atomically return the current
+            // agent's latest session, creating one only when none exists.
+            if (url === "/api/v1/sessions/bootstrap" && req.method === "POST") {
+                const bridge = getBridge?.();
+                if (!bridge) {
+                    json(res, HTTP_STATUS.SERVICE_UNAVAILABLE, {
+                        error: "Agent not ready yet",
+                    });
+                    return;
+                }
+                if (!sessions) {
+                    json(res, HTTP_STATUS.SERVICE_UNAVAILABLE, {
+                        error: "Session manager not available",
+                    });
+                    return;
+                }
+                const sessionManager = sessions;
+                bootstrapSessionPromise ??= (async () => {
+                    const existing = store.listSessions().at(0);
+                    if (existing) {
+                        return {
+                            id: existing.id,
+                            cwd: existing.cwd,
+                            cwdDisplay: abbreviateHomePath(existing.cwd),
+                            title: existing.title,
+                            source: existing.source,
+                            configOptions: [],
+                            agentCommands: sessionManager.getAgentCommands(existing.id),
+                            created: false,
+                        };
+                    }
+                    const { sessionId, configOptions } = await sessionManager.createSession(bridge);
+                    const session = store.getSession(sessionId);
+                    const result = {
+                        id: sessionId,
+                        cwd: session?.cwd ?? deps.dataDir,
+                        cwdDisplay: abbreviateHomePath(session?.cwd ?? deps.dataDir),
+                        title: session?.title ?? null,
+                        source: session?.source ?? "auto",
+                        configOptions,
+                        agentCommands: sessionManager.getAgentCommands(sessionId),
+                        created: true,
+                    };
+                    sseManager.broadcast({
+                        type: "session_created",
+                        sessionId,
+                        cwd: result.cwd,
+                        cwdDisplay: result.cwdDisplay,
+                        title: result.title,
+                        configOptions,
+                        agentCommands: result.agentCommands,
+                    });
+                    return result;
+                })().finally(() => {
+                    bootstrapSessionPromise = null;
+                });
+                try {
+                    const result = await bootstrapSessionPromise;
+                    json(res, HTTP_STATUS.OK, {
+                        ...result,
+                        clientOpId: getClientOpId(req) ?? undefined,
+                    });
+                }
+                catch (err) {
+                    json(res, HTTP_STATUS.INTERNAL_SERVER_ERROR, {
+                        error: err instanceof Error ? err.message : String(err),
+                    });
+                }
+                return;
+            }
             // --- Session CRUD: /api/v1/sessions/:id ---
             const sessionIdMatch = url.match(/^\/api\/v1\/sessions\/([^/?]+)\/?(\?.*)?$/);
             if (sessionIdMatch) {
@@ -1479,33 +1570,12 @@ export function createRequestHandler(deps) {
                                 });
                             })
                                 .catch(() => { });
-                            // Auto-retry if the last turn was interrupted (must wait for resume)
-                            const hasInterrupted = store.hasInterruptedTurn(sessionId);
-                            if (hasInterrupted) {
-                                // Optimistically mark busy so concurrent POST sees the session as active
-                                sessions.activePrompts.add(sessionId);
-                                sessions.syncBusy(sessionId);
-                                void resumePromise
-                                    .then(() => {
-                                    if (!sessions.autoRetryIfNeeded(bridge, sessionId)) {
-                                        // Retry not needed after all — release the optimistic lock
-                                        sessions.activePrompts.delete(sessionId);
-                                        sessions.syncBusy(sessionId);
-                                    }
-                                })
-                                    .catch(() => {
-                                    sessions.activePrompts.delete(sessionId);
-                                    sessions.syncBusy(sessionId);
-                                });
-                            }
-                            else {
-                                resumePromise.catch((err) => {
-                                    slog.error("background resume failed", {
-                                        sessionId: sessionId.slice(0, 8) + "…",
-                                        error: err,
-                                    });
+                            resumePromise.catch((err) => {
+                                slog.error("background resume failed", {
+                                    sessionId: sessionId.slice(0, 8) + "…",
+                                    error: err,
                                 });
-                            }
+                            });
                         }
                     }
                     // If cache is cold and we kicked off a resume, wait briefly so the
@@ -1547,6 +1617,7 @@ export function createRequestHandler(deps) {
                     json(res, HTTP_STATUS.OK, {
                         id: freshSession.id,
                         cwd: freshSession.cwd,
+                        cwdDisplay: abbreviateHomePath(freshSession.cwd),
                         title: freshSession.title,
                         source: freshSession.source,
                         model: freshSession.model,
@@ -1612,6 +1683,9 @@ export function createRequestHandler(deps) {
                         type: "session_created",
                         sessionId,
                         cwd: session?.cwd,
+                        cwdDisplay: session?.cwd
+                            ? abbreviateHomePath(session.cwd)
+                            : undefined,
                         title: session?.title,
                         configOptions,
                         agentCommands: sessions.getAgentCommands(sessionId),
@@ -1630,6 +1704,9 @@ export function createRequestHandler(deps) {
                     json(res, HTTP_STATUS.CREATED, {
                         id: sessionId,
                         cwd: session?.cwd ?? body.cwd,
+                        cwdDisplay: session?.cwd
+                            ? abbreviateHomePath(session.cwd)
+                            : undefined,
                         title: session?.title ?? null,
                         source: session?.source ?? source,
                         configOptions,
@@ -2185,8 +2262,20 @@ export function createRequestHandler(deps) {
                     return;
                 }
                 const cwd = typeof body.cwd === "string" ? body.cwd : undefined;
-                const { sessionId } = await sessions.createSession(bridge, cwd, undefined, "auto");
+                const { sessionId, configOptions } = await sessions.createSession(bridge, cwd, undefined, "auto");
                 const streamUrl = `/api/v1/sessions/${sessionId}/events/stream`;
+                const session = store.getSession(sessionId);
+                sseManager.broadcast({
+                    type: "session_created",
+                    sessionId,
+                    cwd: session?.cwd,
+                    cwdDisplay: session?.cwd
+                        ? abbreviateHomePath(session.cwd)
+                        : undefined,
+                    title: session?.title,
+                    configOptions,
+                    agentCommands: sessions.getAgentCommands(sessionId),
+                });
                 json(res, HTTP_STATUS.ACCEPTED, { sessionId, streamUrl });
                 // Fire-and-forget: send the prompt asynchronously, tracking busy state
                 sessions.activePrompts.add(sessionId);