@deepseek-harness-tui/dsh-tui 0.11.1 → 0.12.0

package/lib/types/dsh-adapter/migrate/adapters/zcode.js

@@ -0,0 +1,93 @@
+/**
+ * zcode adapter: `~/.zcode/v2/sessions/<dir>/<taskId>.json`, one JSON object
+ * per conversation. Discovery lives here; the document is parsed by the pure
+ * zcode.parse.ts. A JSON document has no usable head, so the browse scan
+ * parses each changed file whole (they are small; unchanged ones are reused
+ * by fingerprint).
+ *
+ * @module @deepseek-harness-tui/dsh-tui/migrate/adapters/zcode
+ */
+import { readdirSync, readFileSync, statSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { countEntries } from './scan.js';
+import { fingerprintOf, loadText, runScan, walkFiles } from './scan-fs.js';
+import { parseZcodeSession } from './zcode.parse.js';
+const WALK = { maxDepth: 3, match: name => name.endsWith('.json') };
+async function summarize({ ref, fp }) {
+    const raw = await loadText(ref);
+    const session = typeof raw === 'string' ? parseZcodeSession(raw) : undefined;
+    if (session === undefined)
+        return null;
+    return {
+        agentId: 'zcode',
+        sessionKey: session.sourceId,
+        ref,
+        title: session.title ?? '',
+        cwd: session.cwd,
+        lastMessageAt: fp.mtimeMs,
+        createdAt: session.startedAt || fp.mtimeMs,
+    };
+}
+function readOne(path) {
+    try {
+        return parseZcodeSession(readFileSync(path, 'utf8'));
+    }
+    catch {
+        return undefined;
+    }
+}
+export const zcodeAdapter = {
+    id: 'zcode',
+    label: 'zcode',
+    roots: () => [join(homedir(), '.zcode', 'v2', 'sessions')],
+    discover() {
+        const roots = this.roots();
+        const sessions = [];
+        const walk = (dir, depth) => {
+            if (depth > 3)
+                return;
+            let entries;
+            try {
+                entries = readdirSync(dir, { withFileTypes: true });
+            }
+            catch {
+                return;
+            }
+            for (const entry of entries) {
+                const path = join(dir, entry.name);
+                if (entry.isDirectory())
+                    walk(path, depth + 1);
+                else if (entry.isFile() && entry.name.endsWith('.json')) {
+                    try {
+                        if (statSync(path).size > 64 * 1024 * 1024)
+                            continue;
+                    }
+                    catch {
+                        continue;
+                    }
+                    const session = readOne(path);
+                    if (session !== undefined)
+                        sessions.push(session);
+                }
+            }
+        };
+        for (const root of roots)
+            walk(root, 0);
+        return { roots, sessions };
+    },
+    count() {
+        return countEntries(this.roots(), { maxDepth: WALK.maxDepth, fileMatch: WALK.match });
+    },
+    walk: WALK,
+    async scan(options) {
+        const files = walkFiles(this.roots(), { ...WALK, signal: options?.signal });
+        return runScan(files, file => file.path, fingerprintOf, options, summarize);
+    },
+    async load(ref) {
+        const raw = await loadText(ref);
+        if (typeof raw !== 'string')
+            return raw;
+        return parseZcodeSession(raw) ?? { skip: 'not-a-session' };
+    },
+};

package/lib/types/dsh-adapter/migrate/adapters/zcode.parse.d.ts

@@ -0,0 +1,9 @@
+import type { MigrationSession } from '../types.js';
+/**
+ * Parse one zcode session document.
+ * @returns The session, or undefined when the document is not a
+ *   `{ meta, messages }` object with a task id and workspace, or holds no
+ *   prompt.
+ */
+export declare function parseZcodeSession(raw: string): MigrationSession | undefined;
+//# sourceMappingURL=zcode.parse.d.ts.map

package/lib/types/dsh-adapter/migrate/adapters/zcode.parse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"zcode.parse.d.ts","sourceRoot":"","sources":["../../../../../src/dsh-adapter/migrate/adapters/zcode.parse.ts"],"names":[],"mappings":"AAgBA,OAAO,KAAK,EAAc,gBAAgB,EAAE,MAAM,aAAa,CAAA;AAE/D;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,MAAM,GAAG,gBAAgB,GAAG,SAAS,CAwD3E"}

