@co0ontty/wand 3.1.1 → 4.0.0

package/dist/session-logger.d.ts

@@ -20,6 +20,15 @@ export interface ShortcutLogContext {
     /** Whether the auto-approve was a false positive */
     falsePositive?: boolean;
 }
+/** Optional tuning and I/O injection used by focused logger tests. */
+export interface SessionLoggerOptions {
+    flushIntervalMs?: number;
+    perFileBufferMaxBytes?: number;
+    totalBufferMaxBytes?: number;
+    ptyLogMaxBytes?: number;
+    ptyLogMaxRotations?: number;
+    appendFile?: (filePath: string, data: string) => void;
+}
 /**
  * SessionLogger saves raw session content to local files for debugging and analysis.
  *
@@ -35,10 +44,20 @@ export interface ShortcutLogContext {
 export declare class SessionLogger {
     private readonly baseDir;
     private readonly dirs;
-    /** Cached on-disk size of hot-path log files so we can rotate without stat'ing on every chunk. */
+    /** Cached logical size (disk + pending buffer) so rotation does not stat every chunk. */
     private readonly logSizes;
     private readonly shortcutLogMaxBytes;
-    constructor(configDir: string, shortcutLogMaxBytes?: number);
+    private readonly flushIntervalMs;
+    private readonly perFileBufferMaxBytes;
+    private readonly totalBufferMaxBytes;
+    private readonly ptyLogMaxBytes;
+    private readonly ptyLogMaxRotations;
+    private readonly appendFile;
+    private readonly appendBuffers;
+    private totalBufferedBytes;
+    private flushTimer;
+    private disposed;
+    constructor(configDir: string, shortcutLogMaxBytes?: number, options?: SessionLoggerOptions);
     private ensureDir;
     /**
      * Rotate PTY log files if the current one exceeds the size limit.
@@ -71,4 +90,15 @@ export declare class SessionLogger {
     appendShortcutLog(sessionId: string, shortcutKey: string, tailLines: string, ctx?: ShortcutLogContext): void;
     /** Truncate shortcut log by keeping only the most recent half of entries. Returns the new on-disk size. */
     private truncateShortcutLog;
+    /** Synchronously persist all pending append logs owned by one session. */
+    flushSession(sessionId: string): void;
+    /** Synchronously persist every pending append log owned by this logger. */
+    flushAll(): void;
+    /** Stop the coalescing timer and synchronously persist the final batch. */
+    dispose(): void;
+    private enqueueAppend;
+    private flushFile;
+    private scheduleFlush;
+    private clearFlushTimerIfIdle;
+    private clearFlushTimer;
 }

package/dist/session-logger.js

@@ -8,6 +8,12 @@ const PTY_LOG_MAX_SIZE = 50 * 1024 * 1024;
 const PTY_LOG_MAX_ROTATIONS = 3;
 /** Default max size for shortcut interaction logs per session (10 MB) */
 const DEFAULT_SHORTCUT_LOG_MAX_BYTES = 10 * 1024 * 1024;
+/** Delay used to coalesce hot-path append calls without adding noticeable log latency. */
+const DEFAULT_FLUSH_INTERVAL_MS = 40;
+/** Bound memory retained by one hot log file. */
+const DEFAULT_PER_FILE_BUFFER_MAX_BYTES = 256 * 1024;
+/** Bound memory retained across all sessions owned by one logger instance. */
+const DEFAULT_TOTAL_BUFFER_MAX_BYTES = 4 * 1024 * 1024;
 /**
  * SessionLogger saves raw session content to local files for debugging and analysis.
  *
@@ -23,12 +29,28 @@ const DEFAULT_SHORTCUT_LOG_MAX_BYTES = 10 * 1024 * 1024;
 export class SessionLogger {
     baseDir;
     dirs = new Map();
-    /** Cached on-disk size of hot-path log files so we can rotate without stat'ing on every chunk. */
+    /** Cached logical size (disk + pending buffer) so rotation does not stat every chunk. */
     logSizes = new Map();
     shortcutLogMaxBytes;
