codeep 2.14.0 → 2.15.0

package/dist/renderer/layout.js

@@ -0,0 +1,326 @@
+/**
+ * Pure layout helpers extracted from App.ts.
+ *
+ * These functions take a *snapshot* of the App's UI state (which panels are
+ * open, how many items they hold) and return geometric values (heights,
+ * offsets) without touching `this`. Keeping them pure means they can be
+ * unit-tested directly — the layout math is the part of the renderer most
+ * prone to off-by-one regressions, and it was previously untestable because
+ * it was inlined in `renderChat` with `this.*` access on every line.
+ *
+ * Convention: every field on `LayoutSnapshot` is `readonly` so callers
+ * cannot mutate the App's real state through the snapshot.
+ */
+/**
+ * Compute how many terminal rows the bottom panel (paste info, agent box,
+ * permission/session/confirm/search/export/login/logout/menu/settings
+ * dialogs, autocomplete) occupies in the current frame.
+ *
+ * Mirrors the if/else chain that used to live inline in `renderChat`.
+ * Returns 0 when no panel is open.
+ */
+export function bottomPanelHeight(s) {
+    if (s.pasteInfoOpen) {
+        const previewLines = Math.min(s.pasteInfoPreviewLines, 5);
+        return previewLines + 6; // title + preview + extra line indicator + options
+    }
+    if (s.isAgentRunning && !s.confirmOpen) {
+        return 9; // Agent progress box: top + 5 log lines + stats + bottom + 1 margin
+    }
+    if (s.permissionOpen) {
+        return 10; // Permission dialog
+    }
+    if (s.sessionPickerOpen) {
+        return Math.min(s.sessionPickerItemCount + 6, 14); // Session picker
+    }
+    if (s.confirmOpen) {
+        return s.confirmMessageCount + 5; // title + messages + buttons + padding
+    }
+    if (s.statusOpen) {
+        return 16; // Status info panel
+    }
+    if (s.helpOpen) {
+        return Math.min(s.height - 6, 20); // Help takes more space
+    }
+    if (s.searchOpen) {
+        return Math.min(s.searchResultCount * 3 + 6, 18); // Search results
+    }
+    if (s.exportOpen) {
+        return 10; // Export dialog
+    }
+    if (s.logoutOpen) {
+        return Math.min(s.logoutProviderCount + 6, 12); // Logout picker
+    }
+    if (s.loginOpen) {
+        return s.loginStep === 'provider'
+            ? Math.min(s.loginProviderCount + 5, 14)
+            : 8; // Login dialog
+    }
+    if (s.menuOpen) {
+        return Math.min(s.menuItemCount + 4, 14);
+    }
+    if (s.settingsOpen) {
+        return Math.min(s.settingsCount + 4, 16);
+    }
+    if (s.showAutocomplete && s.autocompleteItemCount > 0) {
+        return Math.min(s.autocompleteItemCount + 3, 12);
+    }
+    return 0;
+}
+export function chatLayout(height, panelHeight) {
+    const mainHeight = Math.max(1, height - panelHeight);
+    const messagesEnd = Math.max(0, mainHeight - 4);
+    const separatorLine = Math.max(0, mainHeight - 3);
+    const inputLine = Math.max(0, mainHeight - 2);
+    const statusLine = Math.max(0, mainHeight - 1);
+    return { messagesStart: 0, messagesEnd, separatorLine, inputLine, statusLine, mainHeight };
+}
+/**
+ * Count how many terminal rows a single chat message will occupy once
+ * word-wrapped to `maxWidth` columns. Used by `scrollToMessage` to find
+ * the right scroll offset.
+ *
+ * Every message renders as: 1 header row + 1 blank row + one or more
+ * wrapped content rows, followed by 1 blank spacing row.
+ */
+export function messageLineCount(content, maxWidth) {
+    const contentLines = content.split('\n');
+    let lines = 2; // Header + empty line after
+    for (const line of contentLines) {
+        lines += Math.ceil(Math.max(1, line.length) / maxWidth);
+    }
+    return lines + 1; // +1 for spacing between messages
+}
+/**
+ * Sum `messageLineCount` across a list of messages and return both the
+ * running total and the line offset where `targetIndex` begins. This is
+ * the pure core of the old `scrollToMessage` method.
+ */
+export function messageOffsets(contents, maxWidth, targetIndex) {
+    let totalLines = 0;
+    let targetStartLine = 0;
+    for (let i = 0; i < contents.length; i++) {
+        if (i === targetIndex)
+            targetStartLine = totalLines;
+        totalLines += messageLineCount(contents[i], maxWidth);
+    }
+    return { totalLines, targetStartLine };
+}
+/**
+ * Compute the scroll offset that places the target message roughly in
+ * the middle of the visible window.
+ */
+export function scrollOffsetForTarget(totalLines, targetStartLine, visibleLines) {
+    return Math.max(0, totalLines - targetStartLine - Math.floor(visibleLines / 2));
+}
+/**
+ * Compute the visible window of a chat transcript given the current scroll
+ * offset. Returns the [startIndex, endIndex) slice into the all-lines array
+ * and, as a side-effect contract, the clamped scroll offset the caller
+ * should store (the renderer overwrites `this.scrollOffset` with this).
+ *
+ * Extracted from `getVisibleMessages` so the off-by-one-prone scroll math
+ * has direct unit tests.
+ */
+export function scrollWindow(args) {
+    const maxScroll = Math.max(0, args.totalLines - args.height);
+    const clampedScrollOffset = Math.min(args.scrollOffset, maxScroll);
+    const endIndex = args.totalLines - clampedScrollOffset;
+    const startIndex = Math.max(0, endIndex - args.height);
+    return { startIndex, endIndex, clampedScrollOffset };
+}
+// ─── Agent progress bar ───────────────────────────────────────────────────────
+//
+// `renderInlineAgentProgress` builds a gradient progress bar from block
+// characters (░▒▓█) when the agent has a known iteration budget. The bar
+// construction is pure string math; extracting it makes the gradient
+// thresholds testable without a Screen mock.
+/** Render a gradient progress bar of the given width for the given ratio. */
+export function agentProgressBar(iteration, maxIterations, barWidth) {
+    // Avoid Infinity when maxIterations is 0 — show an empty bar instead.
+    const progress = maxIterations > 0 ? Math.min(iteration / maxIterations, 1) : 0;
+    const filled = Math.round(progress * barWidth);
+    let bar = '';
+    for (let i = 0; i < barWidth; i++) {
+        if (i < filled - 1)
+            bar += '█';
+        else if (i === filled - 1)
+            bar += '▓';
+        else if (i === filled)
+            bar += '▒';
+        else
+            bar += '░';
+    }
+    return bar;
+}
+// ─── Notification truncation ──────────────────────────────────────────────────
+//
+// `renderStatusBar` truncates the notification string to fit the terminal
+// width with an ellipsis. The truncation rule is pure.
+/** Truncate `text` to `maxLen` columns, appending an ellipsis if it doesn’t fit. */
+export function truncateNotification(text, maxLen) {
+    return text.length > maxLen ? text.slice(0, maxLen - 1) + '…' : text;
+}
+/** Threshold above which a paste is considered "large" and shows a dialog. */
+export const PASTE_DIALOG_THRESHOLD = { chars: 100, lines: 3 };
+/** True when the paste is large enough to warrant the confirm dialog. */
+export function shouldShowPasteDialog(text) {
+    const chars = text.length;
+    const lines = text.split('\n').length;
+    return chars >= PASTE_DIALOG_THRESHOLD.chars || lines > PASTE_DIALOG_THRESHOLD.lines;
+}
+/** Build the PasteInfo struct for a large paste (preview truncated to 200 chars). */
+export function buildPasteInfo(text) {
+    const preview = text.length > 200 ? text.slice(0, 197) + '...' : text;
+    return {
+        chars: text.length,
+        lines: text.split('\n').length,
+        preview,
+        fullText: text,
+    };
+}
+// ─── Status-bar formatting ────────────────────────────────────────────────────
+//
+// Small pure helpers used by `renderStatusBar`. Extracted so the
+// formatting rules (token compacting, context-sensitive right hint) are
+// unit-testable instead of buried in a 60-line screen-painting method.
+/**
+ * Compact a raw token count into the short string shown in the status bar
+ * ("123", "1.2K", "12.3K"). Returns an empty string when tokens is 0 so
+ * the caller can omit the segment entirely.
+ */
+export function formatTokenCount(tokens) {
+    if (tokens <= 0)
+        return '';
+    if (tokens < 1000)
+        return String(tokens);
+    return (tokens / 1000).toFixed(1) + 'K';
+}
+/**
+ * Pick the context-sensitive hint shown at the right edge of the status
+ * bar. The "new messages below" badge takes priority when the user has
+ * scrolled up — otherwise the hint depends on whether work is in flight.
+ */
+export function statusBarRightHint(args) {
+    if (args.scrollOffset > 0 && args.unseenWhileScrolled > 0) {
+        return `↓ ${args.unseenWhileScrolled} new · PgDn `;
+    }
+    return args.isStreaming || args.isLoading ? 'Esc to stop ' : '/help · ↑↓ history ';
+}
+/**
+ * Return the highest-priority open panel. `chat` is the fallback when no
+ * panel is open. The order matches the if/else chain that used to live in
+ * `handleChatKey`.
+ */
+export function activePanel(s) {
+    if (s.pasteInfoOpen)
+        return 'pasteInfo';
+    if (s.permissionOpen)
+        return 'permission';
+    if (s.sessionPickerOpen)
+        return 'sessionPicker';
+    if (s.confirmOpen)
+        return 'confirm';
+    if (s.statusOpen)
+        return 'status';
+    if (s.helpOpen)
+        return 'help';
+    if (s.settingsOpen)
+        return 'settings';
+    if (s.searchOpen)
+        return 'search';
+    if (s.exportOpen)
+        return 'export';
+    if (s.logoutOpen)
+        return 'logout';
+    if (s.loginOpen)
+        return 'login';
+    if (s.menuOpen)
+        return 'menu';
+    if (s.showAutocomplete)
+        return 'autocomplete';
+    return 'chat';
+}
+// ─── Input-line display ───────────────────────────────────────────────────────
+//
+// `renderInput` builds the text and cursor position for the bottom input
+// row. The geometry (which slice of a long line to show, where the cursor
+// lands within that slice, how the prompt symbol scales with multi-line
+// mode) is pure and was previously inlined alongside screen-write calls.
+// Extracting it makes the truncation/scroll behaviour unit-testable.
+/** Multiplier that controls how far from the left edge the cursor sits. */
+const INPUT_CURSOR_ANCHOR = 0.7;
+/**
+ * Compute the prompt symbol for the current state. Multi-line content
+ * shows a `[n] ❯ ` prefix with the line count; otherwise `❯❯ ` in
+ * multi-line mode, or the plain `❯ `.
+ */
+export function inputPromptSymbol(value, isMultilineMode) {
+    const lineCount = value.split('\n').length;
+    if (lineCount > 1)
+        return `[${lineCount}] ❯ `;
+    return isMultilineMode ? '❯❯ ' : '❯ ';
+}
+/**
+ * Compute the visible slice of a long input line, plus the cursor column
+ * it maps to. Mirrors the inline logic that used to live in `renderInput`:
+ * when the line fits, show it whole; otherwise anchor the cursor at 70%
+ * of the available width and slide the viewport.
+ */
+export function inputViewport(args) {
+    const { line, cursorInLine, maxInputWidth } = args;
+    if (line.length <= maxInputWidth) {
+        return { displayValue: line, cursorOffset: Math.max(0, cursorInLine) };
+    }
+    const effectiveCursor = Math.max(0, cursorInLine);
+    const visibleStart = Math.max(0, effectiveCursor - Math.floor(maxInputWidth * INPUT_CURSOR_ANCHOR));
+    const visibleEnd = visibleStart + maxInputWidth;
+    let displayValue;
+    if (visibleStart > 0) {
+        displayValue = '…' + line.slice(visibleStart + 1, visibleEnd);
+    }
+    else {
+        displayValue = line.slice(0, maxInputWidth);
+    }
+    return { displayValue, cursorOffset: effectiveCursor - visibleStart };
+}
+/**
+ * Top-level entry point used by `renderInput`. Produces the prompt symbol,
+ * the visible text, the absolute cursor X, and the placeholder.
+ */
+export function computeInputDisplay(opts) {
+    const promptSymbol = inputPromptSymbol(opts.value, opts.isMultilineMode);
+    const maxInputWidth = opts.width - promptSymbol.length - 1;
+    const isEmpty = opts.value.length === 0;
+    const placeholder = opts.isMultilineMode
+        ? 'Multi-line mode  Enter=newline · Esc=send'
+        : 'Message or /command';
+    if (isEmpty) {
+        return {
+            promptSymbol,
+            displayValue: '',
+            cursorX: promptSymbol.length,
+            placeholder,
+            isEmpty,
+        };
+    }
+    // For multi-line content, show the last line being edited.
+    const lines = opts.value.split('\n');
+    const lineCount = lines.length;
+    const lastLine = lines[lines.length - 1];
+    const displayInput = lineCount > 1 ? lastLine : opts.value;
+    const charsBeforeLastLine = lineCount > 1 ? opts.value.lastIndexOf('\n') + 1 : 0;
+    const cursorInLine = opts.cursorPos - charsBeforeLastLine;
+    const { displayValue, cursorOffset } = inputViewport({
+        line: displayInput,
+        cursorInLine,
+        maxInputWidth,
+    });
+    return {
+        promptSymbol,
+        displayValue,
+        cursorX: promptSymbol.length + cursorOffset,
+        placeholder,
+        isEmpty,
+    };
+}