package/lib/types/dsh-adapter/migrate/adapters/zcode.parse.js

@@ -0,0 +1,89 @@
+/**
+ * zcode session parsing (pure): one `<taskId>.json` → one
+ * {@link MigrationSession}.
+ *
+ * One JSON object per conversation (`{ meta, messages }`) with plain-string
+ * contents and epoch-millisecond timestamps. Only the text roles are mapped:
+ * no sample of this store with tool traffic or reasoning has been available,
+ * so no such field is guessed at.
+ *
+ * @module @deepseek-harness-tui/dsh-tui/migrate/adapters/zcode.parse
+ */
+import { isInjectedText, unwrapUserText } from '../parse/injection.js';
+import { isRecord } from '../parse/jsonl.js';
+import { emptyStats } from '../parse/role-turns.js';
+import { normalizeTitle } from '../parse/title.js';
+import { newStep } from '../parse/tools.js';
+/**
+ * Parse one zcode session document.
+ * @returns The session, or undefined when the document is not a
+ *   `{ meta, messages }` object with a task id and workspace, or holds no
+ *   prompt.
+ */
+export function parseZcodeSession(raw) {
+    let doc;
+    try {
+        doc = JSON.parse(raw);
+    }
+    catch {
+        return undefined;
+    }
+    if (!isRecord(doc) || !isRecord(doc.meta) || !Array.isArray(doc.messages))
+        return undefined;
+    const { taskId, workspacePath, title, createdAt } = doc.meta;
+    if (typeof taskId !== 'string' || taskId === '')
+        return undefined;
+    if (typeof workspacePath !== 'string' || workspacePath === '')
+        return undefined;
+    const stats = emptyStats();
+    let turns = [];
+    let current;
+    let firstTime = 0;
+    for (const message of doc.messages) {
+        if (!isRecord(message))
+            continue;
+        if (message.role !== 'user' && message.role !== 'assistant')
+            continue;
+        if (typeof message.content !== 'string' || message.content === '')
+            continue;
+        if (firstTime === 0 && typeof message.timestamp === 'number')
+            firstTime = message.timestamp;
+        if (message.role === 'user') {
+            // Shared injection rules: harness blocks open no turn, wrappers keep
+            // only the human words.
+            if (isInjectedText(message.content)) {
+                stats.filtered += 1;
+                continue;
+            }
+            const prompt = unwrapUserText(message.content);
+            if (prompt === '')
+                continue;
+            current = { prompt, steps: [] };
+            turns.push(current);
+            continue;
+        }
+        if (current === undefined) {
+            current = { prompt: '', steps: [] };
+            turns.push(current);
+        }
+        const step = newStep();
+        step.blocks.push({ type: 'text', text: message.content });
+        current.steps.push(step);
+    }
+    turns = turns.filter(turn => turn.prompt !== '' || turn.steps.length > 0);
+    if (turns.length === 0)
+        return undefined;
+    // meta.title is the store's own title (written to the log); the first real
+    // prompt is only a fallback.
+    const ownTitle = normalizeTitle(typeof title === 'string' ? title : undefined);
+    const shownTitle = ownTitle !== '' ? ownTitle : normalizeTitle(turns.find(turn => turn.prompt !== '')?.prompt);
+    return {
+        sourceId: taskId,
+        cwd: workspacePath,
+        ...(shownTitle === '' ? {} : { title: shownTitle }),
+        titleExplicit: ownTitle !== '',
+        startedAt: typeof createdAt === 'number' ? createdAt : firstTime,
+        turns,
+        stats,
+    };
+}

