pipane 0.1.0

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

@@ -0,0 +1,231 @@
+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";
+const CACHE_FORMAT_VERSION = 1;
+const DEFAULT_EXTRACTOR_VERSION = "2";
+export class SessionIndex {
+    agentDir;
+    extractorVersion;
+    cacheFilePath;
+    cwdDisplayFormatter;
+    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;
+    }
+    async listSessions() {
+        const files = this.listSessionFiles();
+        const existing = this.getCache();
+        const canReuse = existing?.extractorVersion === this.extractorVersion;
+        const previousEntries = canReuse ? existing.entries : {};
+        const nextEntries = {};
+        const sessions = [];
+        let mutated = !canReuse;
+        for (const sessionPath of files) {
+            let stat;
+            try {
+                stat = statSync(sessionPath);
+            }
+            catch {
+                mutated = true;
+                continue;
+            }
+            const cached = previousEntries[sessionPath];
+            if (cached && cached.fileMtimeMs === stat.mtimeMs && cached.fileSize === stat.size) {
+                nextEntries[sessionPath] = cached;
+                sessions.push(cached.meta);
+                continue;
+            }
+            const meta = this.extractSessionMeta(sessionPath, stat.mtimeMs);
+            if (!meta) {
+                mutated = true;
+                continue;
+            }
+            nextEntries[sessionPath] = {
+                fileMtimeMs: stat.mtimeMs,
+                fileSize: stat.size,
+                meta,
+            };
+            sessions.push(meta);
+            mutated = true;
+        }
+        if (!mutated) {
+            const prevKeys = Object.keys(previousEntries);
+            if (prevKeys.length !== Object.keys(nextEntries).length) {
+                mutated = true;
+            }
+            else {
+                for (const key of prevKeys) {
+                    if (!nextEntries[key]) {
+                        mutated = true;
+                        break;
+                    }
+                }
+            }
+        }
+        sessions.sort((a, b) => new Date(b.modified).getTime() - new Date(a.modified).getTime());
+        if (mutated) {
+            try {
+                this.writeCache({
+                    cacheFormatVersion: CACHE_FORMAT_VERSION,
+                    extractorVersion: this.extractorVersion,
+                    generatedAt: new Date().toISOString(),
+                    entries: nextEntries,
+                });
+            }
+            catch {
+                // Cache writes are best-effort. Listing sessions must still succeed
+                // on read-only agent dirs or transient filesystem errors.
+            }
+        }
+        return sessions;
+    }
+    async invalidateAll() {
+        this.inMemoryCache = null;
+        try {
+            unlinkSync(this.cacheFilePath);
+        }
+        catch {
+            // ignore
+        }
+    }
+    listSessionFiles() {
+        const sessionsDir = path.join(this.agentDir, "sessions");
+        if (!existsSync(sessionsDir))
+            return [];
+        const files = [];
+        const stack = [sessionsDir];
+        while (stack.length > 0) {
+            const current = stack.pop();
+            let entries;
+            try {
+                entries = readdirSync(current, { withFileTypes: true });
+            }
+            catch {
+                continue;
+            }
+            for (const entry of entries) {
+                const full = path.join(current, entry.name);
+                if (entry.isDirectory())
+                    stack.push(full);
+                else if (entry.isFile() && full.endsWith(".jsonl"))
+                    files.push(full);
+            }
+        }
+        return files;
+    }
+    extractSessionMeta(sessionPath, statMtimeMs) {
+        try {
+            const content = readFileSync(sessionPath, "utf8");
+            const entries = parseSessionEntries(content);
+            if (entries.length === 0)
+                return null;
+            const header = entries[0];
+            if (header?.type !== "session" || typeof header.id !== "string")
+                return null;
+            let name;
+            let messageCount = 0;
+            let firstMessage = "";
+            let lastActivityTime;
+            let lastUserPromptTimeMs = 0;
+            for (const entry of entries) {
+                if (entry?.type === "session_info" && typeof entry.name === "string") {
+                    const trimmed = entry.name.trim();
+                    if (trimmed)
+                        name = trimmed;
+                }
+                if (entry?.type !== "message")
+                    continue;
+                messageCount++;
+                const msg = entry.message;
+                if (!msg || typeof msg.role !== "string" || !Object.prototype.hasOwnProperty.call(msg, "content"))
+                    continue;
+                if (msg.role !== "user" && msg.role !== "assistant")
+                    continue;
+                const messageTs = typeof msg.timestamp === "number" ? msg.timestamp : undefined;
+                const entryTs = typeof entry.timestamp === "string" ? new Date(entry.timestamp).getTime() : NaN;
+                const ts = Number.isFinite(messageTs) ? messageTs : (!Number.isNaN(entryTs) ? entryTs : undefined);
+                if (typeof ts === "number") {
+                    lastActivityTime = Math.max(lastActivityTime ?? 0, ts);
+                }
+                if (msg.role === "user") {
+                    if (typeof ts === "number") {
+                        lastUserPromptTimeMs = Math.max(lastUserPromptTimeMs, ts);
+                    }
+                    if (!firstMessage) {
+                        const text = this.extractTextContent(msg.content);
+                        if (text)
+                            firstMessage = text;
+                    }
+                }
+            }
+            const createdMs = typeof header.timestamp === "string" ? new Date(header.timestamp).getTime() : NaN;
+            const created = !Number.isNaN(createdMs) ? new Date(createdMs) : new Date(statMtimeMs);
+            const modified = (() => {
+                if (typeof lastActivityTime === "number" && lastActivityTime > 0)
+                    return new Date(lastActivityTime);
+                if (!Number.isNaN(createdMs))
+                    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)",
+            };
+        }
+        catch {
+            return null;
+        }
+    }
+    extractTextContent(content) {
+        if (typeof content === "string")
+            return content;
+        if (!Array.isArray(content))
+            return "";
+        return content
+            .filter((c) => c?.type === "text")
+            .map((c) => String(c.text ?? ""))
+            .join(" ")
+            .trim();
+    }
+    getCache() {
+        if (this.inMemoryCache !== undefined)
+            return this.inMemoryCache;
+        this.inMemoryCache = this.readCacheFromDisk();
+        return this.inMemoryCache;
+    }
+    readCacheFromDisk() {
+        try {
+            if (!existsSync(this.cacheFilePath))
+                return null;
+            const parsed = JSON.parse(readFileSync(this.cacheFilePath, "utf8"));
+            if (parsed?.cacheFormatVersion !== CACHE_FORMAT_VERSION)
+                return null;
+            if (!parsed || typeof parsed !== "object" || typeof parsed.entries !== "object")
+                return null;
+            return parsed;
+        }
+        catch {
+            return null;
+        }
+    }
+    writeCache(cache) {
+        const dir = path.dirname(this.cacheFilePath);
+        mkdirSync(dir, { recursive: true });
+        const tmp = `${this.cacheFilePath}.tmp`;
+        writeFileSync(tmp, JSON.stringify(cache), "utf8");
+        renameSync(tmp, this.cacheFilePath);
+        this.inMemoryCache = cache;
+    }
+}

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

