dexto 2.0.0-beta.0 → 2.0.0-beta.1

package/dist/cli/import/git.js

@@ -0,0 +1,95 @@
+// Finds the git repository a folder is in by reading `.git` on disk; git itself is never run.
+import { readFile, stat } from 'node:fs/promises';
+import path from 'node:path';
+/**
+ * The repository `folder` is in: the main checkout's folder, so every worktree of one repository
+ * names the same one, and its `origin` remote. Null when the folder is gone or in no repository.
+ */
+export async function findRepository(folder) {
+    const resolved = path.resolve(folder);
+    if (!(await stat(resolved).catch(() => null))?.isDirectory())
+        return null;
+    const found = await findDotGit(resolved);
+    if (found === null)
+        return null;
+    const commonDir = await commonGitDir(found);
+    if (commonDir === null)
+        return null;
+    const root = path.basename(commonDir) === '.git' ? path.dirname(commonDir) : path.dirname(found.path);
+    const config = await readFile(path.join(commonDir, 'config'), 'utf8').catch(() => null);
+    return { remoteUrl: config === null ? null : originUrl(config), root };
+}
+/** A lookup of `findRepository` that reads each folder once. */
+export function createRepositoryFinder() {
+    const found = new Map();
+    return async (folder) => {
+        if (folder === null)
+            return null;
+        let repository = found.get(folder);
+        if (repository === undefined) {
+            repository = findRepository(folder);
+            found.set(folder, repository);
+        }
+        return await repository;
+    };
+}
+/** The nearest `.git` at or above `folder`: a directory, or a worktree's `gitdir:` file. */
+async function findDotGit(folder) {
+    for (let current = folder;; current = path.dirname(current)) {
+        const candidate = path.join(current, '.git');
+        const stats = await stat(candidate).catch(() => null);
+        if (stats?.isDirectory())
+            return { kind: 'dir', path: candidate };
+        if (stats?.isFile())
+            return { kind: 'file', path: candidate };
+        if (path.dirname(current) === current)
+            return null;
+    }
+}
+/** The git directory shared by every worktree: a worktree's `gitdir`, then its `commondir`. */
+async function commonGitDir(dotGit) {
+    if (dotGit.kind === 'dir')
+        return dotGit.path;
+    const pointer = await readFile(dotGit.path, 'utf8').catch(() => null);
+    const gitDir = /^gitdir:\s*(.+)$/mu.exec(pointer ?? '')?.[1]?.trim();
+    if (gitDir === undefined)
+        return null;
+    const worktreeDir = path.resolve(path.dirname(dotGit.path), gitDir);
+    const common = await readFile(path.join(worktreeDir, 'commondir'), 'utf8').catch(() => null);
+    return common === null ? worktreeDir : path.resolve(worktreeDir, common.trim());
+}
+/** `[remote "origin"] url = …` in a git config, without credentials. */
+export function originUrl(config) {
+    let inOrigin = false;
+    for (const raw of config.split(/\r?\n/u)) {
+        const line = raw.trim();
+        if (line.startsWith('[')) {
+            inOrigin = /^\[remote\s+"origin"\]$/u.test(line);
+            continue;
+        }
+        if (!inOrigin)
+            continue;
+        const url = /^url\s*=\s*(.+)$/u.exec(line)?.[1]?.trim();
+        if (url !== undefined && url !== '')
+            return withoutCredentials(url);
+    }
+    return null;
+}
+/**
+ * A remote URL with userinfo, query and fragment removed, including scp-style userinfo.
+ */
+export function withoutCredentials(url) {
+    if (!/^[a-z][a-z0-9+.-]*:\/\//iu.test(url))
+        return url.replace(/^(\/\/)?[^\s]*@(?=[^/]+(?:\/|:|$))/u, '$1').split(/[?#]/u, 1)[0] ?? '';
+    try {
+        const parsed = new URL(url);
+        parsed.username = '';
+        parsed.password = '';
+        parsed.search = '';
+        parsed.hash = '';
+        return parsed.toString();
+    }
+    catch {
+        return url.replace(/\/\/[^/@]*@/u, '//').split(/[?#]/u, 1)[0] ?? '';
+    }
+}

package/dist/cli/import/local-chats.d.ts

@@ -0,0 +1,28 @@
+import type { CloudRuntime } from '../cloud/runtime.js';
+import type { LocalChat, LocalChatSource } from './transcript.js';
+export interface LocalChatQuery {
+    /** Another sessions folder to read instead of the source's own. */
+    readonly dir: string | null;
+    /** Keep sessions whose working directory is this folder or inside it. */
+    readonly folder: string | null;
+    /** Keep sessions with a turn at or after this date. */
+    readonly since: string | null;
+    readonly source: LocalChatSource;
+}
+/** Something about this machine's sessions that the chats found don't show. */
+export interface LocalChatNotice {
+    readonly code: 'codex_history_migrated';
+    /** How many sessions it is about. */
+    readonly count: number;
+    readonly message: string;
+}
+export interface LocalChatScan {
+    /** Newest first. */
+    readonly chats: readonly LocalChat[];
+    readonly notices: readonly LocalChatNotice[];
+}
+type FinderRuntime = Pick<CloudRuntime, 'environment' | 'homeDirectory'>;
+/** The source's sessions on this machine that match the query, newest first. */
+export declare function findLocalChats(runtime: FinderRuntime, query: LocalChatQuery): Promise<LocalChatScan>;
+export {};
+//# sourceMappingURL=local-chats.d.ts.map

package/dist/cli/import/local-chats.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"local-chats.d.ts","sourceRoot":"","sources":["../../../src/cli/import/local-chats.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAIxD,OAAO,KAAK,EAAE,SAAS,EAAE,eAAe,EAAc,MAAM,iBAAiB,CAAC;AAK9E,MAAM,WAAW,cAAc;IAC3B,mEAAmE;IACnE,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,yEAAyE;IACzE,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/B,uDAAuD;IACvD,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,QAAQ,CAAC,MAAM,EAAE,eAAe,CAAC;CACpC;AAED,+EAA+E;AAC/E,MAAM,WAAW,eAAe;IAC5B,QAAQ,CAAC,IAAI,EAAE,wBAAwB,CAAC;IACxC,qCAAqC;IACrC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC5B;AAED,MAAM,WAAW,aAAa;IAC1B,oBAAoB;IACpB,QAAQ,CAAC,KAAK,EAAE,SAAS,SAAS,EAAE,CAAC;IACrC,QAAQ,CAAC,OAAO,EAAE,SAAS,eAAe,EAAE,CAAC;CAChD;AAED,KAAK,aAAa,GAAG,IAAI,CAAC,YAAY,EAAE,aAAa,GAAG,eAAe,CAAC,CAAC;AAEzE,gFAAgF;AAChF,wBAAsB,cAAc,CAChC,OAAO,EAAE,aAAa,EACtB,KAAK,EAAE,cAAc,GACtB,OAAO,CAAC,aAAa,CAAC,CA+BxB"}

package/dist/cli/import/local-chats.js

@@ -0,0 +1,129 @@
+// Finds the Claude Code and Codex chats on this machine that a query asks for.
+import { readdir, readFile, stat } from 'node:fs/promises';
+import path from 'node:path';
+import { UsageError } from '../cloud/command.js';
+import { claudeCodeFolder, parseClaudeCodeTranscript } from './claude-code.js';
+import { codexHome, parseCodexRollout, readCodexThreads } from './codex.js';
+import { createRepositoryFinder, withoutCredentials } from './git.js';
+/** A transcript file larger than this is not read. */
+const MAX_FILE_BYTES = 64 * 1024 * 1024;
+/** The source's sessions on this machine that match the query, newest first. */
+export async function findLocalChats(runtime, query) {
+    if (query.dir !== null)
+        await readdir(query.dir).catch(() => {
+            throw new UsageError(`--dir ${query.dir} is not a folder this can read.`);
+        });
+    const since = query.since === null ? null : new Date(query.since);
+    const within = query.folder === null ? null : path.resolve(query.folder);
+    const matches = (updatedAt, cwd) => (since === null || new Date(updatedAt) >= since) &&
+        (within === null || insideFolder(cwd, within));
+    const sessions = query.source === 'claude-code'
+        ? await claudeCodeSessions(runtime, query.dir)
+        : await codexSessions(runtime, query.dir);
+    const repositoryOf = createRepositoryFinder();
+    const chats = [];
+    for (const file of sessions.files) {
+        const stats = await stat(file).catch(() => null);
+        if (stats === null || stats.size > MAX_FILE_BYTES)
+            continue;
+        const text = await readFile(file, 'utf8').catch(() => null);
+        if (text === null)
+            continue;
+        const parsed = sessions.parse(text, file);
+        if (parsed === null || !matches(parsed.updatedAt, parsed.cwd))
+            continue;
+        chats.push(await withRepository(parsed, repositoryOf));
+    }
+    const notices = sessions.notices(matches);
+    return {
+        chats: chats.sort((left, right) => right.updatedAt.localeCompare(left.updatedAt)),
+        notices,
+    };
+}
+async function claudeCodeSessions(runtime, dir) {
+    const folder = dir ?? claudeCodeFolder(runtime.environment, runtime.homeDirectory);
+    return {
+        files: await claudeCodeFiles(folder),
+        notices: () => [],
+        parse: parseClaudeCodeTranscript,
+    };
+}
+/**
+ * Codex rollouts, titled as Codex lists them. Its own state database is read only for its own
+ * sessions folder: a `--dir` is a copy, whose threads that database doesn't describe.
+ */
+async function codexSessions(runtime, dir) {
+    const home = codexHome(runtime.environment, runtime.homeDirectory);
+    const threads = dir === null ? await readCodexThreads(home) : null;
+    const titles = new Map((threads ?? []).map((thread) => [thread.id, thread.title]));
+    return {
+        files: await codexFiles(dir ?? path.join(home, 'sessions')),
+        notices: (matches) => migratedNotice(threads ?? [], matches),
+        parse: (text, file) => parseCodexRollout(text, file, (id) => titles.get(id) ?? null),
+    };
+}
+/** Codex threads whose history moved out of rollout files, which this can't read yet. */
+function migratedNotice(threads, matches) {
+    const count = threads.filter((thread) => !thread.hasRollout && matches(thread.updatedAt, thread.cwd)).length;
+    if (count === 0)
+        return [];
+    const chats = count === 1 ? '1 Codex chat has' : `${count} Codex chats have`;
+    return [
+        {
+            code: 'codex_history_migrated',
+            count,
+            message: `${chats} no rollout file on this machine, so it can't be imported yet: Codex keeps its history in its own database after \`codex migrate-rollouts\`.`,
+        },
+    ];
+}
+async function withRepository(parsed, repositoryOf) {
+    const { recordedRemoteUrl, ...chat } = parsed;
+    const onDisk = await repositoryOf(chat.cwd);
+    // The remote Codex recorded when the session ran outlives a checkout that has since moved.
+    const remoteUrl = recordedRemoteUrl === null
+        ? (onDisk?.remoteUrl ?? null)
+        : withoutCredentials(recordedRemoteUrl);
+    const root = onDisk?.root ?? null;
+    return {
+        ...chat,
+        repository: root === null && remoteUrl === null ? null : { remoteUrl, root },
+    };
+}
+function insideFolder(cwd, folder) {
+    if (cwd === null)
+        return false;
+    const relative = path.relative(folder, cwd);
+    return relative === '' || (!relative.startsWith('..') && !path.isAbsolute(relative));
+}
+async function entries(folder) {
+    return await readdir(folder, { withFileTypes: true }).catch(() => []);
+}
+/** `projects/<project>/<session>.jsonl`; deeper files are a session's subagents. */
+async function claudeCodeFiles(folder) {
+    const files = [];
+    for (const project of await entries(folder)) {
+        if (!project.isDirectory())
+            continue;
+        for (const file of await entries(path.join(folder, project.name)))
+            if (file.isFile() && file.name.endsWith('.jsonl'))
+                files.push(path.join(folder, project.name, file.name));
+    }
+    return files;
+}
+/** `sessions/YYYY/MM/DD/rollout-*.jsonl`; compressed rollouts are left out. */
+async function codexFiles(folder) {
+    const files = [];
+    const visit = async (dir, depth) => {
+        for (const entry of await entries(dir)) {
+            const full = path.join(dir, entry.name);
+            if (entry.isDirectory() && depth < 3)
+                await visit(full, depth + 1);
+            else if (entry.isFile() &&
+                entry.name.startsWith('rollout-') &&
+                entry.name.endsWith('.jsonl'))
+                files.push(full);
+        }
+    };
+    await visit(folder, 0);
+    return files;
+}

package/dist/cli/import/redaction.d.ts

@@ -0,0 +1,37 @@
+import type { LocalChat, LocalChatMessage, LocalChatSource } from './transcript.js';
+/** What `dexto_chat_import` takes; its bounds are the server's too. */
+export interface ChatImportInput {
+    readonly cwd?: string;
+    readonly gitBranch?: string;
+    readonly messages: readonly LocalChatMessage[];
+    readonly source: LocalChatSource;
+    readonly sourceSessionId: string;
+    readonly title: string;
+}
+export declare const MAX_IMPORT_MESSAGES = 2000;
+export declare const MAX_MESSAGE_CHARS = 64000;
+export declare const MAX_IMPORT_CHARS = 4000000;
+export declare function truncate(text: string, max: number): string;
+export declare function redactSecrets(text: string): {
+    counts: Record<string, number>;
+    text: string;
+};
+export type PreparedImport = {
+    readonly input: ChatImportInput;
+    readonly kind: 'ready';
+    /** How many of the session's oldest messages were left out to fit the import's bounds. */
+    readonly leftOut: number;
+    /** How many of each kind of secret were redacted, counted from the markers sent. */
+    readonly redactions: Readonly<Record<string, number>>;
+    /** How many messages were cut to the size limit. */
+    readonly truncated: number;
+} | {
+    readonly kind: 'skipped';
+    readonly reason: string;
+};
+/**
+ * The chat as it is sent: redacted, and each message within the size limit. A session longer than
+ * the import's bounds keeps its newest messages, after a note that says how many were left out.
+ */
+export declare function toImportInput(chat: Pick<LocalChat, 'cwd' | 'gitBranch' | 'id' | 'messages' | 'source' | 'title'>): PreparedImport;
+//# sourceMappingURL=redaction.d.ts.map

package/dist/cli/import/redaction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"redaction.d.ts","sourceRoot":"","sources":["../../../src/cli/import/redaction.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,SAAS,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAEpF,uEAAuE;AACvE,MAAM,WAAW,eAAe;IAC5B,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,QAAQ,EAAE,SAAS,gBAAgB,EAAE,CAAC;IAC/C,QAAQ,CAAC,MAAM,EAAE,eAAe,CAAC;IACjC,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IACjC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CAC1B;AAED,eAAO,MAAM,mBAAmB,OAAQ,CAAC;AACzC,eAAO,MAAM,iBAAiB,QAAS,CAAC;AACxC,eAAO,MAAM,gBAAgB,UAAY,CAAC;AAM1C,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAI1D;AAsBD,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG;IAAE,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAuC5F;AAED,MAAM,MAAM,cAAc,GACpB;IACI,QAAQ,CAAC,KAAK,EAAE,eAAe,CAAC;IAChC,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IACvB,0FAA0F;IAC1F,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,oFAAoF;IACpF,QAAQ,CAAC,UAAU,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IACtD,oDAAoD;IACpD,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;CAC9B,GACD;IAAE,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC;AAgB5D;;;GAGG;AACH,wBAAgB,aAAa,CACzB,IAAI,EAAE,IAAI,CAAC,SAAS,EAAE,KAAK,GAAG,WAAW,GAAG,IAAI,GAAG,UAAU,GAAG,QAAQ,GAAG,OAAO,CAAC,GACpF,cAAc,CA0BhB"}

package/dist/cli/import/redaction.js

@@ -0,0 +1,148 @@
+// Turns a local chat into what `dexto_chat_import` takes: redacted here, and within its bounds.
+export const MAX_IMPORT_MESSAGES = 2_000;
+export const MAX_MESSAGE_CHARS = 64_000;
+export const MAX_IMPORT_CHARS = 4_000_000;
+const MAX_TITLE_CHARS = 200;
+const MAX_CWD_CHARS = 1_024;
+const MAX_BRANCH_CHARS = 255;
+const SOURCE_SESSION_ID = /^[A-Za-z0-9._:-]{1,200}$/u;
+export function truncate(text, max) {
+    if (text.length <= max)
+        return text;
+    const marker = `\n… [${text.length - max} more characters left out]`;
+    return `${text.slice(0, Math.max(0, max - marker.length))}${marker}`;
+}
+/** Credential shapes, most specific first; each match becomes `[redacted:<kind>]`. */
+const SECRET_PATTERNS = [
+    ['private_key', /-----BEGIN [A-Z ]*PRIVATE KEY-----[\s\S]*?-----END [A-Z ]*PRIVATE KEY-----/gu],
+    ['secret_key', /\bsk-[A-Za-z0-9_-]{20,}/gu],
+    ['secret_key', /\b(?:sk|rk)_(?:live|test)_[A-Za-z0-9_-]{8,}/gu],
+    ['gitlab_token', /\bglpat-[A-Za-z0-9_-]{8,}/gu],
+    ['github_token', /\b(?:gh[pousr]_[A-Za-z0-9]{36,}|github_pat_[A-Za-z0-9_]{22,})/gu],
+    ['aws_access_key', /\b(?:AKIA|ASIA)[0-9A-Z]{16}\b/gu],
+    ['slack_token', /\bxox[abprs]-[A-Za-z0-9-]{10,}/gu],
+    ['google_api_key', /\bAIza[0-9A-Za-z_-]{35}/gu],
+    ['jwt', /\beyJ[A-Za-z0-9_-]{8,}\.eyJ[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}/gu],
+    ['bearer_token', /\bBearer\s+[A-Za-z0-9._~+/=-]{16,}/gu],
+    ['auth_token', /\bAuthorization\s*:\s*(?:Basic|Token)\s+[A-Za-z0-9._~+/=-]{8,}/giu],
+];
+/** `password = value` and the like: the name stays, the value goes. */
+const SECRET_ASSIGNMENT = /\b([A-Za-z_][A-Za-z0-9_-]*)(\\*["']?\s*[:=]\s*\\*["']?)([^\s"'[]{8,})/gu;
+const REDACTED_MARKER = /\[redacted:([a-z_]+)\]/gu;
+export function redactSecrets(text) {
+    const counts = {};
+    const count = (kind) => {
+        counts[kind] = (counts[kind] ?? 0) + 1;
+    };
+    let redacted = text;
+    for (const [kind, pattern] of SECRET_PATTERNS)
+        redacted = redacted.replace(pattern, () => {
+            count(kind);
+            return `[redacted:${kind}]`;
+        });
+    redacted = redacted.replace(/(:\/\/[^\s/:@]+:)([^\s/]+)(@)/gu, (_match, prefix, _password, suffix) => {
+        count('url_password');
+        return `${prefix}[redacted:url_password]${suffix}`;
+    });
+    redacted = redacted.replace(SECRET_ASSIGNMENT, (match, name, separator, value) => {
+        const words = name
+            .replace(/([a-z0-9])([A-Z])/gu, '$1_$2')
+            .toLowerCase()
+            .split(/[_-]+/u);
+        const secret = words.some((word) => ['password', 'passwd', 'pass', 'secret', 'token'].includes(word)) ||
+            words.some((word, index) => ['api', 'private', 'access'].includes(word) && words[index + 1] === 'key');
+        if (!secret || /^z\.\w+\(/u.test(value))
+            return match;
+        count('assignment');
+        return `${name}${separator}[redacted:assignment]`;
+    });
+    return { counts, text: redacted };
+}
+const SOURCE_NAMES = {
+    'claude-code': 'Claude Code',
+    codex: 'Codex',
+};
+/** The first message of a chat whose oldest messages were left out, saying so. */
+function leftOutNote(source, leftOut) {
+    const what = leftOut === 1
+        ? 'the first message of this session was'
+        : `the first ${leftOut.toLocaleString('en-US')} messages of this session were`;
+    return `[Imported from ${SOURCE_NAMES[source]}: ${what} left out. Dexto imports up to a session's newest ${MAX_IMPORT_MESSAGES.toLocaleString('en-US')} messages.]`;
+}
+/**
+ * The chat as it is sent: redacted, and each message within the size limit. A session longer than
+ * the import's bounds keeps its newest messages, after a note that says how many were left out.
+ */
+export function toImportInput(chat) {
+    if (!SOURCE_SESSION_ID.test(chat.id))
+        return { kind: 'skipped', reason: "Its session id isn't one Dexto takes." };
+    let truncated = 0;
+    const bounded = chat.messages.map((message) => {
+        const { text } = redactSecrets(message.text);
+        if (text.length > MAX_MESSAGE_CHARS)
+            truncated += 1;
+        return {
+            createdAt: message.createdAt,
+            role: message.role,
+            text: truncate(text, MAX_MESSAGE_CHARS),
+        };
+    });
+    const { leftOut, messages } = newestWithin(bounded, chat.source);
+    const title = redactSecrets(chat.title).text.slice(0, MAX_TITLE_CHARS);
+    const cwd = chat.cwd === null ? null : redactSecrets(chat.cwd).text;
+    const gitBranch = chat.gitBranch === null ? null : redactSecrets(chat.gitBranch).text;
+    const input = {
+        ...(cwd === null || cwd.length > MAX_CWD_CHARS ? {} : { cwd }),
+        ...(gitBranch === null || gitBranch.length > MAX_BRANCH_CHARS ? {} : { gitBranch }),
+        messages,
+        source: chat.source,
+        sourceSessionId: chat.id,
+        title: title.trim() === '' ? 'Imported chat' : title,
+    };
+    return { input, kind: 'ready', leftOut, redactions: redactionCounts(input), truncated };
+}
+/**
+ * The messages as they are when they fit the import's message and character bounds; otherwise a
+ * note saying how many were left out, then the newest messages that fit alongside it.
+ */
+function newestWithin(messages, source) {
+    const chars = messages.reduce((sum, message) => sum + message.text.length, 0);
+    if (messages.length <= MAX_IMPORT_MESSAGES && chars <= MAX_IMPORT_CHARS)
+        return { leftOut: 0, messages: [...messages] };
+    // The note's own length depends on the count it states; the widest count fits every count.
+    const noteChars = leftOutNote(source, messages.length).length;
+    const kept = [];
+    let total = noteChars;
+    for (let index = messages.length - 1; index >= 0; index -= 1) {
+        const message = messages[index];
+        if (message === undefined)
+            break;
+        if (kept.length === MAX_IMPORT_MESSAGES - 1)
+            break;
+        if (total + message.text.length > MAX_IMPORT_CHARS)
+            break;
+        kept.push(message);
+        total += message.text.length;
+    }
+    kept.reverse();
+    const leftOut = messages.length - kept.length;
+    // Date the note before all retained messages, including when source timestamps tie or regress.
+    const lastLeftOut = messages[leftOut - 1];
+    if (lastLeftOut === undefined)
+        return { leftOut: 0, messages: kept };
+    const note = {
+        createdAt: new Date(Math.min(Date.parse(lastLeftOut.createdAt), ...kept.map((message) => Date.parse(message.createdAt) - 1))).toISOString(),
+        role: 'assistant',
+        text: leftOutNote(source, leftOut),
+    };
+    return { leftOut, messages: [note, ...kept] };
+}
+/** Each `[redacted:<kind>]` in what is sent, including those made while reading tool output. */
+function redactionCounts(input) {
+    const counts = {};
+    const sent = [input.title, input.cwd ?? '', input.gitBranch ?? ''];
+    for (const text of [...sent, ...input.messages.map((message) => message.text)])
+        for (const [, kind = ''] of text.matchAll(REDACTED_MARKER))
+            counts[kind] = (counts[kind] ?? 0) + 1;
+    return counts;
+}

package/dist/cli/import/test-utils.d.ts

@@ -0,0 +1,16 @@
+export declare const jsonl: (lines: readonly unknown[]) => string;
+/** A synthetic Claude Code session, shaped as the Agent SDK's messages. */
+export declare function claudeSession(sessionId: string): string;
+/** A synthetic Codex rollout, shaped as `RolloutItemWire` lines. */
+export declare function codexRollout(id: string): string;
+/** A Codex `state_5.sqlite` with the `threads` columns an import reads, holding these rows. */
+export declare function writeCodexState(home: string, threads: readonly {
+    readonly archived?: boolean;
+    readonly cwd: string;
+    readonly id: string;
+    readonly name?: string | null;
+    readonly rolloutPath: string | null;
+    readonly title: string;
+    readonly updatedAt: string;
+}[]): Promise<void>;
+//# sourceMappingURL=test-utils.d.ts.map

package/dist/cli/import/test-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-utils.d.ts","sourceRoot":"","sources":["../../../src/cli/import/test-utils.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,KAAK,GAAI,OAAO,SAAS,OAAO,EAAE,WACS,CAAC;AAEzD,2EAA2E;AAC3E,wBAAgB,aAAa,CAAC,SAAS,EAAE,MAAM,UAsG9C;AAED,oEAAoE;AACpE,wBAAgB,YAAY,CAAC,EAAE,EAAE,MAAM,UAoGtC;AAED,+FAA+F;AAC/F,wBAAsB,eAAe,CACjC,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,SAAS;IACd,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAC;IAC5B,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,QAAQ,CAAC,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IACpC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;CAC9B,EAAE,GACJ,OAAO,CAAC,IAAI,CAAC,CAuBf"}