package/lib/types/dsh-adapter/migrate/bin-path.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Resolve `bin/dsh-tui.js` for the package that contains `fromDir`, or
+ * undefined when no ancestor within the probe bound carries it.
+ */
+export declare function resolveOwnBin(fromDir: string): string | undefined;
+//# sourceMappingURL=bin-path.d.ts.map

package/lib/types/dsh-adapter/migrate/bin-path.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bin-path.d.ts","sourceRoot":"","sources":["../../../../src/dsh-adapter/migrate/bin-path.ts"],"names":[],"mappings":"AAoBA;;;GAGG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAMjE"}

package/lib/types/dsh-adapter/migrate/bin-path.js

@@ -0,0 +1,30 @@
+/**
+ * Locate this package's `bin/dsh-tui.js` from a module directory inside it.
+ *
+ * The TUI's `/migrate` spawns the CLI through the package bin so the import
+ * runs in a child process. Callers live at DIFFERENT depths per layout:
+ * `src/screens/` at dev time (three levels), `lib/types/screens/` when
+ * installed (four levels) — a fixed dirname count lands inside the tree and
+ * the spawn fails on every real install (the regression the probe-up walk
+ * below replaces; found by the independent test session on a real profile).
+ * Probing upward for `bin/dsh-tui.js` matches both layouts without knowing
+ * which one we are in — the same spirit as src/update.ts's manifest walk.
+ *
+ * @module @deepseek-harness-tui/dsh-tui/migrate/bin-path
+ */
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+/** Upward probe bounds: covers src/screens and lib/types/screens layouts. */
+const PROBE_UP = ['..', '../..', '../../..', '../../../..'];
+/**
+ * Resolve `bin/dsh-tui.js` for the package that contains `fromDir`, or
+ * undefined when no ancestor within the probe bound carries it.
+ */
+export function resolveOwnBin(fromDir) {
+    for (const up of PROBE_UP) {
+        const candidate = join(fromDir, up, 'bin', 'dsh-tui.js');
+        if (existsSync(candidate))
+            return candidate;
+    }
+    return undefined;
+}

package/lib/types/dsh-adapter/migrate/browse.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Browsing other coding agents' conversations for the session screen's source
+ * tabs: which agents have any, what they are, and importing one.
+ *
+ * Everything that knows how a foreign agent stores its conversations stays in
+ * this directory. The channel forwards these three calls unchanged, and the UI
+ * sees rows whose `key` it only hands back — never a path, a fingerprint or a
+ * source id.
+ *
+ * Nothing is persisted, and the cost is paid only by the tab that needs it:
+ * - opening the session screen probes presence alone — each source's walk
+ *   stops at its first candidate, a handful of directory reads;
+ * - a source is listed when its tab is opened, and within this run an
+ *   unchanged conversation (same mtime and size) is not read a second time.
+ *
+ * @module @deepseek-harness-tui/dsh-tui/migrate/browse
+ */
+import type { ForeignImportOutcome, ForeignSessionRow, ForeignSource } from '../../adapter/ports/channel-session.js';
+import type { MigrationAdapter } from './types.js';
+/** Whether an adapter can be browsed (summary scan + full load). */
+export declare function isBrowsable(adapter: MigrationAdapter): boolean;
+/**
+ * The browser behind one channel.
+ * @param persistence - The host's session persistence (imports go through it,
+ *   so an imported session is immediately visible to resume).
+ * @param signal - Aborts in-flight walks when the channel is torn down.
+ * @param adapters - Every registered adapter; only browsable ones are used.
+ */
+export declare function createForeignBrowser(persistence: () => unknown, signal?: AbortSignal, adapters?: readonly MigrationAdapter[]): {
+    /** Sources with at least one candidate, in registry order. */
+    listSources(): Promise<readonly ForeignSource[]>;
+    /**
+     * One source's conversations, newest first. A listing superseded by a
+     * newer one of the same source resolves to what is known, without
+     * publishing its own result.
+     */
+    listSessions(agentId: string, onRow?: (row: ForeignSessionRow) => void): Promise<readonly ForeignSessionRow[]>;
+    /** Import one listed conversation (or find the copy already imported). */
+    importSession(agentId: string, key: string): Promise<ForeignImportOutcome>;
+};
+export type ForeignBrowser = ReturnType<typeof createForeignBrowser>;
+//# sourceMappingURL=browse.d.ts.map