@@ -0,0 +1,260 @@
+/**
+ * Server-side session state manager that produces a canonical JSON representation.
+ *
+ * Replaces the old AttachedSession. Instead of maintaining complex state fields
+ * (messages, streamMessage, pendingToolCalls, partialToolResults), this class
+ * maintains a single JSON string that represents the complete session state.
+ *
+ * The JSON is a serialized SessionState object that the client can directly
+ * use for rendering — no client-side state management needed.
+ *
+ * Changes are delivered to clients via the hash-verified diff protocol
+ * from jsonl-sync.ts.
+ */
+import { existsSync, readFileSync, statSync } from "node:fs";
+import { parseSessionEntries, buildSessionContext, } from "@mariozechner/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");
+}
+// ── SessionJsonl ───────────────────────────────────────────────────────────
+export class SessionJsonl {
+    // ── Internal state (used to build the JSON) ────────────────────────────
+    _messages;
+    _streamMessage = null;
+    _pendingToolCalls = [];
+    _partialToolResults = {};
+    _model;
+    _thinkingLevel;
+    _steeringQueue = [];
+    _error;
+    // ── Serialized state + hash ────────────────────────────────────────────
+    _json;
+    _hash;
+    /** Monotonically increasing version for change detection */
+    _version = 1;
+    constructor(init) {
+        this._messages = init.messages;
+        this._model = init.model;
+        this._thinkingLevel = init.thinkingLevel;
+        // Build initial JSON
+        this._json = this.buildJson();
+        this._hash = computeHashSync(this._json);
+    }
+    get version() { return this._version; }
+    get json() { return this._json; }
+    get hash() { return this._hash; }
+    // Expose for ws-handler steering queue management
+    get steeringQueue() { return this._steeringQueue; }
+    set steeringQueue(q) {
+        this._steeringQueue = q;
+        this.rebuildJson();
+    }
+    // Expose model for ws-handler
+    get model() { return this._model; }
+    // Expose messages for post-detach snapshot
+    get messages() { return this._messages; }
+    /**
+     * Replace the internal messages array (e.g. after auto-compaction rewrites
+     * the session). Rebuilds the JSON and bumps the version.
+     */
+    replaceMessages(messages) {
+        this._messages = messages;
+        this._streamMessage = null;
+        this._pendingToolCalls = [];
+        this._partialToolResults = {};
+        this._version++;
+        this.rebuildJson();
+    }
+    /**
+     * Apply a streaming event from the pi process.
+     * Returns true if state changed.
+     */
+    applyEvent(event) {
+        switch (event.type) {
+            case "agent_start":
+                this._error = undefined;
+                this._streamMessage = null;
+                this._version++;
+                this.rebuildJson();
+                return true;
+            case "message_start":
+                this._streamMessage = event.message;
+                this._version++;
+                this.rebuildJson();
+                return true;
+            case "message_update":
+                this._streamMessage = event.message;
+                this._version++;
+                this.rebuildJson();
+                return true;
+            case "message_end": {
+                this._streamMessage = null;
+                const msg = event.message;
+                if (msg) {
+                    this._messages = [...this._messages, msg];
+                }
+                this._version++;
+                this.rebuildJson();
+                return true;
+            }
+            case "turn_end": {
+                if (event.message?.role === "assistant" && event.message?.errorMessage) {
+                    this._error = event.message.errorMessage;
+                    this._version++;
+                    this.rebuildJson();
+                    return true;
+                }
+                return false;
+            }
+            case "tool_execution_start": {
+                const toolCallId = event.toolCallId;
+                if (toolCallId && !this._pendingToolCalls.includes(toolCallId)) {
+                    this._pendingToolCalls = [...this._pendingToolCalls, toolCallId];
+                    this._version++;
+                    this.rebuildJson();
+                    return true;
+                }
+                return false;
+            }
+            case "tool_execution_update": {
+                const toolCallId = event.toolCallId;
+                const partialResult = event.partialResult;
+                if (toolCallId && partialResult) {
+                    this._partialToolResults = { ...this._partialToolResults, [toolCallId]: partialResult };
+                    this._version++;
+                    this.rebuildJson();
+                    return true;
+                }
+                return false;
+            }
+            case "tool_execution_end": {
+                const toolCallId = event.toolCallId;
+                if (toolCallId) {
+                    this._pendingToolCalls = this._pendingToolCalls.filter(id => id !== toolCallId);
+                    if (toolCallId in this._partialToolResults) {
+                        const { [toolCallId]: _, ...rest } = this._partialToolResults;
+                        this._partialToolResults = rest;
+                    }
+                    this._version++;
+                    this.rebuildJson();
+                    return true;
+                }
+                return false;
+            }
+            default:
+                return false;
+        }
+    }
+    /**
+     * Compute a SyncOp to send to a client.
+     *
+     * @param clientJson - The client's current JSON string (empty if first sync)
+     * @param clientHash - The client's current hash (empty if first sync)
+     * @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)
+            return null;
+        return computeSyncOp(clientJson, this._json, clientHash, this._hash);
+    }
+    /**
+     * Get the full session state (for reading, not for the wire protocol).
+     */
+    toState() {
+        return this.buildState();
+    }
+    // ── Private ────────────────────────────────────────────────────────────
+    /**
+     * Build the flat session state. Merges streamMessage and partialToolResults
+     * into the messages array so the client has a single thing to render.
+     */
+    buildState() {
+        const messages = [...this._messages];
+        // Inject partial tool results as synthetic toolResult messages
+        // so the client's tool renderers can show in-progress output
+        for (const [id, partialResult] of Object.entries(this._partialToolResults)) {
+            messages.push({
+                role: "toolResult",
+                toolCallId: id,
+                content: partialResult.content ?? [],
+                isError: false,
+                details: partialResult.details,
+                timestamp: Date.now(),
+            });
+        }
+        // Append the in-flight stream message at the end
+        if (this._streamMessage) {
+            messages.push(this._streamMessage);
+        }
+        return {
+            messages,
+            isStreaming: true,
+            pendingToolCalls: this._pendingToolCalls,
+            model: this._model,
+            thinkingLevel: this._thinkingLevel,
+            steeringQueue: this._steeringQueue,
+            error: this._error,
+        };
+    }
+    buildJson() {
+        return JSON.stringify(this.buildState());
+    }
+    rebuildJson() {
+        const oldJson = this._json;
+        this._json = this.buildJson();
+        if (this._json !== oldJson) {
+            this._hash = computeHashSync(this._json);
+        }
+    }
+}
+// ── Disk reader ────────────────────────────────────────────────────────────
+/**
+ * Read a session from disk and return a serialized SessionState JSON + hash.
+ */
+export function readSessionFromDisk(sessionPath) {
+    let messages = [];
+    let model = null;
+    let thinkingLevel = "off";
+    try {
+        if (existsSync(sessionPath)) {
+            const content = readFileSync(sessionPath, "utf8");
+            const entries = parseSessionEntries(content);
+            const context = buildSessionContext(entries);
+            messages = context.messages ?? [];
+            model = context.model ?? null;
+            thinkingLevel = context.thinkingLevel ?? "off";
+        }
+    }
+    catch (err) {
+        console.error(`[session] Failed to read session ${sessionPath}:`, err);
+    }
+    const state = {
+        messages,
+        isStreaming: false,
+        pendingToolCalls: [],
+        model,
+        thinkingLevel,
+        steeringQueue: [],
+    };
+    const json = JSON.stringify(state);
+    const hash = computeHashSync(json);
+    return { json, hash, state };
+}
+/**
+ * Get the file size of a session file. Returns 0 if the file doesn't exist.
+ */
+export function getSessionFileSize(sessionPath) {
+    try {
+        if (existsSync(sessionPath)) {
+            return statSync(sessionPath).size;
+        }
+    }
+    catch {
+        // ignore
+    }
+    return 0;
+}

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