-    constructor(configDir, shortcutLogMaxBytes) {
+    flushIntervalMs;
+    perFileBufferMaxBytes;
+    totalBufferMaxBytes;
+    ptyLogMaxBytes;
+    ptyLogMaxRotations;
+    appendFile;
+    appendBuffers = new Map();
+    totalBufferedBytes = 0;
+    flushTimer = null;
+    disposed = false;
+    constructor(configDir, shortcutLogMaxBytes, options = {}) {
         this.baseDir = path.join(configDir, "sessions");
         this.shortcutLogMaxBytes = shortcutLogMaxBytes ?? DEFAULT_SHORTCUT_LOG_MAX_BYTES;
+        this.flushIntervalMs = positiveInteger(options.flushIntervalMs, DEFAULT_FLUSH_INTERVAL_MS);
+        this.perFileBufferMaxBytes = positiveInteger(options.perFileBufferMaxBytes, DEFAULT_PER_FILE_BUFFER_MAX_BYTES);
+        this.totalBufferMaxBytes = positiveInteger(options.totalBufferMaxBytes, DEFAULT_TOTAL_BUFFER_MAX_BYTES);
+        this.ptyLogMaxBytes = positiveInteger(options.ptyLogMaxBytes, PTY_LOG_MAX_SIZE);
+        this.ptyLogMaxRotations = positiveInteger(options.ptyLogMaxRotations, PTY_LOG_MAX_ROTATIONS);
+        this.appendFile = options.appendFile ?? ((filePath, data) => appendFileSync(filePath, data));
         try {
             mkdirSync(this.baseDir, { recursive: true });
         }
@@ -62,12 +84,12 @@ export class SessionLogger {
      */
     rotatePtyLog(dir) {
         // Delete oldest if it exists (beyond max rotations)
-        const oldest = path.join(dir, `pty-output.log.${PTY_LOG_MAX_ROTATIONS}`);
+        const oldest = path.join(dir, `pty-output.log.${this.ptyLogMaxRotations}`);
         if (existsSync(oldest)) {
             unlinkSync(oldest);
         }
         // Shift existing rotations up by one
-        for (let i = PTY_LOG_MAX_ROTATIONS - 1; i >= 1; i--) {
+        for (let i = this.ptyLogMaxRotations - 1; i >= 1; i--) {
             const src = path.join(dir, `pty-output.log.${i}`);
             const dst = path.join(dir, `pty-output.log.${i + 1}`);
             if (existsSync(src)) {
@@ -82,16 +104,21 @@ export class SessionLogger {
     }
     /** Append raw PTY output chunk */
     appendPtyOutput(sessionId, chunk) {
+        if (this.disposed || chunk.length === 0)
+            return;
         try {
             const dir = this.ensureDir(sessionId);
             const sizes = this.logSizes.get(sessionId);
-            if (sizes.pty >= PTY_LOG_MAX_SIZE) {
+            const logPath = path.join(dir, "pty-output.log");
+            if (sizes.pty >= this.ptyLogMaxBytes) {
+                // Pending bytes must reach the current file before it is renamed.
+                this.flushFile(logPath);
                 this.rotatePtyLog(dir);
                 sizes.pty = 0;
             }
-            const logPath = path.join(dir, "pty-output.log");
-            appendFileSync(logPath, chunk);
-            sizes.pty += Buffer.byteLength(chunk);
+            const chunkBytes = Buffer.byteLength(chunk);
+            sizes.pty += chunkBytes;
+            this.enqueueAppend(sessionId, logPath, chunk, chunkBytes, "pty");
         }
         catch {
             // Non-critical — don't let logging failures affect main flow
@@ -100,9 +127,10 @@ export class SessionLogger {
     /** Read the full PTY transcript including rotated logs, oldest first. */
     readPtyOutput(sessionId) {
         try {
+            this.flushSession(sessionId);
             const dir = this.ensureDir(sessionId);
             const parts = [];
-            for (let index = PTY_LOG_MAX_ROTATIONS; index >= 1; index -= 1) {
+            for (let index = this.ptyLogMaxRotations; index >= 1; index -= 1) {
                 const rotatedPath = path.join(dir, `pty-output.log.${index}`);
                 if (existsSync(rotatedPath)) {
                     parts.push(readFileSync(rotatedPath, "utf8"));
@@ -122,9 +150,11 @@ export class SessionLogger {
     }
     /** Append a native mode NDJSON event */
     appendStreamEvent(sessionId, event) {
+        if (this.disposed)
+            return;
         try {
             const dir = this.ensureDir(sessionId);
-            appendFileSync(path.join(dir, "stream-events.jsonl"), JSON.stringify(event) + "\n");
+            this.enqueueAppend(sessionId, path.join(dir, "stream-events.jsonl"), JSON.stringify(event) + "\n");
         }
         catch {
             // Non-critical
@@ -132,9 +162,11 @@ export class SessionLogger {
     }
     /** Append raw stdout chunk from a structured-mode child process. */
     appendStructuredStdout(sessionId, chunk) {
+        if (this.disposed || chunk.length === 0)
+            return;
         try {
             const dir = this.ensureDir(sessionId);
-            appendFileSync(path.join(dir, "structured-stdout.log"), chunk);
+            this.enqueueAppend(sessionId, path.join(dir, "structured-stdout.log"), chunk);
         }
         catch {
             // Non-critical
@@ -142,9 +174,11 @@ export class SessionLogger {
     }
     /** Append raw stderr chunk from a structured-mode child process. */
     appendStructuredStderr(sessionId, chunk) {
+        if (this.disposed || chunk.length === 0)
+            return;
         try {
             const dir = this.ensureDir(sessionId);
-            appendFileSync(path.join(dir, "structured-stderr.log"), chunk);
+            this.enqueueAppend(sessionId, path.join(dir, "structured-stderr.log"), chunk);
         }
         catch {
             // Non-critical
@@ -152,10 +186,12 @@ export class SessionLogger {
     }
     /** Append a spawn metadata record (args, pid, cwd, exit, errors, …) for a structured run. */
     appendStructuredSpawn(sessionId, meta) {
+        if (this.disposed)
+            return;
         try {
             const dir = this.ensureDir(sessionId);
             const entry = JSON.stringify({ ts: new Date().toISOString(), ...meta }) + "\n";
-            appendFileSync(path.join(dir, "structured-spawns.jsonl"), entry);
+            this.enqueueAppend(sessionId, path.join(dir, "structured-spawns.jsonl"), entry);
         }
         catch {
             // Non-critical
@@ -164,6 +200,7 @@ export class SessionLogger {
     /** Read recent stderr tail (for surfacing in failure messages). */
     readStructuredStderrTail(sessionId, maxBytes = 4096) {
         try {
+            this.flushSession(sessionId);
             const dir = this.ensureDir(sessionId);
             const filePath = path.join(dir, "structured-stderr.log");
             if (!existsSync(filePath))
@@ -177,6 +214,8 @@ export class SessionLogger {
     }
     /** Save the current structured messages snapshot */
     saveMessages(sessionId, messages) {
+        if (this.disposed)
+            return;
         try {
             const dir = this.ensureDir(sessionId);
             writeFileSync(path.join(dir, "messages.json"), JSON.stringify(messages, null, 2) + "\n");
@@ -187,6 +226,8 @@ export class SessionLogger {
     }
     /** Save session metadata */
     saveMetadata(sessionId, meta) {
+        if (this.disposed)
+            return;
         try {
             const dir = this.ensureDir(sessionId);
             writeFileSync(path.join(dir, "metadata.json"), JSON.stringify(meta, null, 2) + "\n");
@@ -197,6 +238,9 @@ export class SessionLogger {
     }
     /** Delete all log files for a session */
     deleteSession(sessionId) {
+        // Flush and remove every pending entry before deleting the directory so a
+        // later timer cannot recreate files for a deleted session.
+        this.flushSession(sessionId);
         const dir = path.join(this.baseDir, sessionId);
         try {
             rmSync(dir, { recursive: true, force: true });
@@ -209,7 +253,7 @@ export class SessionLogger {
     }
     /** Append a shortcut key interaction log entry (for analyzing auto-confirm gaps) */
     appendShortcutLog(sessionId, shortcutKey, tailLines, ctx) {
-        if (this.shortcutLogMaxBytes <= 0)
+        if (this.disposed || this.shortcutLogMaxBytes <= 0)
             return;
         try {
             const dir = this.ensureDir(sessionId);
@@ -226,10 +270,11 @@ export class SessionLogger {
             }) + "\n";
             const entryBytes = Buffer.byteLength(entry);
             if (sizes.shortcut + entryBytes > this.shortcutLogMaxBytes) {
+                this.flushFile(logPath);
                 sizes.shortcut = this.truncateShortcutLog(logPath);
             }
-            appendFileSync(logPath, entry);
             sizes.shortcut += entryBytes;
+            this.enqueueAppend(sessionId, logPath, entry, entryBytes, "shortcut");
         }
         catch {
             // Non-critical
@@ -253,6 +298,86 @@ export class SessionLogger {
             return 0;
         }
     }
+    /** Synchronously persist all pending append logs owned by one session. */
+    flushSession(sessionId) {
+        for (const [filePath, pending] of Array.from(this.appendBuffers.entries())) {
+            if (pending.sessionId === sessionId)
+                this.flushFile(filePath);
+        }
+        this.clearFlushTimerIfIdle();
+    }
+    /** Synchronously persist every pending append log owned by this logger. */
+    flushAll() {
+        this.clearFlushTimer();
+        for (const filePath of Array.from(this.appendBuffers.keys())) {
+            this.flushFile(filePath);
+        }
+    }
+    /** Stop the coalescing timer and synchronously persist the final batch. */
+    dispose() {
+        if (this.disposed)
+            return;
+        this.disposed = true;
+        this.flushAll();
+    }
+    enqueueAppend(sessionId, filePath, chunk, byteLength = Buffer.byteLength(chunk), sizeKind) {
+        let pending = this.appendBuffers.get(filePath);
+        if (!pending) {
+            pending = { sessionId, chunks: [], byteLength: 0, sizeKind };
+            this.appendBuffers.set(filePath, pending);
+        }
+        pending.chunks.push(chunk);
+        pending.byteLength += byteLength;
+        this.totalBufferedBytes += byteLength;
+        if (pending.byteLength >= this.perFileBufferMaxBytes) {
+            this.flushFile(filePath);
+        }
+        if (this.totalBufferedBytes >= this.totalBufferMaxBytes) {
+            this.flushAll();
+        }
+        else if (this.totalBufferedBytes > 0) {
+            this.scheduleFlush();
+        }
+    }
+    flushFile(filePath) {
+        const pending = this.appendBuffers.get(filePath);
+        if (!pending)
+            return;
+        this.appendBuffers.delete(filePath);
+        this.totalBufferedBytes = Math.max(0, this.totalBufferedBytes - pending.byteLength);
+        try {
+            this.appendFile(filePath, pending.chunks.join(""));
+        }
+        catch {
+            // Match the previous best-effort behavior. Do not retain a failing batch
+            // indefinitely, but remove its bytes from logical rotation accounting.
+            if (pending.sizeKind) {
+                const sizes = this.logSizes.get(pending.sessionId);
+                if (sizes)
+                    sizes[pending.sizeKind] = Math.max(0, sizes[pending.sizeKind] - pending.byteLength);
+            }
+        }
+        this.clearFlushTimerIfIdle();
+    }
+    scheduleFlush() {
+        if (this.flushTimer || this.disposed)
+            return;
+        this.flushTimer = setTimeout(() => {
+            this.flushTimer = null;
+            this.flushAll();
+        }, this.flushIntervalMs);
+        this.flushTimer.unref?.();
+    }
+    clearFlushTimerIfIdle() {
+        if (this.totalBufferedBytes === 0)
+            this.clearFlushTimer();
+    }
+    clearFlushTimer() {
+        if (!this.flushTimer)
+            return;
+        clearTimeout(this.flushTimer);
+        this.flushTimer = null;
+    }
 }
 function tryStatSize(filePath) {
     try {
@@ -262,3 +387,8 @@ function tryStatSize(filePath) {
         return 0;
     }
 }
+function positiveInteger(value, fallback) {
+    return value !== undefined && Number.isFinite(value) && value > 0
+        ? Math.floor(value)
+        : fallback;
+}

package/dist/session-registry.d.ts

@@ -0,0 +1,27 @@
+import type { ProcessManager } from "./process-manager.js";
+import type { StructuredSessionManager } from "./structured-session-manager.js";
+import type { WandStorage } from "./storage.js";
+import type { ExecutionMode, SessionSnapshot } from "./types.js";
+export type SessionOwner = "structured" | "pty" | "storage";
+/**
+ * Coordinates session ownership without merging the two runner managers.
+ * Live structured state wins over PTY, and both win over a durable fallback.
+ */
+export declare class SessionRegistry {
+    private readonly processes;
+    private readonly structured;
+    private readonly storage;
+    constructor(processes: ProcessManager, structured: StructuredSessionManager, storage: WandStorage);
+    ownerOf(id: string): SessionOwner | null;
+    get(id: string): SessionSnapshot | null;
+    getLatest(id: string): SessionSnapshot | null;
+    listSlim(): SessionSnapshot[];
+    setSessionModel(id: string, model: string | null): SessionSnapshot | null;
+    setSessionThinkingEffort(id: string, effort: SessionSnapshot["thinkingEffort"]): SessionSnapshot | null;
+    setSessionMode(id: string, mode: ExecutionMode): SessionSnapshot | null;
+    setSessionTopic(id: string, title: string, description: string): SessionSnapshot | null;
+    updateWorktreeState(id: string, status: SessionSnapshot["worktreeMergeStatus"], info: SessionSnapshot["worktreeMergeInfo"]): SessionSnapshot | null;
+    delete(id: string): SessionSnapshot | null;
+    deleteWithProviderHistory(id: string): SessionSnapshot | null;
+    private updateStored;
+}

package/dist/session-registry.js

@@ -0,0 +1,153 @@
+function slimSnapshot(snapshot) {
+    const { output: _output, messages: _messages, ...slim } = snapshot;
+    return { ...slim, output: "" };
+}
+function addHiddenProviderSessionId(storage, id) {
+    const raw = storage.getConfigValue("hidden_claude_session_ids");
+    let hidden;
+    try {
+        const parsed = raw ? JSON.parse(raw) : [];
+        hidden = new Set(Array.isArray(parsed) ? parsed.filter((value) => typeof value === "string") : []);
+    }
+    catch {
+        hidden = new Set();
+    }
+    if (hidden.has(id))
+        return;
+    hidden.add(id);
+    storage.setConfigValue("hidden_claude_session_ids", JSON.stringify(Array.from(hidden)));
+}
+/**
+ * Coordinates session ownership without merging the two runner managers.
+ * Live structured state wins over PTY, and both win over a durable fallback.
+ */
+export class SessionRegistry {
+    processes;
+    structured;
+    storage;
+    constructor(processes, structured, storage) {
+        this.processes = processes;
+        this.structured = structured;
+        this.storage = storage;
+    }
+    ownerOf(id) {
+        if (this.structured.get(id))
+            return "structured";
+        if (this.processes.getOwned(id))
+            return "pty";
+        return this.storage.getSession(id) ? "storage" : null;
+    }
+    get(id) {
+        return this.structured.get(id) ?? this.processes.getOwned(id) ?? this.storage.getSession(id);
+    }
+    getLatest(id) {
+        return this.get(id);
+    }
+    listSlim() {
+        const byId = new Map();
+        for (const snapshot of this.structured.listSlim())
+            byId.set(snapshot.id, snapshot);
+        for (const snapshot of this.processes.listSlim()) {
+            if (!byId.has(snapshot.id))
+                byId.set(snapshot.id, snapshot);
+        }
+        for (const snapshot of this.storage.loadSessions()) {
+            if (!byId.has(snapshot.id))
+                byId.set(snapshot.id, slimSnapshot(snapshot));
+        }
+        return Array.from(byId.values()).sort((a, b) => b.startedAt.localeCompare(a.startedAt));
+    }
+    setSessionModel(id, model) {
+        const owner = this.ownerOf(id);
+        if (owner === "structured")
+            return this.structured.setSessionModel(id, model);
+        if (owner === "pty")
+            return this.processes.setSessionModel(id, model);
+        return this.updateStored(id, (snapshot) => ({
+            ...snapshot,
+            selectedModel: model?.trim() || null,
+            structuredState: (snapshot.sessionKind ?? "pty") === "structured"
+                ? { ...snapshot.structuredState, model: model?.trim() || undefined }
+                : snapshot.structuredState,
+        }));
+    }
+    setSessionThinkingEffort(id, effort) {
+        const owner = this.ownerOf(id);
+        if (owner === "structured")
+            return this.structured.setSessionThinkingEffort(id, effort);
+        if (owner === "pty")
+            return this.processes.setSessionThinkingEffort(id, effort);
+        return this.updateStored(id, (snapshot) => ({ ...snapshot, thinkingEffort: effort }));
+    }
+    setSessionMode(id, mode) {
+        const owner = this.ownerOf(id);
+        if (owner === "structured")
+            return this.structured.setSessionMode(id, mode);
+        if (owner === "pty")
+            return this.processes.setSessionMode(id, mode);
+        return this.updateStored(id, (snapshot) => ({ ...snapshot, mode }));
+    }
+    setSessionTopic(id, title, description) {
+        const owner = this.ownerOf(id);
+        if (owner === "structured")
+            return this.structured.setSessionTopic(id, title, description);
+        if (owner === "pty")
+            return this.processes.setSessionTopic(id, title, description);
+        return this.updateStored(id, (snapshot) => ({ ...snapshot, title, description, summary: description }));
+    }
+    updateWorktreeState(id, status, info) {
+        const owner = this.ownerOf(id);
+        if (owner === "structured")
+            return this.structured.setWorktreeMergeState(id, status, info);
+        if (owner === "pty")
+            return this.processes.setWorktreeMergeState(id, status, info);
+        return this.updateStored(id, (snapshot) => ({
+            ...snapshot,
+            worktreeMergeStatus: status,
+            worktreeMergeInfo: info ?? null,
+        }));
+    }
+    delete(id) {
+        const snapshot = this.get(id);
+        if (!snapshot)
+            return null;
+        const owner = this.ownerOf(id);
+        if (owner === "structured")
+            this.structured.delete(id);
+        else if (owner === "pty")
+            this.processes.delete(id);
+        else
+            this.storage.deleteSession(id);
+        return snapshot;
+    }
+    deleteWithProviderHistory(id) {
+        const snapshot = this.delete(id);
+        const providerSessionId = snapshot?.claudeSessionId?.trim();
+        if (!snapshot || !providerSessionId)
+            return snapshot;
+        const provider = snapshot.provider
+            ?? snapshot.structuredState?.provider
+            ?? (/^codex\b/i.test(snapshot.command.trim())
+                ? "codex"
+                : /^opencode\b/i.test(snapshot.command.trim()) ? "opencode" : "claude");
+        if (provider === "claude") {
+            this.processes.deleteClaudeHistoryFiles([{ claudeSessionId: providerSessionId, cwd: snapshot.cwd }]);
+        }
+        else if (provider === "codex") {
+            this.processes.deleteCodexHistoryFiles([providerSessionId]);
+        }
+        else {
+            return snapshot;
+        }
+        addHiddenProviderSessionId(this.storage, providerSessionId);
+        return snapshot;
+    }
+    updateStored(id, update) {
+        const current = this.storage.getSession(id);
+        if (!current)
+            return null;
+        const next = update(current);
+        this.storage.updateSessionRuntimeMetadata(next);
+        return next;
+    }
+}

package/dist/session-transport.d.ts

@@ -0,0 +1,31 @@
+import type { ConversationTurn, SessionSnapshot } from "./types.js";
+export declare const SESSION_TRANSPORT_OUTPUT_LIMIT = 200000;
+export type SessionBaseDTO = Omit<SessionSnapshot, "output" | "messages">;
+export interface SessionListItemDTO extends SessionBaseDTO {
+    /** Kept for compatibility with clients that initialize terminal state from the list. */
+    output: "";
+}
+export interface SessionDetailDTO extends SessionBaseDTO {
+    output: string;
+    outputOffset: number;
+    outputTotal: number;
+    outputTruncated: boolean;
+    messages?: ConversationTurn[];
+    messageOffset?: number;
+    messageTotal?: number;
+    leadingBlockOffset?: number;
+    leadingBlockTotal?: number;
+}
+export declare function toSessionListItemDTO(snapshot: SessionSnapshot): SessionListItemDTO;
+export interface SessionDetailDTOOptions {
+    output?: string;
+    messages?: ConversationTurn[];
+    messageOffset?: number;
+    messageTotal?: number;
+    leadingBlockOffset?: number;
+    leadingBlockTotal?: number;
+    outputLimit?: number;
+}
+export declare function toSessionDetailDTO(snapshot: SessionSnapshot, options?: SessionDetailDTOOptions): SessionDetailDTO;
+/** Bound snapshot-like event payloads before they enter per-client WS queues. */
+export declare function boundSessionEventData(data: unknown, outputLimit?: number): unknown;

package/dist/session-transport.js

@@ -0,0 +1,82 @@
+export const SESSION_TRANSPORT_OUTPUT_LIMIT = 200_000;
+/** Explicit allow-list separating the server's session object from its wire DTO. */
+function sessionBase(snapshot) {
+    return {
+        id: snapshot.id,
+        sessionSource: snapshot.sessionSource,
+        automationId: snapshot.automationId,
+        sessionKind: snapshot.sessionKind,
+        provider: snapshot.provider,
+        runner: snapshot.runner,
+        command: snapshot.command,
+        cwd: snapshot.cwd,
+        mode: snapshot.mode,
+        worktreeEnabled: snapshot.worktreeEnabled,
+        worktree: snapshot.worktree,
+        worktreeMergeStatus: snapshot.worktreeMergeStatus,
+        worktreeMergeInfo: snapshot.worktreeMergeInfo,
+        autonomyPolicy: snapshot.autonomyPolicy,
+        approvalPolicy: snapshot.approvalPolicy,
+        allowedScopes: snapshot.allowedScopes,
+        status: snapshot.status,
+        exitCode: snapshot.exitCode,
+        startedAt: snapshot.startedAt,
+        endedAt: snapshot.endedAt,
+        archived: snapshot.archived,
+        archivedAt: snapshot.archivedAt,
+        permissionBlocked: snapshot.permissionBlocked,
+        pendingEscalation: snapshot.pendingEscalation,
+        lastEscalationResult: snapshot.lastEscalationResult,
+        claudeSessionId: snapshot.claudeSessionId,
+        queuedMessages: snapshot.queuedMessages,
+        structuredState: snapshot.structuredState,
+        resumedFromSessionId: snapshot.resumedFromSessionId,
+        autoRecovered: snapshot.autoRecovered,
+        autoApprovePermissions: snapshot.autoApprovePermissions,
+        approvalStats: snapshot.approvalStats,
+        summary: snapshot.summary,
+        title: snapshot.title,
+        description: snapshot.description,
+        currentTaskTitle: snapshot.currentTaskTitle,
+        selectedModel: snapshot.selectedModel,
+        thinkingEffort: snapshot.thinkingEffort,
+        ptyCols: snapshot.ptyCols,
+        ptyRows: snapshot.ptyRows,
+    };
+}
+export function toSessionListItemDTO(snapshot) {
+    return { ...sessionBase(snapshot), output: "" };
+}
+export function toSessionDetailDTO(snapshot, options = {}) {
+    const rawOutput = options.output ?? snapshot.output;
+    const outputLimit = Math.max(1, options.outputLimit ?? SESSION_TRANSPORT_OUTPUT_LIMIT);
+    const outputOffset = Math.max(0, rawOutput.length - outputLimit);
+    return {
+        ...sessionBase(snapshot),
+        output: outputOffset > 0 ? rawOutput.slice(outputOffset) : rawOutput,
+        outputOffset,
+        outputTotal: rawOutput.length,
+        outputTruncated: outputOffset > 0,
+        ...(options.messages !== undefined ? { messages: options.messages } : {}),
+        ...(options.messageOffset !== undefined ? { messageOffset: options.messageOffset } : {}),
+        ...(options.messageTotal !== undefined ? { messageTotal: options.messageTotal } : {}),
+        ...(options.leadingBlockOffset !== undefined ? { leadingBlockOffset: options.leadingBlockOffset } : {}),
+        ...(options.leadingBlockTotal !== undefined ? { leadingBlockTotal: options.leadingBlockTotal } : {}),
+    };
+}
+/** Bound snapshot-like event payloads before they enter per-client WS queues. */
+export function boundSessionEventData(data, outputLimit = SESSION_TRANSPORT_OUTPUT_LIMIT) {
+    if (!data || typeof data !== "object" || Array.isArray(data))
+        return data;
+    const record = data;
+    if (typeof record.output !== "string" || record.output.length <= outputLimit)
+        return data;
+    const outputOffset = record.output.length - outputLimit;
+    return {
+        ...record,
+        output: record.output.slice(outputOffset),
+        outputOffset,
+        outputTotal: record.output.length,
+        outputTruncated: true,
+    };
+}