package/lib/types/dsh-adapter/migrate/browse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"browse.d.ts","sourceRoot":"","sources":["../../../../src/dsh-adapter/migrate/browse.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AACH,OAAO,KAAK,EAAE,oBAAoB,EAAE,iBAAiB,EAAE,aAAa,EAAE,MAAM,wCAAwC,CAAA;AAIpH,OAAO,KAAK,EAAsC,gBAAgB,EAAE,MAAM,YAAY,CAAA;AAStF,oEAAoE;AACpE,wBAAgB,WAAW,CAAC,OAAO,EAAE,gBAAgB,GAAG,OAAO,CAE9D;AAUD;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAClC,WAAW,EAAE,MAAM,OAAO,EAC1B,MAAM,CAAC,EAAE,WAAW,EACpB,QAAQ,GAAE,SAAS,gBAAgB,EAAuB;IAqBxD,8DAA8D;mBACzC,OAAO,CAAC,SAAS,aAAa,EAAE,CAAC;IAKtD;;;;OAIG;0BACyB,MAAM,UAAU,CAAC,GAAG,EAAE,iBAAiB,KAAK,IAAI,GAAG,OAAO,CAAC,SAAS,iBAAiB,EAAE,CAAC;IA2BpH,0EAA0E;2BACnD,MAAM,OAAO,MAAM,GAAG,OAAO,CAAC,oBAAoB,CAAC;EAS7E;AAED,MAAM,MAAM,cAAc,GAAG,UAAU,CAAC,OAAO,oBAAoB,CAAC,CAAA"}

package/lib/types/dsh-adapter/migrate/browse.js

@@ -0,0 +1,90 @@
+import { walkFiles } from './adapters/scan-fs.js';
+import { createForeignImporter } from './import-one.js';
+import { MIGRATION_ADAPTERS } from './index.js';
+/** Whether an adapter can be browsed (summary scan + full load). */
+export function isBrowsable(adapter) {
+    return adapter.walk !== undefined && adapter.scan !== undefined && adapter.load !== undefined;
+}
+const isAbort = (error) => error instanceof Error && error.name === 'AbortError';
+const newestFirst = (a, b) => b.updatedAt - a.updatedAt;
+function toRow(summary) {
+    return { agentId: summary.agentId, key: summary.ref, title: summary.title, cwd: summary.cwd, updatedAt: summary.lastMessageAt };
+}
+/**
+ * The browser behind one channel.
+ * @param persistence - The host's session persistence (imports go through it,
+ *   so an imported session is immediately visible to resume).
+ * @param signal - Aborts in-flight walks when the channel is torn down.
+ * @param adapters - Every registered adapter; only browsable ones are used.
+ */
+export function createForeignBrowser(persistence, signal, adapters = MIGRATION_ADAPTERS) {
+    const browsable = adapters.filter(isBrowsable);
+    const known = new Map();
+    const generations = new Map();
+    const importer = createForeignImporter(() => persistence());
+    const adapterOf = (agentId) => browsable.find(adapter => adapter.id === agentId);
+    const rowsOf = (agentId) => {
+        const rows = [];
+        for (const entry of known.get(agentId)?.values() ?? [])
+            if (entry.summary !== null)
+                rows.push(toRow(entry.summary));
+        return rows.sort(newestFirst);
+    };
+    /** Whether a source has at least one candidate; the walk stops at the first. */
+    const hasCandidate = async (adapter) => {
+        for await (const _file of walkFiles(adapter.roots(), { ...adapter.walk, signal }))
+            return true;
+        return false;
+    };
+    return {
+        /** Sources with at least one candidate, in registry order. */
+        async listSources() {
+            const present = await Promise.all(browsable.map(adapter => hasCandidate(adapter).catch(() => false)));
+            return browsable.filter((_adapter, index) => present[index]).map(adapter => ({ agentId: adapter.id, label: adapter.label }));
+        },
+        /**
+         * One source's conversations, newest first. A listing superseded by a
+         * newer one of the same source resolves to what is known, without
+         * publishing its own result.
+         */
+        async listSessions(agentId, onRow) {
+            const adapter = adapterOf(agentId);
+            if (adapter === undefined)
+                return [];
+            const generation = (generations.get(agentId) ?? 0) + 1;
+            generations.set(agentId, generation);
+            const previous = known.get(agentId);
+            let scanned;
+            try {
+                scanned = await adapter.scan({
+                    signal,
+                    cached: (ref, fp) => {
+                        const entry = previous?.get(ref);
+                        return entry !== undefined && entry.fp.mtimeMs === fp.mtimeMs && entry.fp.size === fp.size ? entry.summary : undefined;
+                    },
+                    onEntry: onRow === undefined ? undefined : summary => onRow(toRow(summary)),
+                });
+            }
+            catch (error) {
+                // Channel teardown mid-walk: what is known stands.
+                if (isAbort(error))
+                    return rowsOf(agentId);
+                throw error;
+            }
+            if (generations.get(agentId) === generation) {
+                known.set(agentId, new Map(scanned.map(entry => [entry.ref, { fp: entry.fp, summary: entry.summary }])));
+            }
+            return rowsOf(agentId);
+        },
+        /** Import one listed conversation (or find the copy already imported). */
+        importSession(agentId, key) {
+            const adapter = adapterOf(agentId);
+            if (adapter === undefined)
+                return Promise.resolve({ kind: 'failed', reason: 'unknown-source' });
+            // A key this run never listed still imports: with no known identity the
+            // existence check misses, and the id is derived from what is loaded.
+            const summary = known.get(agentId)?.get(key)?.summary ?? undefined;
+            return importer.import(adapter, { sessionKey: summary?.sessionKey ?? '', ref: key, cwd: summary?.cwd ?? '' });
+        },
+    };
+}