@@ -0,0 +1,155 @@
+/**
+ * Session lifecycle state machine.
+ *
+ * Single source of truth for session→process mappings, session status,
+ * and steering queues. Enforces legal state transitions and emits typed events.
+ *
+ * States per session:
+ *   (absent)  → session has never been tracked
+ *   "running" → a pi process is attached and executing a turn
+ *   "done"    → pi process was attached at some point and has since detached
+ *
+ * Transitions:
+ *   attach(sessionPath, proc)  → sets "running"
+ *   detach(sessionPath)        → sets "done", clears proc mapping
+ *   crash(sessionPath)         → sets "done", clears proc mapping (for unexpected exits)
+ */
+export class SessionLifecycle {
+    /** session path → attached process */
+    attached = new Map();
+    /** session path → "running" | "done" (persists for server lifetime) */
+    statuses = new Map();
+    /** session path → queued steering messages */
+    steeringQueues = new Map();
+    listeners = new Set();
+    // ── Event subscription ───────────────────────────────────────────────
+    subscribe(fn) {
+        this.listeners.add(fn);
+        return () => this.listeners.delete(fn);
+    }
+    emit(event) {
+        for (const fn of this.listeners)
+            fn(event);
+    }
+    // ── State queries ────────────────────────────────────────────────────
+    getAttachedProcess(sessionPath) {
+        return this.attached.get(sessionPath);
+    }
+    getAllStatuses() {
+        const result = {};
+        for (const [k, v] of this.statuses)
+            result[k] = v;
+        return result;
+    }
+    getAttachedSessionForProcess(proc) {
+        for (const [sessionPath, p] of this.attached) {
+            if (p === proc)
+                return sessionPath;
+        }
+        return undefined;
+    }
+    get attachedCount() {
+        return this.attached.size;
+    }
+    // ── Transitions ──────────────────────────────────────────────────────
+    /**
+     * Attach a process to a session. Sets status to "running".
+     * If the session is already attached, returns the existing process (idempotent).
+     */
+    attach(sessionPath, proc) {
+        const existing = this.attached.get(sessionPath);
+        if (existing) {
+            return existing;
+        }
+        this.attached.set(sessionPath, proc);
+        this.statuses.set(sessionPath, "running");
+        this.emit({ type: "status_change", sessionPath, status: "running" });
+        this.emit({ type: "session_attached", sessionPath, procId: proc.id });
+        return proc;
+    }
+    /**
+     * Detach a process from a session (normal completion). Sets status to "done".
+     * Returns the process that was detached, or undefined if not attached.
+     */
+    detach(sessionPath) {
+        const proc = this.attached.get(sessionPath);
+        if (!proc) {
+            console.warn(`[lifecycle] detach called for non-attached session: ${sessionPath}`);
+            return undefined;
+        }
+        this.attached.delete(sessionPath);
+        this.statuses.set(sessionPath, "done");
+        // Clear steering queue on detach
+        this.steeringQueues.delete(sessionPath);
+        this.emit({ type: "steering_queue_update", sessionPath, queue: [] });
+        this.emit({ type: "status_change", sessionPath, status: "done" });
+        this.emit({ type: "session_detached", sessionPath, procId: proc.id });
+        return proc;
+    }
+    /**
+     * Handle a process crash while attached to a session.
+     * Same as detach but named differently for clarity in call sites.
+     */
+    crash(sessionPath) {
+        return this.detach(sessionPath);
+    }
+    // ── Steering queue management ────────────────────────────────────────
+    getAllSteeringQueues() {
+        const result = {};
+        for (const [k, v] of this.steeringQueues) {
+            if (v.length > 0)
+                result[k] = [...v];
+        }
+        return result;
+    }
+    enqueueSteering(sessionPath, message) {
+        let queue = this.steeringQueues.get(sessionPath);
+        if (!queue) {
+            queue = [];
+            this.steeringQueues.set(sessionPath, queue);
+        }
+        queue.push(message);
+        this.emit({ type: "steering_queue_update", sessionPath, queue: [...queue] });
+    }
+    /**
+     * Dequeue a steering message by matching its text.
+     * Used when the agent confirms it received a user message.
+     */
+    dequeueSteering(sessionPath, text) {
+        const queue = this.steeringQueues.get(sessionPath);
+        if (!queue)
+            return false;
+        const idx = queue.indexOf(text);
+        if (idx === -1)
+            return false;
+        queue.splice(idx, 1);
+        if (queue.length === 0) {
+            this.steeringQueues.delete(sessionPath);
+        }
+        this.emit({ type: "steering_queue_update", sessionPath, queue: [...(this.steeringQueues.get(sessionPath) ?? [])] });
+        return true;
+    }
+    /**
+     * Remove a steering message by index.
+     */
+    removeSteeringByIndex(sessionPath, index) {
+        const queue = this.steeringQueues.get(sessionPath);
+        if (!queue || index < 0 || index >= queue.length)
+            return false;
+        queue.splice(index, 1);
+        if (queue.length === 0) {
+            this.steeringQueues.delete(sessionPath);
+        }
+        this.emit({ type: "steering_queue_update", sessionPath, queue: [...(this.steeringQueues.get(sessionPath) ?? [])] });
+        return true;
+    }
+    /**
+     * Clear all steering messages for a session.
+     */
+    clearSteering(sessionPath) {
+        if (!this.steeringQueues.has(sessionPath))
+            return;
+        this.steeringQueues.delete(sessionPath);
+        this.emit({ type: "steering_queue_update", sessionPath, queue: [] });
+    }
+}