package/dist/renderer/main.d.ts

@@ -5,4 +5,5 @@
  * This file contains only startup/init logic. Command dispatch lives in
  * commands.ts and agent execution in agentExecution.ts.
  */
-export {};
+/** Derive a short display name from a user message (first ~5 words, max 48 chars). */
+export declare function deriveSessionName(message: string): string;

package/dist/renderer/main.js

@@ -33,7 +33,7 @@ let app;
 let sessionDisplayName = null;
 const addedFiles = new Map();
 /** Derive a short display name from a user message (first ~5 words, max 48 chars). */
-function deriveSessionName(message) {
+export function deriveSessionName(message) {
     const clean = message.replace(/\s+/g, ' ').trim();
     const words = clean.split(' ').slice(0, 5).join(' ');
     return words.length > 48 ? words.slice(0, 45) + '…' : words;
@@ -706,18 +706,53 @@ Commands (in chat):
     if (projectPath) {
         (async () => {
             try {
-                const { loadMcpServerConfig } = await import('../utils/mcpConfig.js');
+                const { loadMcpServerConfigSplit, isWorkspaceMcpTrusted, trustWorkspaceMcp } = await import('../utils/mcpConfig.js');
                 const { registerSessionServers } = await import('../utils/mcpRegistry.js');
-                const servers = loadMcpServerConfig(projectPath);
-                if (servers.length === 0)
+                const { global: globalServers, workspace: workspaceServers } = loadMcpServerConfigSplit(projectPath);
+                const spawnServers = async (servers) => {
+                    if (servers.length === 0)
+                        return;
+                    const { registered, errors } = await registerSessionServers('codeep-tui', servers, { workspaceRoot: projectPath });
+                    if (registered.length > 0) {
+                        app.notify(`MCP: ${registered.length} tool(s) from ${servers.length} server(s) ready. Type /mcp.`);
+                    }
+                    for (const e of errors) {
+                        app.notifyWarn(`MCP server "${e.server}" failed: ${e.error}`);
+                    }
+                };
+                // ~/.codeep servers are the user's own machine-wide config — spawn.
+                await spawnServers(globalServers);
+                // Workspace files (.codeep/mcp_servers.json, .mcp.json) travel WITH
+                // the repo — a cloned project could otherwise execute arbitrary
+                // commands at startup. One-time per-workspace approval, mirroring
+                // the trustedHookProjects gate for hooks.
+                if (workspaceServers.length === 0)
+                    return;
+                if (isWorkspaceMcpTrusted(projectPath)) {
+                    await spawnServers(workspaceServers);
                     return;
-                const { registered, errors } = await registerSessionServers('codeep-tui', servers, { workspaceRoot: projectPath });
-                if (registered.length > 0) {
-                    app.notify(`MCP: ${registered.length} tool(s) from ${servers.length} server(s) ready. Type /mcp.`);
-                }
-                for (const e of errors) {
-                    app.notifyWarn(`MCP server "${e.server}" failed: ${e.error}`);
                 }
+                const preview = workspaceServers.slice(0, 5).map(s => `  ${s.name}: ${s.command ? [s.command, ...(s.args ?? [])].join(' ') : s.url ?? ''}`);
+                if (workspaceServers.length > 5)
+                    preview.push(`  …and ${workspaceServers.length - 5} more`);
+                app.showConfirm({
+                    title: 'Trust workspace MCP servers?',
+                    message: [
+                        `This workspace defines ${workspaceServers.length} MCP server(s) that run as local processes:`,
+                        ...preview,
+                        '',
+                        'Only start them if you trust this repo — they run with your permissions.',
+                    ],
+                    confirmLabel: 'Trust & start',
+                    cancelLabel: 'Not now',
+                    onConfirm: () => {
+                        trustWorkspaceMcp(projectPath);
+                        void spawnServers(workspaceServers);
+                    },
+                    onCancel: () => {
+                        app.notify('Workspace MCP servers skipped. Run /mcp trust to enable them.');
+                    },
+                });
             }
             catch {
                 // Loading MCP must never block the TUI.

package/dist/renderer/ollamaHint.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Return a UI hint for an Ollama model id, based on its parameter count.
+ *
+ * Examples:
+ *   - `7b`, `8b`, `14b`, `72b` → `'✓ agent mode'`
+ *   - `1.5b`, `3b`            → `'⚠ chat only (< 7B)'`
+ *   - `custom-name` (no size) → `''` (no hint)
+ *
+ * The parameter count is parsed from the first `<number>b` token in the
+ * id (case-insensitive), so both `qwen3:14b` and `llama2-13b` work.
+ */
+export declare function ollamaModelHint(modelId: string): string;

package/dist/renderer/ollamaHint.js

@@ -0,0 +1,29 @@
+/**
+ * Ollama model-size hint.
+ *
+ * Extracted from `commands.ts` so the size threshold + label rule can be
+ * unit-tested. Maps a model id like `qwen3:14b` to a UI hint telling the
+ * user whether the model is agent-capable (≥ 7B params) or chat-only.
+ */
+const AGENT_MIN_PARAMS_B = 7;
+/**
+ * Return a UI hint for an Ollama model id, based on its parameter count.
+ *
+ * Examples:
+ *   - `7b`, `8b`, `14b`, `72b` → `'✓ agent mode'`
+ *   - `1.5b`, `3b`            → `'⚠ chat only (< 7B)'`
+ *   - `custom-name` (no size) → `''` (no hint)
+ *
+ * The parameter count is parsed from the first `<number>b` token in the
+ * id (case-insensitive), so both `qwen3:14b` and `llama2-13b` work.
+ */
+export function ollamaModelHint(modelId) {
+    const lower = modelId.toLowerCase();
+    const match = lower.match(/(\d+(?:\.\d+)?)b/);
+    if (!match)
+        return '';
+    const params = parseFloat(match[1]);
+    if (params >= AGENT_MIN_PARAMS_B)
+        return '✓ agent mode';
+    return '⚠ chat only (< 7B)';
+}

package/dist/utils/agentChat.js

@@ -43,15 +43,37 @@ export class TimeoutError extends Error {
  * Load project rules from .codeep/rules.md or CODEEP.md
  */
 export function loadProjectRules(projectRoot) {
+    // Lookup precedence (highest first):
+    //   1. .codeep/rules.md  — Codeep-native, committed with the repo
+    //   2. CODEEP.md         — Codeep-native, root-level convenience
+    //   3. AGENTS.md         — cross-tool standard (Claude Code, Cursor,
+    //                          Kilo Code). Read so users coming from those
+    //                          tools don't have to duplicate their rules.
+    //
+    // First non-empty file wins. We deliberately don't concatenate: when two
+    // files exist, the Codeep-native one is authoritative (a user who keeps
+    // both probably has a trimmed AGENTS.md for the other tools and a richer
+    // CODEEP-specific rules file here).
     const candidates = [
         join(projectRoot, '.codeep', 'rules.md'),
         join(projectRoot, 'CODEEP.md'),
+        join(projectRoot, 'AGENTS.md'),
     ];
+    // Rules ride EVERY system prompt, so cap the injected size — an oversized
+    // file (AGENTS.md files from other tools can grow unbounded) would bloat
+    // every request's token bill and can push small-context models over their
+    // limit. 64KB ≈ 16k tokens is far above any sane rules file.
+    const MAX_RULES_BYTES = 64 * 1024;
     for (const filePath of candidates) {
         if (existsSync(filePath)) {
             try {
-                const content = readFileSync(filePath, 'utf-8').trim();
+                let content = readFileSync(filePath, 'utf-8').trim();
                 if (content) {
+                    if (content.length > MAX_RULES_BYTES) {
+                        debug('Project rules truncated', filePath, `${content.length} > ${MAX_RULES_BYTES}`);
+                        content = content.slice(0, MAX_RULES_BYTES)
+                            + '\n\n[Rules truncated by Codeep — file exceeds the 64KB inline limit.]';
+                    }
                     debug('Loaded project rules from', filePath);
                     return `\n\n## Project Rules\nThe following rules are defined by the project owner. You MUST follow these rules:\n\n${content}`;
                 }

package/dist/utils/codeepCloud.d.ts

@@ -77,6 +77,13 @@ export declare function pushKeys(keys: Record<string, string>): Promise<boolean>
  * later wants them off the server. Returns true on success.
  */
 export declare function purgeKeys(): Promise<boolean>;
+declare function globalDir(kind: 'personalities' | 'commands'): string;
+/** Read every <name>.md in a global config dir into a { name → body } map. */
+declare function readFileBundle(kind: 'personalities' | 'commands'): Record<string, string>;
+/** Write a { name → body } map into a global config dir as <name>.md
+ *  files. Only writes files that don't already exist (additive merge —
+ *  never clobber local edits). Returns the count of newly written files. */
+declare function writeFileBundle(kind: 'personalities' | 'commands', items: Record<string, string>): number;
 export declare const pullPersonalities: () => Promise<number | null>;
 export declare const pushPersonalities: () => Promise<number | null>;
 export declare const pullCommands: () => Promise<number | null>;
@@ -106,6 +113,49 @@ export declare function syncSessionAsync(payload: {
         content: string;
     }[];
 }): Promise<void>;
+/** Summary of a remote session — no messages, just metadata for listing. */
+export interface CloudSessionSummary {
+    sessionId: string;
+    sessionName: string | null;
+    projectName: string | null;
+    projectId: string | null;
+    messageCount: number;
+    updatedAt: string;
+}
+/** Full remote session — messages included (fetched on demand by id). */
+export interface CloudSession extends CloudSessionSummary {
+    messages: {
+        role: string;
+        content: string;
+    }[];
+}
+/**
+ * List the user's cloud sessions (summaries only — no message bodies).
+ *
+ * The server supports three scopes via the `projectId` query param:
+ *   - omitted    → all sessions for the user
+ *   - "none"     → only personal (no-project) sessions
+ *   - <id>       → sessions scoped to that project
+ *
+ * Returns null if not linked or on network/server error. The caller decides
+ * how to surface that (silently skip vs. notify).
+ *
+ * `telemetry` is NOT consulted here — reading your own previously-pushed
+ * data back is not telemetry, and the user is explicitly asking for it
+ * (via /cloud). The original push was already gated.
+ */
+export declare function listCloudSessions(projectId?: string): Promise<CloudSessionSummary[] | null>;
+/**
+ * Fetch a single cloud session by id, including the full message array.
+ *
+ * Used by `/cloud` → pick → resume: we pull the messages and write them
+ * into the local `.codeep/sessions/` store via `saveSession`, so the
+ * resumed session behaves identically to a locally-created one (shows
+ * up in `/sessions`, survives restarts, re-syncs on next change).
+ *
+ * Returns null if not linked, not found (404), or network/server error.
+ */
+export declare function pullCloudSession(sessionId: string): Promise<CloudSession | null>;
 /**
  * Sync progress.md content to codeep.dev.
  * Fire-and-forget. Only sends if linked (githubId + syncToken).
@@ -128,3 +178,7 @@ export declare function pushUserProfile(): Promise<boolean>;
  *  exists. Returns 1 if written, 0 if skipped, null on error / not linked. */
 export declare function pullUserProfile(): Promise<number | null>;
 export declare function syncMemoryNotes(projectName: string, notes: string[]): Promise<void>;
+export declare const _globalDirForTest: typeof globalDir;
+export declare const _readFileBundleForTest: typeof readFileBundle;
+export declare const _writeFileBundleForTest: typeof writeFileBundle;
+export {};

package/dist/utils/codeepCloud.js

@@ -372,6 +372,95 @@ export async function syncSessionAsync(payload) {
         body: JSON.stringify({ ...payload, messages: filtered, githubId }),
     });
 }
+/**
+ * List the user's cloud sessions (summaries only — no message bodies).
+ *
+ * The server supports three scopes via the `projectId` query param:
+ *   - omitted    → all sessions for the user
+ *   - "none"     → only personal (no-project) sessions
+ *   - <id>       → sessions scoped to that project
+ *
+ * Returns null if not linked or on network/server error. The caller decides
+ * how to surface that (silently skip vs. notify).
+ *
+ * `telemetry` is NOT consulted here — reading your own previously-pushed
+ * data back is not telemetry, and the user is explicitly asking for it
+ * (via /cloud). The original push was already gated.
+ */
+export async function listCloudSessions(projectId) {
+    const syncToken = getSyncToken();
+    if (!syncToken)
+        return null;
+    const url = new URL(`${API_BASE}/api/sessions`);
+    if (projectId)
+        url.searchParams.set('projectId', projectId);
+    try {
+        const res = await fetch(url.toString(), {
+            headers: { 'x-sync-token': syncToken },
+        });
+        if (!res.ok)
+            return null;
+        // Server responses are untrusted input — validate the shape instead of
+        // casting, so a malformed/hostile payload degrades to null (the normal
+        // "unavailable" path) rather than throwing deep inside the /cloud picker.
+        // Note `!== true` + Array.isArray also normalizes an absent field to
+        // null (a bare `data.ok ? … : null` would leak `undefined` past the
+        // caller's `=== null` check).
+        const data = await res.json();
+        if (data?.ok !== true || !Array.isArray(data.sessions))
+            return null;
+        return data.sessions.filter((s) => {
+            const c = s;
+            return !!c && typeof c === 'object' && typeof c.sessionId === 'string' && c.sessionId.length > 0;
+        });
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Fetch a single cloud session by id, including the full message array.
+ *
+ * Used by `/cloud` → pick → resume: we pull the messages and write them
+ * into the local `.codeep/sessions/` store via `saveSession`, so the
+ * resumed session behaves identically to a locally-created one (shows
+ * up in `/sessions`, survives restarts, re-syncs on next change).
+ *
+ * Returns null if not linked, not found (404), or network/server error.
+ */
+export async function pullCloudSession(sessionId) {
+    const syncToken = getSyncToken();
+    if (!syncToken)
+        return null;
+    try {
+        const url = new URL(`${API_BASE}/api/sessions`);
+        url.searchParams.set('id', sessionId);
+        const res = await fetch(url.toString(), {
+            headers: { 'x-sync-token': syncToken },
+        });
+        if (!res.ok)
+            return null;
+        // Untrusted input — validate before it flows into the local session
+        // store. Messages are filtered to well-formed {role, content} string
+        // pairs; anything else is dropped rather than persisted.
+        const data = await res.json();
+        if (data?.ok !== true || !data.session || typeof data.session !== 'object')
+            return null;
+        const s = data.session;
+        if (typeof s.sessionId !== 'string' || s.sessionId.length === 0)
+            return null;
+        if (!Array.isArray(s.messages))
+            return null;
+        const messages = s.messages.filter((m) => {
+            const c = m;
+            return !!c && typeof c === 'object' && typeof c.role === 'string' && typeof c.content === 'string';
+        });
+        return { ...s, messages };
+    }
+    catch {
+        return null;
+    }
+}
 // ─── Progress log sync ────────────────────────────────────────────────────────
 /**
  * Sync progress.md content to codeep.dev.
@@ -549,3 +638,9 @@ async function fetchWithRetry(url, options, maxRetries = 2) {
     }
     return null;
 }
+// Test seams — these helpers are otherwise file-private; export them under
+// a `_forTest` suffix so the bundle read/write logic can be exercised
+// directly without going through the network round-trip.
+export const _globalDirForTest = globalDir;
+export const _readFileBundleForTest = readFileBundle;
+export const _writeFileBundleForTest = writeFileBundle;