package/lib/types/dsh-adapter/migrate/cli.d.ts

@@ -0,0 +1,9 @@
+/** Exit code for "nothing to do / unknown agent". */
+export declare const MIGRATE_CLI_USAGE_EXIT = 2;
+/**
+ * Run one migration CLI invocation.
+ * @param argv - Arguments after the `migrate` word.
+ * @returns Process exit code.
+ */
+export declare function cliMigrate(argv: readonly string[]): Promise<number>;
+//# sourceMappingURL=cli.d.ts.map

package/lib/types/dsh-adapter/migrate/cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../../../../src/dsh-adapter/migrate/cli.ts"],"names":[],"mappings":"AAwBA,qDAAqD;AACrD,eAAO,MAAM,sBAAsB,IAAI,CAAA;AAQvC;;;;GAIG;AACH,wBAAsB,UAAU,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,GAAG,OAAO,CAAC,MAAM,CAAC,CAUzE"}

package/lib/types/dsh-adapter/migrate/cli.js

@@ -0,0 +1,106 @@
+/**
+ * CLI surface for migration, reached via `dsh-tui migrate ...` (the bin
+ * launcher delegates here exactly like it delegates `update`; the TUI's
+ * `/migrate` command spawns this same CLI in a child process).
+ *
+ * Usage:
+ *   dsh-tui migrate                     # list agents and discoverable counts (writes nothing)
+ *   dsh-tui migrate <agent>             # import every conversation found from that agent
+ *   dsh-tui migrate <agent> --dry-run   # show what would land, write nothing
+ *
+ * One agent per run, and `--dry-run` always names one: both are usage errors
+ * rather than silent fallbacks, matching the TUI's `/migrate` entry points.
+ *
+ * Every string that originated OUTSIDE this machine (source ids, cwds, error
+ * text embedding them) passes through cleanRenderText before printing: a
+ * hostile session file must not be able to drive terminal escape sequences
+ * through the preview/report paths (deep-review M2).
+ *
+ * @module @deepseek-harness-tui/dsh-tui/migrate/cli
+ */
+import { cleanRenderText } from '../sanitize.js';
+import { messageCount } from './parse/role-turns.js';
+import { MIGRATION_ADAPTERS, defaultSessionRoot, importSessions } from './index.js';
+/** Exit code for "nothing to do / unknown agent". */
+export const MIGRATE_CLI_USAGE_EXIT = 2;
+/** Bound for one cleaned external string in CLI output (display cells). */
+const RENDER_CELL_BUDGET = 200;
+/** One external-origin string, sanitized to display-safe text. */
+const safe = (value) => cleanRenderText(value, RENDER_CELL_BUDGET);
+/**
+ * Run one migration CLI invocation.
+ * @param argv - Arguments after the `migrate` word.
+ * @returns Process exit code.
+ */
+export async function cliMigrate(argv) {
+    try {
+        return await cliMigrateInner(argv);
+    }
+    catch (error) {
+        // A top-level failure (e.g. persistence never becomes ready because the
+        // target root is unwritable) must land as one CLI-style summary line,
+        // not a bare Node stack trace (deep-review i1).
+        process.stderr.write(`dsh-tui migrate: ${error instanceof Error ? safe(error.message) : String(error)}\n`);
+        return 1;
+    }
+}
+async function cliMigrateInner(argv) {
+    const dryRun = argv.includes('--dry-run');
+    const words = argv.filter(word => word !== '--dry-run');
+    if (words.length > 1) {
+        process.stderr.write('usage: dsh-tui migrate [<agent>] [--dry-run]\n');
+        return MIGRATE_CLI_USAGE_EXIT;
+    }
+    const wanted = words[0];
+    if (wanted === undefined) {
+        // `--dry-run` previews ONE source, so it needs one named: without this the
+        // flag fell through to the listing below and was silently ignored (the
+        // TUI's `/migrate --dry-run` says the same thing).
+        if (dryRun) {
+            process.stderr.write('usage: dsh-tui migrate <agent> --dry-run\n');
+            return MIGRATE_CLI_USAGE_EXIT;
+        }
+        // Bare `migrate` only reports; importing requires an explicit agent.
+        for (const adapter of MIGRATION_ADAPTERS) {
+            // Name-only count when the adapter offers one: list mode must not pay
+            // a full parse of every foreign file (deep-review M3). The count is
+            // scan candidates; import filters unreadable/empty ones, so it may
+            // land slightly above the imported total.
+            const available = adapter.count !== undefined ? adapter.count() : adapter.discover().sessions.length;
+            console.log(`[${adapter.id}] ${available} session file(s) to scan (run \`dsh-tui migrate ${adapter.id}\` to import)`);
+        }
+        return 0;
+    }
+    const agent = MIGRATION_ADAPTERS.find(adapter => adapter.id === wanted);
+    if (agent === undefined) {
+        process.stderr.write(`dsh-tui migrate: unknown agent "${safe(wanted)}"; known: ${MIGRATION_ADAPTERS.map(adapter => adapter.id).join(', ')}\n`);
+        return MIGRATE_CLI_USAGE_EXIT;
+    }
+    const found = agent.discover();
+    if (found.sessions.length === 0) {
+        console.log(`[${agent.id}] no conversations found`);
+        return 0;
+    }
+    if (dryRun) {
+        console.log(`[${agent.id}] ${found.sessions.length} conversation(s) would be imported into ${defaultSessionRoot()} (dry run)`);
+        for (const session of found.sessions.slice(0, 5)) {
+            console.log(`  · ${safe(session.sourceId)}  (${messageCount(session)} messages · cwd ${safe(session.cwd)})`);
+        }
+        if (found.sessions.length > 5)
+            console.log(`  … and ${found.sessions.length - 5} more`);
+        return 0;
+    }
+    console.log(`[${agent.id}] importing ${found.sessions.length} conversation(s) into ${defaultSessionRoot()}`);
+    const run = await importSessions(agent, defaultSessionRoot(), found.sessions);
+    const parts = [`imported ${run.imported}`];
+    if (run.existing > 0)
+        parts.push(`already present ${run.existing}`);
+    if (run.failed > 0)
+        parts.push(`failed ${run.failed}`);
+    console.log(`[${agent.id}] ${parts.join(' · ')}`);
+    for (const failure of run.failures.slice(0, 10))
+        console.log(`  ✗ ${safe(failure)}`);
+    if (run.failures.length > 10)
+        console.log(`  … and ${run.failures.length - 10} more`);
+    return run.failed > 0 ? 1 : 0;
+}

