pipane 0.1.5 → 0.1.7

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

@@ -1,209 +0,0 @@
-/**
- * Attached session state — only exists while a pi process is running a turn.
- *
- * This is the in-memory state for sessions that have a pi process attached.
- * It accumulates streaming events (message_start, message_update, message_end,
- * tool_execution_start/end) into a canonical state.
- *
- * When the turn ends (agent_end), this object is discarded and the final
- * authoritative state is read from the JSONL file on disk.
- *
- * Detached sessions have NO in-memory state — they are read from disk on demand.
- */
-import { existsSync, readFileSync, statSync } from "node:fs";
-import { parseSessionEntries, buildSessionContext, } from "@mariozechner/pi-coding-agent";
-// ── Attached session ───────────────────────────────────────────────────────
-export class AttachedSession {
-    messages;
-    streamMessage = null;
-    pendingToolCalls = [];
-    /** Partial tool results from tool_execution_update, keyed by toolCallId */
-    partialToolResults = {};
-    model;
-    thinkingLevel;
-    steeringQueue = [];
-    error;
-    /** Monotonically increasing version for change detection */
-    _version = 1;
-    /** Whether the stream message changed since last push */
-    _streamDirty = false;
-    constructor(init) {
-        this.messages = init.messages;
-        this.model = init.model;
-        this.thinkingLevel = init.thinkingLevel;
-    }
-    get version() { return this._version; }
-    /**
-     * 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++;
-                return true;
-            case "message_start":
-                this.streamMessage = event.message;
-                this._streamDirty = true;
-                this._version++;
-                return true;
-            case "message_update":
-                this.streamMessage = event.message;
-                this._streamDirty = true;
-                this._version++;
-                return true;
-            case "message_end": {
-                this.streamMessage = null;
-                const msg = event.message;
-                if (msg) {
-                    this.messages = [...this.messages, msg];
-                }
-                this._version++;
-                return true;
-            }
-            case "turn_end": {
-                if (event.message?.role === "assistant" && event.message?.errorMessage) {
-                    this.error = event.message.errorMessage;
-                    this._version++;
-                    return true;
-                }
-                return false;
-            }
-            case "tool_execution_start": {
-                const toolCallId = event.toolCallId;
-                if (toolCallId && !this.pendingToolCalls.includes(toolCallId)) {
-                    this.pendingToolCalls = [...this.pendingToolCalls, toolCallId];
-                    this._streamDirty = true;
-                    this._version++;
-                    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._streamDirty = true;
-                    this._version++;
-                    return true;
-                }
-                return false;
-            }
-            case "tool_execution_end": {
-                const toolCallId = event.toolCallId;
-                if (toolCallId) {
-                    this.pendingToolCalls = this.pendingToolCalls.filter(id => id !== toolCallId);
-                    // Clear partial result for this tool
-                    if (toolCallId in this.partialToolResults) {
-                        const { [toolCallId]: _, ...rest } = this.partialToolResults;
-                        this.partialToolResults = rest;
-                    }
-                    this._streamDirty = true;
-                    this._version++;
-                    return true;
-                }
-                return false;
-            }
-            default:
-                return false;
-        }
-    }
-    /**
-     * Build a full snapshot of the current state.
-     */
-    toSnapshot() {
-        return {
-            messages: this.messages,
-            streamMessage: this.streamMessage,
-            status: "streaming",
-            pendingToolCalls: this.pendingToolCalls,
-            partialToolResults: this.partialToolResults,
-            model: this.model,
-            thinkingLevel: this.thinkingLevel,
-            steeringQueue: this.steeringQueue,
-            error: this.error,
-        };
-    }
-    /**
-     * Compute the cheapest update op to send to a client.
-     *
-     * If only streamMessage/pendingToolCalls changed (the high-frequency case
-     * during streaming), returns a lightweight stream_delta.
-     * Otherwise returns a full snapshot.
-     *
-     * Returns null if nothing changed since the client's last known version.
-     */
-    computeUpdateOp(clientVersion, clientMessageCount) {
-        if (this._version === clientVersion)
-            return null;
-        // If client has never seen this session, or messages changed, send snapshot
-        if (clientVersion === 0
-            || this.messages.length !== clientMessageCount
-            || this.messages.length < clientMessageCount) {
-            this._streamDirty = false;
-            return { op: "snapshot", state: this.toSnapshot() };
-        }
-        // Messages didn't change — only stream state changed
-        if (this._streamDirty) {
-            this._streamDirty = false;
-            return {
-                op: "stream_delta",
-                streamMessage: this.streamMessage,
-                pendingToolCalls: this.pendingToolCalls,
-                partialToolResults: this.partialToolResults,
-            };
-        }
-        // Something else changed (error, steering queue, etc.) — send snapshot
-        return { op: "snapshot", state: this.toSnapshot() };
-    }
-}
-// ── Disk reader ────────────────────────────────────────────────────────────
-/**
- * Read a session from disk and return a snapshot.
- * Used for detached sessions (no pi process running).
- */
-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);
-    }
-    return {
-        messages,
-        streamMessage: null,
-        status: "idle",
-        pendingToolCalls: [],
-        partialToolResults: {},
-        model,
-        thinkingLevel,
-        steeringQueue: [],
-    };
-}
-/**
- * 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/load-trace-store.js

@@ -1,48 +0,0 @@
-const MAX_TRACES = 50;
-const MAX_EVENTS_PER_TRACE = 1000;
-export class LoadTraceStore {
-    traces = new Map();
-    record(traceId, event) {
-        if (!traceId)
-            return;
-        const trace = this.ensure(traceId);
-        trace.events.push(event);
-        if (trace.events.length > MAX_EVENTS_PER_TRACE) {
-            trace.events.splice(0, trace.events.length - MAX_EVENTS_PER_TRACE);
-        }
-        trace.updatedAt = event.ts;
-    }
-    get(traceId) {
-        return this.traces.get(traceId);
-    }
-    getLatest() {
-        return Array.from(this.traces.values())
-            .sort((a, b) => b.updatedAt.localeCompare(a.updatedAt))
-            .slice(0, 10);
-    }
-    ensure(traceId) {
-        let trace = this.traces.get(traceId);
-        if (!trace) {
-            const now = new Date().toISOString();
-            trace = {
-                traceId,
-                startedAt: now,
-                updatedAt: now,
-                events: [],
-            };
-            this.traces.set(traceId, trace);
-            this.compact();
-        }
-        return trace;
-    }
-    compact() {
-        if (this.traces.size <= MAX_TRACES)
-            return;
-        const oldest = Array.from(this.traces.values())
-            .sort((a, b) => a.updatedAt.localeCompare(b.updatedAt))
-            .slice(0, this.traces.size - MAX_TRACES);
-        for (const trace of oldest) {
-            this.traces.delete(trace.traceId);
-        }
-    }
-}

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

@@ -1,155 +0,0 @@
-/**
- * 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: [] });
-    }
-}