@deepseek-harness-tui/dsh-tui 0.11.0 → 0.11.2

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"}

package/lib/types/dsh-adapter/migrate/import-one.js

@@ -0,0 +1,133 @@
+/**
+ * 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 } from '@deepseek-ai/dsh-session';
+import { existsSync } from 'node:fs';
+import { deleteSessionLog } from '../compat/index.js';
+import { sessionize } from './sessionize.js';
+import { migrationUuid } from './uuid.js';
+/** Deterministic DSH session id of one foreign conversation (same as /migrate). */
+export function foreignSessionId(agentId, sourceId) {
+    return SessionId(migrationUuid(`${agentId}:${sourceId}`));
+}
+/**
+ * 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 async function writeImportedSession(persistence, id, agentId, session) {
+    const { header, events } = sessionize(id, agentId, session);
+    const handle = await persistence.create(header);
+    try {
+        await handle.append(events);
+        await handle.flush();
+    }
+    finally {
+        // A close failure must not mask an append/flush error, nor (on the
+        // single-import path) turn a completed write into a cleanup candidate.
+        await handle.close().catch(() => { });
+    }
+}
+async function exists(persistence, id) {
+    if (persistence.stat !== undefined)
+        return (await persistence.stat(id)) !== undefined;
+    return (await persistence.list()).some(entry => entry.header.id === id);
+}
+/**
+ * Import one conversation unless it is already present.
+ * @returns ready (with whether it was written now), cwd-missing, or failed.
+ */
+export async function importForeignSession(persistence, adapter, request, deps = {}) {
+    const cwdExists = deps.cwdExists ?? existsSync;
+    let id = foreignSessionId(adapter.id, request.sessionKey);
+    if (await exists(persistence, id))
+        return { kind: 'ready', sessionId: id, created: false };
+    if (request.cwd !== '' && !cwdExists(request.cwd))
+        return { kind: 'cwd-missing', cwd: request.cwd };
+    if (adapter.load === undefined)
+        return { kind: 'failed', reason: 'not-a-session' };
+    const loaded = await adapter.load(request.ref);
+    if ('skip' in loaded)
+        return { kind: 'failed', reason: loaded.skip };
+    if (!cwdExists(loaded.cwd))
+        return { kind: 'cwd-missing', cwd: loaded.cwd };
+    // The artifact may have changed identity since it was listed; the id always
+    // follows what is actually imported, exactly as /migrate derives it.
+    if (loaded.sourceId !== request.sessionKey) {
+        id = foreignSessionId(adapter.id, loaded.sourceId);
+        if (await exists(persistence, id))
+            return { kind: 'ready', sessionId: id, created: false };
+    }
+    // create is its own phase: losing the race for the deterministic id to a
+    // concurrent writer (the /migrate batch, another TUI) means the log that is
+    // already there is theirs — complete or becoming complete — and never this
+    // failure's to delete. Any other create failure wrote nothing at all.
+    const { header, events } = sessionize(id, adapter.id, loaded);
+    let handle;
+    try {
+        handle = await persistence.create(header);
+    }
+    catch (error) {
+        if (await exists(persistence, id))
+            return { kind: 'ready', sessionId: id, created: false };
+        return { kind: 'failed', reason: 'write-failed', detail: error instanceof Error ? error.message : String(error) };
+    }
+    try {
+        await handle.append(events);
+        await handle.flush();
+    }
+    catch (error) {
+        await handle.close().catch(() => { });
+        (deps.discard ?? deleteSessionLog)(id);
+        return { kind: 'failed', reason: 'write-failed', detail: error instanceof Error ? error.message : String(error) };
+    }
+    await handle.close().catch(() => { });
+    return { kind: 'ready', sessionId: id, created: true };
+}
+/**
+ * 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 function createForeignImporter(persistence, deps = {}) {
+    const inFlight = new Map();
+    return {
+        import(adapter, request) {
+            const key = request.sessionKey !== ''
+                ? `id:${foreignSessionId(adapter.id, request.sessionKey)}`
+                : `ref:${adapter.id}|${request.ref}`;
+            const running = inFlight.get(key);
+            if (running !== undefined)
+                return running;
+            const service = persistence();
+            if (service === undefined)
+                return Promise.resolve({ kind: 'failed', reason: 'write-failed', detail: 'session persistence unavailable' });
+            const started = importForeignSession(service, adapter, request, deps)
+                .catch((error) => ({ kind: 'failed', reason: 'write-failed', detail: error instanceof Error ? error.message : String(error) }))
+                .finally(() => inFlight.delete(key));
+            inFlight.set(key, started);
+            return started;
+        },
+    };
+}

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

@@ -0,0 +1,35 @@
+import { SessionId } from '@deepseek-ai/dsh-session';
+import type { MigrationAdapter, MigrationSession } from './types.js';
+export declare const MIGRATION_ADAPTERS: readonly MigrationAdapter[];
+/**
+ * The default import target: the shared DSH session store, resolved exactly
+ * like the persistence backend's root (cordis.patch.yml): an explicit
+ * `DSH_TUI_SESSION_ROOT` first, then `$DSH_HOME/sessions`, then
+ * `~/.dsh/sessions`. Resolving it any other way would let the CLI import into
+ * a store the TUI (and the source tabs) never read.
+ */
+export declare function defaultSessionRoot(): string;
+/** Deterministic session id for one foreign conversation. */
+export declare function migrationSessionId(adapter: MigrationAdapter, session: MigrationSession): SessionId;
+export interface ImportRun {
+    readonly imported: number;
+    readonly existing: number;
+    readonly failed: number;
+    /** One-line cause per failed conversation, for the CLI summary. */
+    readonly failures: readonly string[];
+}
+/**
+ * Import every discovered conversation of one adapter into the DSH store.
+ *
+ * The persistence backend is mounted ONCE per run (one Context, one plugin
+ * lifecycle) and disposed after the loop; sessions already present (same
+ * deterministic id) are skipped, and a failed conversation never aborts the
+ * batch — both properties the retired-store migration established first.
+ *
+ * @param adapter - the foreign agent to import from.
+ * @param root - the DSH session root to write into.
+ * @param sessions - the conversations to import (usually adapter.discover()).
+ * @returns the per-run counters.
+ */
+export declare function importSessions(adapter: MigrationAdapter, root: string, sessions: readonly MigrationSession[]): Promise<ImportRun>;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/dsh-adapter/migrate/index.ts"],"names":[],"mappings":"AAiBA,OAAO,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAA;AASpD,OAAO,KAAK,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAA;AAEpE,eAAO,MAAM,kBAAkB,EAAE,SAAS,gBAAgB,EAMzD,CAAA;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,IAAI,MAAM,CAK3C;AAED,6DAA6D;AAC7D,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,gBAAgB,EAAE,OAAO,EAAE,gBAAgB,GAAG,SAAS,CAElG;AAuBD,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;IACzB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;IACzB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,mEAAmE;IACnE,QAAQ,CAAC,QAAQ,EAAE,SAAS,MAAM,EAAE,CAAA;CACrC;AAED;;;;;;;;;;;;GAYG;AACH,wBAAsB,cAAc,CAClC,OAAO,EAAE,gBAAgB,EACzB,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,SAAS,gBAAgB,EAAE,GACpC,OAAO,CAAC,SAAS,CAAC,CAkCpB"}