package/lib/types/dsh-adapter/migrate/import-one.d.ts

@@ -0,0 +1,89 @@
+/**
+ * Import ONE foreign conversation through the host's persistence service —
+ * the session screen's "select to start" path (the CLI batch keeps
+ * importSessions, which mounts its own backend).
+ *
+ * Order is chosen so a failure never leaves a half-written log that the
+ * next click would take for "already imported":
+ *   1. the deterministic id already exists → open it, nothing is written;
+ *   2. the working directory must exist (resuming into a missing cwd fails
+ *      later and less clearly);
+ *   3. the whole conversation is parsed and sessionized in memory;
+ *   4. only then create → append → flush → close; a write failure removes
+ *      what was written, best effort — except a create that lost to a
+ *      concurrent writer of the same deterministic id: that log is the
+ *      winner's, and the import simply opens it.
+ *
+ * @module @deepseek-harness-tui/dsh-tui/migrate/import-one
+ */
+import { SessionId, type SessionEvent, type SessionHeader } from '@deepseek-ai/dsh-session';
+import type { LoadSkip, MigrationAdapter, MigrationSession } from './types.js';
+/** Structural slice of the persistence service a single import needs. */
+export interface ImportPersistence {
+    create(header: SessionHeader): Promise<ImportWriteHandle>;
+    /** Present on current backends: one session's snapshot, undefined when absent. */
+    stat?(id: SessionId): Promise<unknown>;
+    list(): Promise<readonly {
+        header: {
+            id: string;
+        };
+    }[]>;
+}
+export interface ImportWriteHandle {
+    append(events: readonly SessionEvent[]): Promise<void>;
+    flush(): Promise<void>;
+    close(): Promise<void>;
+}
+/** Outcome of one import request. */
+export type ForeignImportResult = {
+    readonly kind: 'ready';
+    readonly sessionId: string;
+    readonly created: boolean;
+} | {
+    readonly kind: 'cwd-missing';
+    readonly cwd: string;
+} | {
+    readonly kind: 'failed';
+    readonly reason: LoadSkip['skip'] | 'write-failed';
+    readonly detail?: string;
+};
+/** Deterministic DSH session id of one foreign conversation (same as /migrate). */
+export declare function foreignSessionId(agentId: string, sourceId: string): SessionId;
+/**
+ * Write one sessionized conversation (the CLI batch path; the single import
+ * phases create/append itself so a create race stays out of its cleanup).
+ * Both paths produce byte-identical logs: sessionize is deterministic in
+ * the id and the events.
+ */
+export declare function writeImportedSession(persistence: Pick<ImportPersistence, 'create'>, id: SessionId, agentId: string, session: MigrationSession): Promise<void>;
+export interface ImportRequest {
+    /** The listed conversation's stable source id (ForeignSessionSummary.sessionKey). */
+    readonly sessionKey: string;
+    readonly ref: string;
+    /** The listed cwd; '' when the summary did not know it. */
+    readonly cwd: string;
+}
+export interface ImportDeps {
+    readonly cwdExists?: (path: string) => boolean;
+    /** Best-effort removal of a partially written log. */
+    readonly discard?: (sessionId: string) => void;
+}
+/**
+ * Import one conversation unless it is already present.
+ * @returns ready (with whether it was written now), cwd-missing, or failed.
+ */
+export declare function importForeignSession(persistence: ImportPersistence, adapter: MigrationAdapter, request: ImportRequest, deps?: ImportDeps): Promise<ForeignImportResult>;
+/**
+ * One importer per host: a second request for a conversation already being
+ * imported joins the running one instead of starting another write.
+ *
+ * Requests are keyed by the conversation's IDENTITY (the id it will be written
+ * under), not by its locator: two artifacts of one source can carry the same
+ * source id (a Claude session continued in another project directory), and
+ * two concurrent writes to one id would have the loser's cleanup delete the
+ * winner's log. The locator is the key only when the identity is not known yet.
+ */
+export declare function createForeignImporter(persistence: () => ImportPersistence | undefined, deps?: ImportDeps): {
+    import(adapter: MigrationAdapter, request: ImportRequest): Promise<ForeignImportResult>;
+};
+//# sourceMappingURL=import-one.d.ts.map

