@lelouchhe/webagent 0.8.0 → 0.9.0

package/lib/server.js

@@ -5,6 +5,7 @@ import { fileURLToPath } from "node:url";
 import { loadConfig } from "./config.js";
 import { setLogLevel, log } from "./log.js";
 import { AgentBridge } from "./bridge.js";
+import { agentKeyFromCommand } from "./agent-key.js";
 import { Store } from "./store.js";
 import { SessionManager } from "./session-manager.js";
 import { TitleService } from "./title-service.js";
@@ -53,7 +54,7 @@ const PKG_VERSION = (() => {
     }
 })();
 // --- Core dependencies ---
-const store = new Store(config.data_dir);
+const store = new Store(config.data_dir, agentKeyFromCommand(preflight.agentCmd));
 console.log(`[store] using ${config.data_dir}/`);
 // Pin <data_dir>/sessions realpath at boot so all later anchor checks
 // (file:// URI construction, permission interceptor) compare against the
@@ -109,28 +110,29 @@ const messageCleanup = startMessageCleanup(store, config.messages.unprocessed_tt
 });
 let sharePreviewCleanup = null;
 // --- HTTP server ---
+const requestHandler = createRequestHandler({
+    store,
+    sessions,
+    sseManager,
+    clientRegistry,
+    titleService,
+    getBridge: () => bridge,
+    publicDir: PUBLIC_DIR,
+    dataDir: config.data_dir,
+    limits: config.limits,
+    pushService,
+    serverVersion: PKG_VERSION,
+    debugLevel: config.debug.level,
+    authStore,
+    ticketStore,
+    attachmentSecret,
+    shareConfig: config.share,
+});
 const server = createServer((req, res) => {
-    void createRequestHandler({
-        store,
-        sessions,
-        sseManager,
-        clientRegistry,
-        titleService,
-        getBridge: () => bridge,
-        publicDir: PUBLIC_DIR,
-        dataDir: config.data_dir,
-        limits: config.limits,
-        pushService,
-        serverVersion: PKG_VERSION,
-        debugLevel: config.debug.level,
-        authStore,
-        ticketStore,
-        attachmentSecret,
-        shareConfig: config.share,
-    })(req, res);
+    void requestHandler(req, res);
 });
 async function initBridge(agentCmd) {
-    const b = new AgentBridge(agentCmd);
+    const b = new AgentBridge(agentCmd, store);
     b.setAttachmentDispatcher(attachmentDispatcher);
     const eventHandlerConfig = _buildBridgeEventHandlerConfig({
         cancelTimeout: config.limits.cancel_timeout,

package/lib/session-manager.js

@@ -6,6 +6,7 @@ import { join } from "node:path";
 import { MessageNotFoundError } from "./store.js";
 import { SessionStateManager } from "./session-state.js";
 import { buildLabelMap } from "./attachment-labels.js";
+import { abbreviateHomePath, expandHomePath } from "./home-path.js";
 import { log } from "./log.js";
 const slog = log.scope("session");
 const IS_WIN = process.platform === "win32";
@@ -89,7 +90,7 @@ export class SessionManager {
     }
     /** Create a new session in both bridge and store, inheriting the source session's config. */
     async createSession(bridge, cwd, inheritFromSessionId, source = "auto", opts) {
-        const sessionCwd = cwd ?? this.defaultCwd;
+        const sessionCwd = expandHomePath(cwd ?? this.defaultCwd);
         try {
             const info = await stat(sessionCwd);
             if (!info.isDirectory())
@@ -109,37 +110,47 @@ export class SessionManager {
         const sourceSession = inheritFromSessionId
             ? this.store.getSession(inheritFromSessionId)
             : null;
-        const { sessionId, configOptions: createdConfigOptions } = await bridge.newSession(sessionCwd, { silent: opts?.silent });
+        const webSessionId = randomUUID();
+        const { sessionId: agentSessionId, configOptions: createdConfigOptions } = await bridge.newSession(sessionCwd, { silent: opts?.silent });
         let configOptions = createdConfigOptions;
         try {
-            this.store.createSession(sessionId, sessionCwd, source);
+            this.store.createSession(webSessionId, sessionCwd, source, agentSessionId);
         }
         catch (err) {
             slog.warn("ACP session created but local persistence failed", {
-                sessionId,
+                agentSessionId,
                 error: err,
             });
+            bridge.discardUnboundSession?.(agentSessionId);
             throw err;
         }
-        this.liveSessions.add(sessionId);
-        this.recordConfigOptions(sessionId, createdConfigOptions);
+        this.liveSessions.add(webSessionId);
+        this.recordConfigOptions(webSessionId, createdConfigOptions);
+        bridge.sessionMapped?.(agentSessionId);
         // Inherit config options from source session
         if (sourceSession) {
+            const thinkingOption = createdConfigOptions.find((option) => "options" in option &&
+                (option.id === "reasoning_effort" ||
+                    option.id === "thought_level" ||
+                    option.category === "thought_level"));
             const inherited = [
                 { configId: "model", value: sourceSession.model },
-                { configId: "reasoning_effort", value: sourceSession.reasoning_effort },
+                {
+                    configId: thinkingOption?.id ?? "reasoning_effort",
+                    value: sourceSession.reasoning_effort,
+                },
             ];
             for (const { configId, value } of inherited) {
                 if (!value)
                     continue;
                 try {
-                    const updatedConfigOptions = await bridge.setConfigOption(sessionId, configId, value);
+                    const updatedConfigOptions = await bridge.setConfigOption(webSessionId, configId, value);
                     if (updatedConfigOptions.length > 0) {
                         configOptions = updatedConfigOptions;
-                        this.recordConfigOptions(sessionId, updatedConfigOptions);
+                        this.recordConfigOptions(webSessionId, updatedConfigOptions);
                     }
                     else {
-                        this.store.updateSessionConfig(sessionId, configId, value);
+                        this.store.updateSessionConfig(webSessionId, configId, value);
                     }
                 }
                 catch {
@@ -147,9 +158,9 @@ export class SessionManager {
                 }
             }
         }
-        const session = this.store.getSession(sessionId);
+        const session = this.store.getSession(webSessionId);
         return {
-            sessionId,
+            sessionId: webSessionId,
             configOptions: session
                 ? this.applyStoredConfig(configOptions, session)
                 : [],
@@ -229,6 +240,7 @@ export class SessionManager {
                 type: "session_created",
                 sessionId,
                 cwd: session.cwd,
+                cwdDisplay: abbreviateHomePath(session.cwd),
                 title: session.title,
                 configOptions,
             };
@@ -252,6 +264,7 @@ export class SessionManager {
                 type: "session_created",
                 sessionId,
                 cwd: session.cwd,
+                cwdDisplay: abbreviateHomePath(session.cwd),
                 title: session.title,
                 configOptions,
             };
@@ -272,33 +285,42 @@ export class SessionManager {
      * DB row — setConfigOption's currentValue for unrelated keys is the
      * agent's in-memory default, not the user's preference.
      *
-     * Key priority mode > reasoning_effort > model:
+     * Key priority mode > thinking aliases > model:
      *   - mode is a small stable enum, rewriting current value is idempotent.
+     *   - ACP agents use both reasoning_effort and thought_level for thinking.
      *   - model has the highest schema-drift risk (agent upgrades drop values).
      */
     async tryWarmCache(bridge, sessionId, session) {
         if (this.cachedConfigOptions.length > 0)
             return;
-        const pick = session.mode
-            ? { id: "mode", value: session.mode }
-            : session.reasoning_effort
-                ? { id: "reasoning_effort", value: session.reasoning_effort }
-                : session.model
-                    ? { id: "model", value: session.model }
-                    : null;
-        if (!pick)
+        const candidates = [];
+        if (session.mode)
+            candidates.push({ id: "mode", value: session.mode });
+        if (session.reasoning_effort) {
+            candidates.push({ id: "reasoning_effort", value: session.reasoning_effort }, { id: "thought_level", value: session.reasoning_effort });
+        }
+        if (session.model)
+            candidates.push({ id: "model", value: session.model });
+        if (candidates.length === 0)
             return;
-        try {
-            const opts = await bridge.setConfigOption(sessionId, pick.id, pick.value);
-            if (opts.length > 0) {
-                this.cachedConfigOptions = opts;
-                slog.info("warmed cache on resume", { options: opts.length });
+        let lastError = null;
+        for (const candidate of candidates) {
+            try {
+                const opts = await bridge.setConfigOption(sessionId, candidate.id, candidate.value);
+                if (opts.length > 0) {
+                    this.cachedConfigOptions = opts;
+                    slog.info("warmed cache on resume", { options: opts.length });
+                    return;
+                }
+            }
+            catch (err) {
+                lastError = err;
             }
         }
-        catch (err) {
+        if (lastError) {
             slog.warn("cache warming failed", {
                 sessionId: sessionId.slice(0, 8) + "…",
-                error: err,
+                error: lastError,
             });
         }
     }
@@ -331,9 +353,12 @@ export class SessionManager {
             model: session.model,
             mode: session.mode,
             reasoning_effort: session.reasoning_effort,
+            thought_level: session.reasoning_effort,
         };
         return configOptions.map((opt) => {
-            const override = stored[opt.id];
+            const override = opt.category === "thought_level"
+                ? session.reasoning_effort
+                : stored[opt.id];
             if (override && "options" in opt)
                 return { ...opt, currentValue: override };
             return opt;

package/lib/session-state.js

@@ -17,6 +17,7 @@ function defaultState() {
             pendingPermissions: [],
             streaming: { assistant: false, thinking: false },
             plan: null,
+            contextUsage: null,
         },
     };
 }
@@ -56,6 +57,14 @@ function plansEqual(a, b) {
         return false;
     return a.every((entry, index) => entry.status === b[index].status && entry.content === b[index].content);
 }
+function contextUsageEqual(a, b) {
+    if (a === null || b === null)
+        return a === b;
+    return (a.used === b.used &&
+        a.size === b.size &&
+        (a.cost?.amount ?? null) === (b.cost?.amount ?? null) &&
+        (a.cost?.currency ?? null) === (b.cost?.currency ?? null));
+}
 /** True when the patch would change the current runtime state. */
 function hasRuntimeChanges(current, patch) {
     if (!patch)
@@ -68,6 +77,9 @@ function hasRuntimeChanges(current, patch) {
         return true;
     if ("plan" in patch && !plansEqual(current.plan, patch.plan ?? null))
         return true;
+    if ("contextUsage" in patch &&
+        !contextUsageEqual(current.contextUsage, patch.contextUsage ?? null))
+        return true;
     if ("streaming" in patch && patch.streaming) {
         const s = patch.streaming;
         if (s.assistant !== undefined &&
@@ -119,6 +131,15 @@ export class SessionStateManager {
                 state.runtime.plan =
                     patch.runtime.plan?.map((entry) => ({ ...entry })) ?? null;
             }
+            if ("contextUsage" in patch.runtime) {
+                const usage = patch.runtime.contextUsage;
+                state.runtime.contextUsage = usage
+                    ? {
+                        ...usage,
+                        ...(usage.cost ? { cost: { ...usage.cost } } : {}),
+                    }
+                    : null;
+            }
             if ("streaming" in patch.runtime && patch.runtime.streaming) {
                 if (patch.runtime.streaming.assistant !== undefined) {
                     state.runtime.streaming.assistant = patch.runtime.streaming.assistant;
@@ -162,6 +183,14 @@ export class SessionStateManager {
             }
         }
     }
+    /** Clear context usage for every known session on bridge teardown. */
+    clearContextUsage() {
+        for (const [sessionId, state] of this.states) {
+            if (state.runtime.contextUsage !== null) {
+                this.patch(sessionId, { runtime: { contextUsage: null } });
+            }
+        }
+    }
     /** Clear active stream markers for every known session on bridge teardown. */
     clearStreaming() {
         for (const [sessionId, state] of this.states) {

package/lib/share/routes.js

@@ -444,6 +444,10 @@ async function handlePublish(req, res, deps, sessionId) {
         json(res, HTTP_STATUS.BAD_REQUEST, { error: "token required" });
         return;
     }
+    if (!deps.store.ownsSession(sessionId)) {
+        json(res, HTTP_STATUS.NOT_FOUND, { error: "share not found" });
+        return;
+    }
     const row = deps.store.getShareByToken(body.token);
     if (!row) {
         json(res, HTTP_STATUS.NOT_FOUND, { error: "share not found" });
@@ -849,6 +853,10 @@ async function handleRevoke(req, res, deps, sessionId) {
         json(res, HTTP_STATUS.BAD_REQUEST, { error: "token required" });
         return;
     }
+    if (!deps.store.ownsSession(sessionId)) {
+        json(res, HTTP_STATUS.NOT_FOUND, { error: "share not found" });
+        return;
+    }
     const row = deps.store.getShareByToken(body.token);
     if (!row) {
         // Idempotent DELETE: row already gone (revoked or never existed).
@@ -910,6 +918,10 @@ async function handlePatchLabel(req, res, deps, sessionId) {
         json(res, HTTP_STATUS.BAD_REQUEST, { error: "token required" });
         return;
     }
+    if (!deps.store.ownsSession(sessionId)) {
+        json(res, HTTP_STATUS.NOT_FOUND, { error: "share not found" });
+        return;
+    }
     const row = deps.store.getShareByToken(body.token);
     if (!row) {
         json(res, HTTP_STATUS.NOT_FOUND, { error: "share not found" });

package/lib/store.js

@@ -9,7 +9,11 @@ export class MessageNotFoundError extends Error {
 }
 export class Store {
     db;
-    constructor(dataDir) {
+    agentKey;
+    constructor(dataDir, agentKey) {
+        if (!agentKey)
+            throw new Error("agentKey is required");
+        this.agentKey = agentKey;
         mkdirSync(dataDir, { recursive: true });
         this.db = new Database(join(dataDir, "webagent.db"));
         this.db.pragma("journal_mode = WAL");
@@ -27,6 +31,16 @@ export class Store {
         created_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%d %H:%M:%f', 'now')),
         last_active_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%d %H:%M:%f', 'now'))
       );
+      CREATE TABLE IF NOT EXISTS agent_sessions (
+        agent_key TEXT NOT NULL,
+        agent_session_id TEXT NOT NULL,
+        web_session_id TEXT REFERENCES sessions(id) ON DELETE CASCADE,
+        created_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%d %H:%M:%f', 'now')),
+        PRIMARY KEY (agent_key, agent_session_id)
+      );
+      CREATE UNIQUE INDEX IF NOT EXISTS idx_agent_sessions_web
+        ON agent_sessions(web_session_id)
+        WHERE web_session_id IS NOT NULL;
       CREATE TABLE IF NOT EXISTS events (
         id INTEGER PRIMARY KEY AUTOINCREMENT,
         session_id TEXT NOT NULL REFERENCES sessions(id),
@@ -70,6 +84,21 @@ export class Store {
         if (!colNames.has("deleted_at")) {
             this.db.exec("ALTER TABLE sessions ADD COLUMN deleted_at INTEGER");
         }
+        // One-time dual-ID migration. Existing WebAgent session IDs were also the
+        // ACP agent's IDs, so preserve the public IDs and record that identity
+        // mapping under the agent command active during the upgrade.
+        this.db
+            .prepare(`
+        INSERT INTO agent_sessions (
+          agent_key, agent_session_id, web_session_id, created_at
+        )
+        SELECT ?, s.id, s.id, s.created_at
+        FROM sessions s
+        WHERE NOT EXISTS (
+          SELECT 1 FROM agent_sessions a WHERE a.web_session_id = s.id
+        )
+      `)
+            .run(this.agentKey);
         // messages — pending unbound notifications. POST /api/v1/messages with
         // `to = "user"` lands here; consumeMessageTx transactionally moves the
         // content into an existing ACP-backed session's events and deletes the
@@ -247,29 +276,72 @@ export class Store {
       );
     `);
     }
-    createSession(id, cwd, source = "auto") {
-        this.db
-            .prepare("INSERT INTO sessions (id, cwd, source) VALUES (?, ?, ?)")
-            .run(id, cwd, source);
-        return this.db
-            .prepare("SELECT * FROM sessions WHERE id = ?")
-            .get(id);
+    createSession(id, cwd, source = "auto", agentSessionId = id) {
+        return this.db.transaction(() => {
+            this.db
+                .prepare("INSERT INTO sessions (id, cwd, source) VALUES (?, ?, ?)")
+                .run(id, cwd, source);
+            this.db
+                .prepare("INSERT INTO agent_sessions (agent_key, agent_session_id, web_session_id) VALUES (?, ?, ?)")
+                .run(this.agentKey, agentSessionId, id);
+            return this.db
+                .prepare("SELECT * FROM sessions WHERE id = ?")
+                .get(id);
+        })();
     }
     listSessions(opts) {
         if (opts?.source) {
             return this.db
-                .prepare("SELECT * FROM sessions WHERE source = ? AND deleted_at IS NULL ORDER BY COALESCE(last_active_at, created_at) DESC")
-                .all(opts.source);
+                .prepare(`SELECT s.* FROM sessions s
+           JOIN agent_sessions a ON a.web_session_id = s.id
+           WHERE a.agent_key = ? AND s.source = ? AND s.deleted_at IS NULL
+           ORDER BY COALESCE(s.last_active_at, s.created_at) DESC`)
+                .all(this.agentKey, opts.source);
         }
         return this.db
-            .prepare("SELECT * FROM sessions WHERE deleted_at IS NULL ORDER BY COALESCE(last_active_at, created_at) DESC")
-            .all();
+            .prepare(`SELECT s.* FROM sessions s
+         JOIN agent_sessions a ON a.web_session_id = s.id
+         WHERE a.agent_key = ? AND s.deleted_at IS NULL
+         ORDER BY COALESCE(s.last_active_at, s.created_at) DESC`)
+            .all(this.agentKey);
     }
     /** Returns live sessions only. Soft-deleted (tombstone) rows are hidden. */
     getSession(id) {
         return this.db
-            .prepare("SELECT * FROM sessions WHERE id = ? AND deleted_at IS NULL")
-            .get(id);
+            .prepare(`SELECT s.* FROM sessions s
+         JOIN agent_sessions a ON a.web_session_id = s.id
+         WHERE s.id = ? AND a.agent_key = ? AND s.deleted_at IS NULL`)
+            .get(id, this.agentKey);
+    }
+    registerInternalAgentSession(agentSessionId) {
+        this.db
+            .prepare("INSERT OR IGNORE INTO agent_sessions (agent_key, agent_session_id, web_session_id) VALUES (?, ?, NULL)")
+            .run(this.agentKey, agentSessionId);
+        const row = this.db
+            .prepare("SELECT * FROM agent_sessions WHERE agent_key = ? AND agent_session_id = ?")
+            .get(this.agentKey, agentSessionId);
+        if (row.web_session_id) {
+            throw new Error("Agent reused a user-visible session ID internally");
+        }
+        return row;
+    }
+    getAgentSessionId(webSessionId) {
+        return this.db
+            .prepare("SELECT agent_session_id FROM agent_sessions WHERE agent_key = ? AND web_session_id = ?")
+            .get(this.agentKey, webSessionId)?.agent_session_id;
+    }
+    getWebSessionId(agentSessionId) {
+        return this.db
+            .prepare("SELECT web_session_id FROM agent_sessions WHERE agent_key = ? AND agent_session_id = ? AND web_session_id IS NOT NULL")
+            .get(this.agentKey, agentSessionId)?.web_session_id;
+    }
+    getAgentSessionBinding(webSessionId) {
+        return this.db
+            .prepare("SELECT * FROM agent_sessions WHERE agent_key = ? AND web_session_id = ?")
+            .get(this.agentKey, webSessionId);
+    }
+    ownsSession(webSessionId) {
+        return this.getAgentSessionBinding(webSessionId) !== undefined;
     }
     /**
      * Returns a session row even if soft-deleted. Used by the public share
@@ -339,11 +411,14 @@ export class Store {
         const empties = this.db
             .prepare(`
       SELECT s.id FROM sessions s
+      JOIN agent_sessions a ON a.web_session_id = s.id
       LEFT JOIN events e ON e.session_id = s.id
       WHERE e.id IS NULL
+        AND a.agent_key = ?
+        AND s.deleted_at IS NULL
         AND strftime('%s', 'now') - strftime('%s', s.created_at) >= ?
     `)
-            .all(minAgeS);
+            .all(this.agentKey, minAgeS);
         if (empties.length === 0)
             return [];
         const del = this.db.prepare("DELETE FROM sessions WHERE id = ?");
@@ -367,6 +442,7 @@ export class Store {
             model: "model",
             mode: "mode",
             reasoning_effort: "reasoning_effort",
+            thought_level: "reasoning_effort",
         }[configId];
         if (!column)
             return;
@@ -435,14 +511,17 @@ export class Store {
             .get(sessionId);
         return row.seq;
     }
-    /** Check if the most recent agent turn was interrupted (user_message without a following prompt_done). */
+    /** Check if the most recent agent turn lacks a completion or error terminal event. */
     hasInterruptedTurn(sessionId) {
         const row = this.db
             .prepare(`
       SELECT 1 FROM events
       WHERE session_id = ? AND type = 'user_message'
         AND seq > COALESCE(
-          (SELECT MAX(seq) FROM events WHERE session_id = ? AND type = 'prompt_done'),
+          (
+            SELECT MAX(seq) FROM events
+            WHERE session_id = ? AND type IN ('prompt_done', 'error')
+          ),
           0
         )
       LIMIT 1
@@ -771,9 +850,11 @@ export class Store {
          s.ttl_hours AS ttl_hours,
          s.last_accessed_at AS last_accessed_at
        FROM shares s
+       JOIN agent_sessions a ON a.web_session_id = s.session_id
        LEFT JOIN sessions sess ON sess.id = s.session_id
+       WHERE a.agent_key = ?
        ORDER BY s.created_at DESC`)
-            .all();
+            .all(this.agentKey);
     }
     /**
      * One-time write of last_accessed_at (share-plan §4.1 R2 ENG-6a +

package/lib/title-service.js

@@ -64,7 +64,7 @@ export class TitleService {
         this.cancelledSourceSessions.add(sessionId);
         if (!this.titleSessionId || !this.activeSourceSessions.has(sessionId))
             return;
-        await bridge.cancel(this.titleSessionId);
+        await bridge.cancelAgentSession(this.titleSessionId);
     }
     /** Clear the cached title session ID (e.g. after agent reload). */
     invalidate() {
@@ -76,14 +76,14 @@ export class TitleService {
             return this.titleSessionId;
         try {
             const { sessionId: id, configOptions } = await bridge.newSession(this.defaultCwd, { silent: true });
-            this.sessions.liveSessions.add(id);
+            this.store.registerInternalAgentSession(id);
             // Pick the cheapest available model by matching id substrings against
             // the agent's reported availableModels (`configOptions[id=model].options`).
             // Empty pattern list, no model option, or no match → skip the call and
             // inherit the agent's default model (`currentModelId`).
             const picked = pickModelByPatterns(configOptions, this.modelPatterns);
             if (picked) {
-                await bridge.setConfigOption(id, "model", picked).catch(() => []);
+                await bridge.setAgentConfigOption(id, "model", picked).catch(() => []);
             }
             this.titleSessionId = id;
             return id;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lelouchhe/webagent",
-  "version": "0.8.0",
+  "version": "0.9.0",
   "description": "A terminal-style web UI for ACP-compatible agents",
   "type": "module",
   "license": "MIT",
@@ -64,6 +64,7 @@
     "@types/web-push": "^3.6.4",
     "better-sqlite3": "^12.6.2",
     "busboy": "^1.6.0",
+    "diff": "^9.0.0",
     "dompurify": "^3.4.1",
     "file-type": "^22.0.1",
     "highlight.js": "^11.11.1",