pipane 0.1.5 → 0.1.7

package/dist/server/server/session-index.js

@@ -1,19 +1,32 @@
 import { existsSync, mkdirSync, readdirSync, readFileSync, renameSync, statSync, unlinkSync, writeFileSync, } from "node:fs";
 import path from "node:path";
-import { getAgentDir, parseSessionEntries } from "@mariozechner/pi-coding-agent";
+import { getAgentDir, parseSessionEntries } from "@earendil-works/pi-coding-agent";
+import { createWorktreeNameResolver, } from "./worktree-name.js";
 const CACHE_FORMAT_VERSION = 1;
-const DEFAULT_EXTRACTOR_VERSION = "2";
+const DEFAULT_EXTRACTOR_VERSION = "3";
+const MAX_RECENT_TOOL_PATHS = 16;
+const PATH_ACTIVITY_TOOLS = new Set([
+    "edit",
+    "hypa_find",
+    "hypa_grep",
+    "hypa_ls",
+    "hypa_read",
+    "read",
+    "write",
+]);
 export class SessionIndex {
     agentDir;
     extractorVersion;
     cacheFilePath;
     cwdDisplayFormatter;
+    worktreeNameResolver;
     inMemoryCache;
     constructor(opts) {
         this.agentDir = opts?.agentDir ?? getAgentDir();
         this.extractorVersion = opts?.extractorVersion ?? DEFAULT_EXTRACTOR_VERSION;
         this.cacheFilePath = path.join(this.agentDir, "cache", "pipane-session-index-v1.json");
         this.cwdDisplayFormatter = opts?.cwdDisplayFormatter;
+        this.worktreeNameResolver = opts?.worktreeNameResolver;
     }
     async listSessions() {
         const files = this.listSessionFiles();
@@ -38,17 +51,18 @@ export class SessionIndex {
                 sessions.push(cached.meta);
                 continue;
             }
-            const meta = this.extractSessionMeta(sessionPath, stat.mtimeMs);
-            if (!meta) {
+            const extracted = this.extractSessionMeta(sessionPath, stat.mtimeMs);
+            if (!extracted) {
                 mutated = true;
                 continue;
             }
             nextEntries[sessionPath] = {
                 fileMtimeMs: stat.mtimeMs,
                 fileSize: stat.size,
-                meta,
+                meta: extracted.meta,
+                recentToolPaths: extracted.recentToolPaths,
             };
-            sessions.push(meta);
+            sessions.push(extracted.meta);
             mutated = true;
         }
         if (!mutated) {
@@ -80,7 +94,20 @@ export class SessionIndex {
                 // on read-only agent dirs or transient filesystem errors.
             }
         }
-        return sessions;
+        // A default resolver is scoped to one listing: its filesystem lookups are
+        // shared by every session, but discarded before the next request so newly
+        // created or removed worktrees are reflected immediately.
+        const worktreeNameResolver = this.worktreeNameResolver ?? createWorktreeNameResolver();
+        return sessions.map((session) => {
+            let worktreeName = "root";
+            try {
+                worktreeName = worktreeNameResolver(session.cwd, nextEntries[session.path]?.recentToolPaths ?? []) || "root";
+            }
+            catch {
+                worktreeName = "root";
+            }
+            return { ...session, worktreeName };
+        });
     }
     async invalidateAll() {
         this.inMemoryCache = null;
@@ -125,11 +152,14 @@ export class SessionIndex {
             const header = entries[0];
             if (header?.type !== "session" || typeof header.id !== "string")
                 return null;
+            const cwd = typeof header.cwd === "string" ? header.cwd : "";
             let name;
             let messageCount = 0;
             let firstMessage = "";
             let lastActivityTime;
             let lastUserPromptTimeMs = 0;
+            const pendingToolPaths = new Map();
+            const recentToolPaths = [];
             for (const entry of entries) {
                 if (entry?.type === "session_info" && typeof entry.name === "string") {
                     const trimmed = entry.name.trim();
@@ -142,6 +172,19 @@ export class SessionIndex {
                 const msg = entry.message;
                 if (!msg || typeof msg.role !== "string" || !Object.prototype.hasOwnProperty.call(msg, "content"))
                     continue;
+                if (msg.role === "assistant") {
+                    this.rememberPendingToolPaths(msg.content, cwd, pendingToolPaths);
+                }
+                else if (msg.role === "toolResult" && typeof msg.toolCallId === "string") {
+                    const completedPaths = pendingToolPaths.get(msg.toolCallId);
+                    pendingToolPaths.delete(msg.toolCallId);
+                    if (msg.isError !== true && completedPaths) {
+                        recentToolPaths.push(...completedPaths);
+                        if (recentToolPaths.length > MAX_RECENT_TOOL_PATHS) {
+                            recentToolPaths.splice(0, recentToolPaths.length - MAX_RECENT_TOOL_PATHS);
+                        }
+                    }
+                }
                 if (msg.role !== "user" && msg.role !== "assistant")
                     continue;
                 const messageTs = typeof msg.timestamp === "number" ? msg.timestamp : undefined;
@@ -170,24 +213,74 @@ export class SessionIndex {
                     return new Date(createdMs);
                 return new Date(statMtimeMs);
             })();
-            const cwd = typeof header.cwd === "string" ? header.cwd : "";
             return {
-                id: header.id,
-                path: sessionPath,
-                cwd,
-                cwdDisplay: cwd && this.cwdDisplayFormatter ? this.cwdDisplayFormatter(cwd) : cwd,
-                name,
-                created: created.toISOString(),
-                modified: modified.toISOString(),
-                lastUserPromptTime: lastUserPromptTimeMs > 0 ? new Date(lastUserPromptTimeMs).toISOString() : undefined,
-                messageCount,
-                firstMessage: firstMessage || "(no messages)",
+                meta: {
+                    id: header.id,
+                    path: sessionPath,
+                    cwd,
+                    cwdDisplay: cwd && this.cwdDisplayFormatter ? this.cwdDisplayFormatter(cwd) : cwd,
+                    name,
+                    created: created.toISOString(),
+                    modified: modified.toISOString(),
+                    lastUserPromptTime: lastUserPromptTimeMs > 0 ? new Date(lastUserPromptTimeMs).toISOString() : undefined,
+                    messageCount,
+                    firstMessage: firstMessage || "(no messages)",
+                },
+                recentToolPaths,
             };
         }
         catch {
             return null;
         }
     }
+    rememberPendingToolPaths(content, cwd, pendingToolPaths) {
+        if (!Array.isArray(content))
+            return;
+        for (const chunk of content) {
+            if (chunk?.type !== "toolCall" || typeof chunk.id !== "string")
+                continue;
+            pendingToolPaths.set(chunk.id, this.extractToolPaths(chunk.name, chunk.arguments, cwd));
+        }
+    }
+    extractToolPaths(toolName, rawArguments, cwd) {
+        if (typeof toolName !== "string")
+            return [];
+        const args = this.parseToolArguments(rawArguments);
+        if (!args)
+            return [];
+        if (Array.isArray(args.tool_uses)) {
+            return args.tool_uses.flatMap((toolUse) => this.extractToolPaths(toolUse?.recipient_name, toolUse?.parameters, cwd));
+        }
+        const shortName = toolName.toLowerCase().split(".").pop() ?? "";
+        if (!PATH_ACTIVITY_TOOLS.has(shortName))
+            return [];
+        const candidate = typeof args.path === "string"
+            ? args.path
+            : typeof args.file_path === "string"
+                ? args.file_path
+                : "";
+        if (!candidate || candidate.includes("\0"))
+            return [];
+        if (!path.isAbsolute(candidate) && !cwd)
+            return [];
+        return [path.resolve(cwd || path.parse(candidate).root, candidate)];
+    }
+    parseToolArguments(rawArguments) {
+        if (rawArguments && typeof rawArguments === "object" && !Array.isArray(rawArguments)) {
+            return rawArguments;
+        }
+        if (typeof rawArguments !== "string")
+            return null;
+        try {
+            const parsed = JSON.parse(rawArguments);
+            return parsed && typeof parsed === "object" && !Array.isArray(parsed)
+                ? parsed
+                : null;
+        }
+        catch {
+            return null;
+        }
+    }
     extractTextContent(content) {
         if (typeof content === "string")
             return content;

package/dist/server/server/session-jsonl.js

@@ -12,13 +12,38 @@
  * from jsonl-sync.ts.
  */
 import { existsSync, readFileSync, statSync } from "node:fs";
-import { parseSessionEntries, buildSessionContext, } from "@mariozechner/pi-coding-agent";
+import { buildContextEntries, buildSessionContext, parseSessionEntries, sessionEntryToContextMessages, } from "@earendil-works/pi-coding-agent";
 import { createHash } from "node:crypto";
 import { computeSyncOp } from "../shared/jsonl-sync.js";
 /** Synchronous SHA-256 hash (server-only, uses node:crypto). */
 function computeHashSync(data) {
     return createHash("sha256").update(data, "utf8").digest("hex");
 }
+function messageTimestamp(message) {
+    const timestamp = message.timestamp;
+    return typeof timestamp === "number" && Number.isFinite(timestamp) ? timestamp : undefined;
+}
+function inferToolCallTimings(messages) {
+    const timings = {};
+    for (const message of messages) {
+        if (message.role === "assistant") {
+            const startedAt = messageTimestamp(message);
+            if (startedAt === undefined)
+                continue;
+            for (const part of message.content) {
+                if (part.type === "toolCall")
+                    timings[part.id] ??= { startedAt };
+            }
+        }
+        else if (message.role === "toolResult") {
+            const completedAt = messageTimestamp(message);
+            const timing = timings[message.toolCallId];
+            if (timing && completedAt !== undefined)
+                timing.completedAt = completedAt;
+        }
+    }
+    return timings;
+}
 // ── SessionJsonl ───────────────────────────────────────────────────────────
 export class SessionJsonl {
     // ── Internal state (used to build the JSON) ────────────────────────────
@@ -26,6 +51,7 @@ export class SessionJsonl {
     _streamMessage = null;
     _pendingToolCalls = [];
     _partialToolResults = {};
+    _toolCallTimings;
     _model;
     _thinkingLevel;
     _steeringQueue = [];
@@ -37,6 +63,7 @@ export class SessionJsonl {
     _version = 1;
     constructor(init) {
         this._messages = init.messages;
+        this._toolCallTimings = init.toolCallTimings ?? inferToolCallTimings(init.messages);
         this._model = init.model;
         this._thinkingLevel = init.thinkingLevel;
         // Build initial JSON
@@ -52,8 +79,21 @@ export class SessionJsonl {
         this._steeringQueue = q;
         this.rebuildJson();
     }
-    // Expose model for ws-handler
+    // Expose controls for ws-handler reconciliation.
     get model() { return this._model; }
+    get thinkingLevel() { return this._thinkingLevel; }
+    /** Atomically replace the effective model/thinking state reported by pi. */
+    setControlState(model, thinkingLevel) {
+        const sameModel = this._model?.provider === model?.provider
+            && this._model?.modelId === model?.modelId;
+        if (sameModel && this._thinkingLevel === thinkingLevel)
+            return false;
+        this._model = model;
+        this._thinkingLevel = thinkingLevel;
+        this._version++;
+        this.rebuildJson();
+        return true;
+    }
     // Expose messages for post-detach snapshot
     get messages() { return this._messages; }
     /**
@@ -65,6 +105,11 @@ export class SessionJsonl {
         this._streamMessage = null;
         this._pendingToolCalls = [];
         this._partialToolResults = {};
+        const inferredTimings = inferToolCallTimings(messages);
+        this._toolCallTimings = Object.fromEntries(Object.keys(inferredTimings).map((id) => [
+            id,
+            { ...inferredTimings[id], ...this._toolCallTimings[id] },
+        ]));
         this._version++;
         this.rebuildJson();
     }
@@ -109,10 +154,23 @@ export class SessionJsonl {
                 }
                 return false;
             }
+            case "thinking_level_changed": {
+                const level = event.level ?? event.thinkingLevel;
+                if (typeof level !== "string" || level === this._thinkingLevel)
+                    return false;
+                this._thinkingLevel = level;
+                this._version++;
+                this.rebuildJson();
+                return true;
+            }
             case "tool_execution_start": {
                 const toolCallId = event.toolCallId;
                 if (toolCallId && !this._pendingToolCalls.includes(toolCallId)) {
                     this._pendingToolCalls = [...this._pendingToolCalls, toolCallId];
+                    this._toolCallTimings = {
+                        ...this._toolCallTimings,
+                        [toolCallId]: { startedAt: Date.now() },
+                    };
                     this._version++;
                     this.rebuildJson();
                     return true;
@@ -134,6 +192,13 @@ export class SessionJsonl {
                 const toolCallId = event.toolCallId;
                 if (toolCallId) {
                     this._pendingToolCalls = this._pendingToolCalls.filter(id => id !== toolCallId);
+                    const timing = this._toolCallTimings[toolCallId];
+                    if (timing && timing.completedAt === undefined) {
+                        this._toolCallTimings = {
+                            ...this._toolCallTimings,
+                            [toolCallId]: { ...timing, completedAt: Date.now() },
+                        };
+                    }
                     if (toolCallId in this._partialToolResults) {
                         const { [toolCallId]: _, ...rest } = this._partialToolResults;
                         this._partialToolResults = rest;
@@ -156,8 +221,11 @@ export class SessionJsonl {
      * @param clientVersion - The client's last known version
      * @returns SyncOp to send, or null if nothing changed
      */
-    computeSyncOp(clientJson, clientHash, clientVersion) {
-        if (this._version === clientVersion && clientHash === this._hash)
+    computeSyncOp(clientJson, clientHash, _clientVersion) {
+        // Some Pi lifecycle events advance the internal version without changing
+        // the serialized state. Do not emit a same-revision empty delta: wire
+        // revisions describe observable state changes, not internal event counts.
+        if (clientHash === this._hash)
             return null;
         return computeSyncOp(clientJson, this._json, clientHash, this._hash);
     }
@@ -194,6 +262,7 @@ export class SessionJsonl {
             messages,
             isStreaming: true,
             pendingToolCalls: this._pendingToolCalls,
+            toolCallTimings: this._toolCallTimings,
             model: this._model,
             thinkingLevel: this._thinkingLevel,
             steeringQueue: this._steeringQueue,
@@ -212,6 +281,49 @@ export class SessionJsonl {
     }
 }
 // ── Disk reader ────────────────────────────────────────────────────────────
+/**
+ * Build the messages in chronological display order.
+ *
+ * Pi's LLM context intentionally puts the latest compaction summary before the
+ * retained pre-compaction messages. In the conversation timeline, however, the
+ * compaction happened after those retained messages. Restoring append order
+ * keeps the completed marker where the user ran /compact while still omitting
+ * the older messages replaced by the summary.
+ */
+function buildSessionDisplayEntries(entries) {
+    const sessionEntries = entries.filter((entry) => entry.type !== "session");
+    const entryOrder = new Map(sessionEntries.map((entry, index) => [entry, index]));
+    return [...buildContextEntries(sessionEntries)]
+        .sort((left, right) => (entryOrder.get(left) ?? 0) - (entryOrder.get(right) ?? 0));
+}
+export function buildSessionDisplayMessages(entries) {
+    return buildSessionDisplayEntries(entries).flatMap(sessionEntryToContextMessages);
+}
+function buildSessionToolCallTimings(entries) {
+    const timings = {};
+    for (const entry of buildSessionDisplayEntries(entries)) {
+        if (entry.type !== "message")
+            continue;
+        const entryTimestamp = new Date(entry.timestamp).getTime();
+        const timestamp = Number.isFinite(entryTimestamp)
+            ? entryTimestamp
+            : messageTimestamp(entry.message);
+        if (timestamp === undefined)
+            continue;
+        if (entry.message.role === "assistant") {
+            for (const part of entry.message.content) {
+                if (part.type === "toolCall")
+                    timings[part.id] ??= { startedAt: timestamp };
+            }
+        }
+        else if (entry.message.role === "toolResult") {
+            const timing = timings[entry.message.toolCallId];
+            if (timing)
+                timing.completedAt = timestamp;
+        }
+    }
+    return timings;
+}
 /**
  * Read a session from disk and return a serialized SessionState JSON + hash.
  */
@@ -219,12 +331,15 @@ export function readSessionFromDisk(sessionPath) {
     let messages = [];
     let model = null;
     let thinkingLevel = "off";
+    let toolCallTimings = {};
     try {
         if (existsSync(sessionPath)) {
             const content = readFileSync(sessionPath, "utf8");
             const entries = parseSessionEntries(content);
-            const context = buildSessionContext(entries);
-            messages = context.messages ?? [];
+            const sessionEntries = entries.filter((entry) => entry.type !== "session");
+            const context = buildSessionContext(sessionEntries);
+            messages = buildSessionDisplayMessages(entries);
+            toolCallTimings = buildSessionToolCallTimings(entries);
             model = context.model ?? null;
             thinkingLevel = context.thinkingLevel ?? "off";
         }
@@ -236,14 +351,19 @@ export function readSessionFromDisk(sessionPath) {
         messages,
         isStreaming: false,
         pendingToolCalls: [],
+        toolCallTimings,
         model,
         thinkingLevel,
         steeringQueue: [],
     };
-    const json = JSON.stringify(state);
-    const hash = computeHashSync(json);
+    const { json, hash } = serializeSessionState(state);
     return { json, hash, state };
 }
+/** Serialize a canonical session state using the wire protocol's hash format. */
+export function serializeSessionState(state) {
+    const json = JSON.stringify(state);
+    return { json, hash: computeHashSync(json) };
+}
 /**
  * Get the file size of a session file. Returns 0 if the file doesn't exist.
  */

package/dist/server/server/session-path.js

@@ -0,0 +1,145 @@
+import { realpathSync, statSync } from "node:fs";
+import path from "node:path";
+import { getAgentDir } from "@earendil-works/pi-coding-agent";
+export class SessionPathError extends Error {
+    code;
+    constructor(message, code) {
+        super(message);
+        this.code = code;
+        this.name = "SessionPathError";
+    }
+}
+function isWithin(root, candidate) {
+    const relative = path.relative(root, candidate);
+    return relative !== ""
+        && relative !== ".."
+        && !relative.startsWith(`..${path.sep}`)
+        && !path.isAbsolute(relative);
+}
+function errorCode(error) {
+    return typeof error === "object" && error !== null && "code" in error
+        ? String(error.code)
+        : undefined;
+}
+/** Canonicalizes and confines all client-provided Pi session file paths. */
+export class SessionPathGuard {
+    configuredRoot;
+    constructor(sessionsRoot = path.join(getAgentDir(), "sessions")) {
+        this.configuredRoot = path.resolve(sessionsRoot);
+    }
+    resolveExisting(value) {
+        const candidate = this.resolveLexical(value);
+        const canonicalRoot = this.resolveRoot();
+        let canonicalCandidate;
+        try {
+            canonicalCandidate = realpathSync(candidate);
+        }
+        catch (error) {
+            if (errorCode(error) === "ENOENT" || errorCode(error) === "ENOTDIR") {
+                throw new SessionPathError("Session file not found", "not_found");
+            }
+            throw new SessionPathError("Invalid session path", "invalid");
+        }
+        if (path.extname(canonicalCandidate) !== ".jsonl" || !isWithin(canonicalRoot, canonicalCandidate)) {
+            throw new SessionPathError("Session path escapes the Pi sessions directory", "invalid");
+        }
+        try {
+            if (!statSync(canonicalCandidate).isFile()) {
+                throw new SessionPathError("Session path is not a file", "invalid");
+            }
+        }
+        catch (error) {
+            if (error instanceof SessionPathError)
+                throw error;
+            if (errorCode(error) === "ENOENT" || errorCode(error) === "ENOTDIR") {
+                throw new SessionPathError("Session file not found", "not_found");
+            }
+            throw new SessionPathError("Invalid session path", "invalid");
+        }
+        return canonicalCandidate;
+    }
+    /**
+     * Canonicalizes a path allocated by Pi before Pi has flushed the new file.
+     * Its existing parent is still resolved so a symlinked directory cannot escape.
+     */
+    resolvePending(value) {
+        const candidate = this.resolveLexical(value);
+        try {
+            return this.resolveExisting(candidate);
+        }
+        catch (error) {
+            if (!(error instanceof SessionPathError) || error.code !== "not_found")
+                throw error;
+        }
+        const canonicalRoot = this.resolveRoot();
+        let canonicalParent;
+        try {
+            canonicalParent = realpathSync(path.dirname(candidate));
+        }
+        catch {
+            throw new SessionPathError("Session parent directory not found", "not_found");
+        }
+        if (canonicalParent !== canonicalRoot && !isWithin(canonicalRoot, canonicalParent)) {
+            throw new SessionPathError("Session path escapes the Pi sessions directory", "invalid");
+        }
+        try {
+            if (!statSync(canonicalParent).isDirectory()) {
+                throw new SessionPathError("Invalid session parent directory", "invalid");
+            }
+        }
+        catch (error) {
+            if (error instanceof SessionPathError)
+                throw error;
+            throw new SessionPathError("Invalid session parent directory", "invalid");
+        }
+        return path.join(canonicalParent, path.basename(candidate));
+    }
+    /** Returns a confined, canonical destination for a server-generated filename. */
+    createPath(filename) {
+        if (!filename || path.basename(filename) !== filename || path.extname(filename) !== ".jsonl") {
+            throw new SessionPathError("Invalid generated session filename", "invalid");
+        }
+        const canonicalRoot = this.resolveRoot();
+        const candidate = path.join(canonicalRoot, filename);
+        if (!isWithin(canonicalRoot, candidate)) {
+            throw new SessionPathError("Generated session path escapes the Pi sessions directory", "invalid");
+        }
+        return candidate;
+    }
+    resolveLexical(value) {
+        if (typeof value !== "string" || !value || value.includes("\0")) {
+            throw new SessionPathError("Missing or invalid session path", "invalid");
+        }
+        if (!path.isAbsolute(value)) {
+            throw new SessionPathError("Session path must be absolute", "invalid");
+        }
+        const candidate = path.resolve(value);
+        if (path.extname(candidate) !== ".jsonl" || !isWithin(this.configuredRoot, candidate)) {
+            throw new SessionPathError("Session path must be a .jsonl file within the Pi sessions directory", "invalid");
+        }
+        return candidate;
+    }
+    resolveRoot() {
+        let canonicalRoot;
+        try {
+            canonicalRoot = realpathSync(this.configuredRoot);
+        }
+        catch (error) {
+            if (errorCode(error) === "ENOENT" || errorCode(error) === "ENOTDIR") {
+                throw new SessionPathError("Pi sessions directory not found", "not_found");
+            }
+            throw new SessionPathError("Invalid Pi sessions directory", "invalid");
+        }
+        try {
+            if (!statSync(canonicalRoot).isDirectory()) {
+                throw new SessionPathError("Invalid Pi sessions directory", "invalid");
+            }
+        }
+        catch (error) {
+            if (error instanceof SessionPathError)
+                throw error;
+            throw new SessionPathError("Invalid Pi sessions directory", "invalid");
+        }
+        return canonicalRoot;
+    }
+}

package/dist/server/server/session-registry.js

@@ -0,0 +1,67 @@
+import { SessionActor } from "./session-actor.js";
+/** Registry and process index for per-session actors. */
+export class SessionRegistry {
+    actors = new Map();
+    actorsByProcess = new Map();
+    statuses = new Map();
+    listeners = new Set();
+    get(sessionPath) {
+        let actor = this.actors.get(sessionPath);
+        if (!actor) {
+            actor = new SessionActor(sessionPath, (event) => this.handleActorEvent(actor, event));
+            this.actors.set(sessionPath, actor);
+        }
+        return actor;
+    }
+    find(sessionPath) {
+        return this.actors.get(sessionPath);
+    }
+    getActorForProcess(proc) {
+        return this.actorsByProcess.get(proc);
+    }
+    subscribe(listener) {
+        this.listeners.add(listener);
+        return () => this.listeners.delete(listener);
+    }
+    getAllStatuses() {
+        return Object.fromEntries(this.statuses);
+    }
+    getAllSteeringQueues() {
+        const queues = {};
+        for (const [sessionPath, actor] of this.actors) {
+            if (actor.steeringQueue.length > 0)
+                queues[sessionPath] = [...actor.steeringQueue];
+        }
+        return queues;
+    }
+    get attachedCount() {
+        return this.actorsByProcess.size;
+    }
+    handleActorEvent(actor, event) {
+        switch (event.type) {
+            case "attached":
+                this.actorsByProcess.set(event.proc, actor);
+                this.statuses.set(actor.sessionPath, "running");
+                this.emit({ type: "status_change", sessionPath: actor.sessionPath, status: "running" });
+                this.emit({ type: "session_attached", sessionPath: actor.sessionPath, procId: event.proc.id });
+                break;
+            case "detached":
+                if (this.actorsByProcess.get(event.proc) === actor)
+                    this.actorsByProcess.delete(event.proc);
+                this.statuses.set(actor.sessionPath, "done");
+                this.emit({ type: "status_change", sessionPath: actor.sessionPath, status: "done" });
+                this.emit({ type: "session_detached", sessionPath: actor.sessionPath, procId: event.proc.id });
+                break;
+            case "phase_change":
+                this.emit({ type: "phase_change", sessionPath: actor.sessionPath, phase: event.phase });
+                break;
+            case "steering_queue_update":
+                this.emit({ type: "steering_queue_update", sessionPath: actor.sessionPath, queue: event.queue });
+                break;
+        }
+    }
+    emit(event) {
+        for (const listener of this.listeners)
+            listener(event);
+    }
+}

package/dist/server/server/update-api.js

@@ -0,0 +1,28 @@
+import { isUpdateTarget } from "../shared/updates.js";
+export function registerUpdateApi(app, manager) {
+    app.get("/api/updates", async (_req, res) => {
+        try {
+            res.json(await manager.check());
+        }
+        catch (error) {
+            res.status(500).json({ error: error instanceof Error ? error.message : String(error) });
+        }
+    });
+    app.post("/api/updates/:target", async (req, res) => {
+        if (req.get("X-Pipane-Action") !== "update") {
+            res.status(400).json({ error: "Missing update action header." });
+            return;
+        }
+        if (!isUpdateTarget(req.params.target)) {
+            res.status(400).json({ error: `Unknown update target: ${req.params.target}` });
+            return;
+        }
+        try {
+            const result = await manager.run(req.params.target);
+            res.json({ result, snapshot: manager.currentSnapshot });
+        }
+        catch (error) {
+            res.status(409).json({ error: error instanceof Error ? error.message : String(error) });
+        }
+    });
+}