package/lib/types/dsh-adapter/migrate/import-one.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"import-one.d.ts","sourceRoot":"","sources":["../../../../src/dsh-adapter/migrate/import-one.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,OAAO,EAAE,SAAS,EAAE,KAAK,YAAY,EAAE,KAAK,aAAa,EAAE,MAAM,0BAA0B,CAAA;AAI3F,OAAO,KAAK,EAAE,QAAQ,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAA;AAG9E,yEAAyE;AACzE,MAAM,WAAW,iBAAiB;IAChC,MAAM,CAAC,MAAM,EAAE,aAAa,GAAG,OAAO,CAAC,iBAAiB,CAAC,CAAA;IACzD,kFAAkF;IAClF,IAAI,CAAC,CAAC,EAAE,EAAE,SAAS,GAAG,OAAO,CAAC,OAAO,CAAC,CAAA;IACtC,IAAI,IAAI,OAAO,CAAC,SAAS;QAAE,MAAM,EAAE;YAAE,EAAE,EAAE,MAAM,CAAA;SAAE,CAAA;KAAE,EAAE,CAAC,CAAA;CACvD;AACD,MAAM,WAAW,iBAAiB;IAChC,MAAM,CAAC,MAAM,EAAE,SAAS,YAAY,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IACtD,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAA;IACtB,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAA;CACvB;AAED,qCAAqC;AACrC,MAAM,MAAM,mBAAmB,GAC3B;IAAE,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAA;CAAE,GACjF;IAAE,QAAQ,CAAC,IAAI,EAAE,aAAa,CAAC;IAAC,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;CAAE,GACtD;IAAE,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,GAAG,cAAc,CAAC;IAAC,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE,CAAA;AAE7G,mFAAmF;AACnF,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,SAAS,CAE7E;AAED;;;;;GAKG;AACH,wBAAsB,oBAAoB,CACxC,WAAW,EAAE,IAAI,CAAC,iBAAiB,EAAE,QAAQ,CAAC,EAC9C,EAAE,EAAE,SAAS,EACb,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,gBAAgB,GACxB,OAAO,CAAC,IAAI,CAAC,CAWf;AAOD,MAAM,WAAW,aAAa;IAC5B,qFAAqF;IACrF,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAA;IAC3B,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;IACpB,2DAA2D;IAC3D,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;CACrB;AAED,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,SAAS,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAA;IAC9C,sDAAsD;IACtD,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,IAAI,CAAA;CAC/C;AAED;;;GAGG;AACH,wBAAsB,oBAAoB,CACxC,WAAW,EAAE,iBAAiB,EAC9B,OAAO,EAAE,gBAAgB,EACzB,OAAO,EAAE,aAAa,EACtB,IAAI,GAAE,UAAe,GACpB,OAAO,CAAC,mBAAmB,CAAC,CAqC9B;AAED;;;;;;;;;GASG;AACH,wBAAgB,qBAAqB,CAAC,WAAW,EAAE,MAAM,iBAAiB,GAAG,SAAS,EAAE,IAAI,GAAE,UAAe;oBAGzF,gBAAgB,WAAW,aAAa,GAAG,OAAO,CAAC,mBAAmB,CAAC;EAe1F"}