dexto 1.14.6 → 2.0.0-beta.1

package/dist/cli/import/codex.js

@@ -0,0 +1,148 @@
+// Reads Codex sessions: rollouts in `$CODEX_HOME/sessions/YYYY/MM/DD/`, titled from `state_5.sqlite`.
+import { access } from 'node:fs/promises';
+import path from 'node:path';
+import { z } from 'zod';
+import { createTurns, finishChat, isRecord, jsonLines, stringField, toolCallText, toolResultText, validTime, } from './transcript.js';
+/** Context Codex sends as `user` messages that the person never typed. */
+const CODEX_INJECTED = /^\s*(<environment_context>|<user_instructions>|<permissions instructions>|<turn_aborted>|# AGENTS\.md instructions)/u;
+/**
+ * A Codex rollout: `{timestamp, type, payload}` lines, as `codex-rs/history` writes them. The
+ * `session_meta` line names the thread and its git remote; `response_item` lines carry messages and
+ * tool calls. Developer and system messages, injected context, reasoning and compaction are left out.
+ * `titleOf` gives the title Codex keeps for a thread, or null when it keeps none.
+ */
+export function parseCodexRollout(text, file, titleOf) {
+    const turns = createTurns();
+    let id = null;
+    let cwd = null;
+    let gitBranch = null;
+    let remoteUrl = null;
+    for (const line of jsonLines(text)) {
+        const payload = line.payload;
+        if (!isRecord(payload))
+            continue;
+        if (line.type === 'session_meta') {
+            id ??= stringField(payload, 'id');
+            cwd ??= stringField(payload, 'cwd');
+            if (isRecord(payload.git)) {
+                gitBranch ??= stringField(payload.git, 'branch');
+                remoteUrl ??= stringField(payload.git, 'repository_url');
+            }
+            continue;
+        }
+        const at = validTime(stringField(line, 'timestamp'));
+        if (line.type !== 'response_item' || at === null)
+            continue;
+        switch (payload.type) {
+            case 'message': {
+                const said = codexContentText(payload.content);
+                if (payload.role === 'user' && !CODEX_INJECTED.test(said))
+                    turns.user(said, at);
+                if (payload.role === 'assistant')
+                    turns.assistant(said, at);
+                break;
+            }
+            case 'function_call':
+                turns.assistant(toolCallText(stringField(payload, 'name') ?? 'tool', payload.arguments ?? ''), at);
+                break;
+            case 'custom_tool_call':
+                turns.assistant(toolCallText(stringField(payload, 'name') ?? 'tool', payload.input ?? ''), at);
+                break;
+            case 'local_shell_call': {
+                const action = isRecord(payload.action) ? payload.action : {};
+                const command = Array.isArray(action.command) ? action.command : [];
+                turns.assistant(toolCallText('shell', { command }), at);
+                break;
+            }
+            case 'function_call_output':
+            case 'custom_tool_call_output':
+                turns.assistant(toolResultText(codexOutputText(payload.output)), at);
+                break;
+        }
+    }
+    const threadId = id ?? path.basename(file, '.jsonl');
+    return finishChat({
+        cwd,
+        gitBranch,
+        id: threadId,
+        path: file,
+        pullRequests: [],
+        recordedRemoteUrl: remoteUrl,
+        source: 'codex',
+        title: titleOf(threadId),
+    }, turns.done());
+}
+function codexContentText(content) {
+    if (!Array.isArray(content))
+        return '';
+    return content
+        .map((part) => (isRecord(part) && typeof part.text === 'string' ? part.text : ''))
+        .filter((part) => part !== '')
+        .join('\n');
+}
+function codexOutputText(output) {
+    if (typeof output === 'string')
+        return output;
+    if (isRecord(output) && typeof output.content === 'string')
+        return output.content;
+    return codexContentText(output);
+}
+/** `$CODEX_HOME`, or `~/.codex`. */
+export function codexHome(environment, homeDirectory) {
+    return environment.CODEX_HOME ?? path.join(homeDirectory, '.codex');
+}
+/** The state database Codex 0.1xx keeps beside its rollouts. */
+const CODEX_STATE_DB = 'state_5.sqlite';
+const ThreadRowsSchema = z.array(z.object({
+    archived: z.number(),
+    cwd: z.string(),
+    id: z.string(),
+    name: z.string().nullable(),
+    rollout_path: z.string().nullable(),
+    title: z.string(),
+    updated_at: z.number(),
+}));
+/**
+ * The threads Codex lists, read from its state database without writing to it; null when there is
+ * no such database. A present database that cannot be read is reported to the caller.
+ * Archived threads are left out, as their rollouts are not where sessions are read from.
+ */
+export async function readCodexThreads(home) {
+    const file = path.join(home, CODEX_STATE_DB);
+    if (!(await exists(file)))
+        return null;
+    let rows;
+    try {
+        const { default: Database } = await import('better-sqlite3');
+        const db = new Database(file, { fileMustExist: true, readonly: true });
+        try {
+            rows = ThreadRowsSchema.parse(db
+                .prepare('SELECT id, rollout_path, cwd, title, name, archived, updated_at FROM threads')
+                .all());
+        }
+        finally {
+            db.close();
+        }
+    }
+    catch (error) {
+        throw new Error(`Cannot read Codex state database; titles and migrated history are unavailable. Use --dir to read rollout files without it. ${error instanceof Error ? error.message : 'Unknown error.'}`, { cause: error });
+    }
+    const threads = [];
+    for (const row of rows) {
+        if (row.archived !== 0)
+            continue;
+        const name = row.name?.trim() ?? '';
+        const title = row.title.trim();
+        threads.push({
+            cwd: row.cwd,
+            hasRollout: row.rollout_path !== null && (await exists(row.rollout_path)),
+            id: row.id,
+            title: name !== '' ? name : title !== '' ? title : null,
+            updatedAt: new Date(row.updated_at * 1_000).toISOString(),
+        });
+    }
+    return threads;
+}
+async function exists(file) {
+    return await access(file).then(() => true, () => false);
+}

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

@@ -0,0 +1,19 @@
+/**
+ * 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 declare function findRepository(folder: string): Promise<{
+    readonly remoteUrl: string | null;
+    readonly root: string;
+} | null>;
+type FoundRepository = ReturnType<typeof findRepository>;
+/** A lookup of `findRepository` that reads each folder once. */
+export declare function createRepositoryFinder(): (folder: string | null) => FoundRepository;
+/** `[remote "origin"] url = …` in a git config, without credentials. */
+export declare function originUrl(config: string): string | null;
+/**
+ * A remote URL with userinfo, query and fragment removed, including scp-style userinfo.
+ */
+export declare function withoutCredentials(url: string): string;
+export {};
+//# sourceMappingURL=git.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"git.d.ts","sourceRoot":"","sources":["../../../src/cli/import/git.ts"],"names":[],"mappings":"AAKA;;;GAGG;AACH,wBAAsB,cAAc,CAChC,MAAM,EAAE,MAAM,GACf,OAAO,CAAC;IAAE,QAAQ,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAAC,CAW9E;AAED,KAAK,eAAe,GAAG,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC;AAEzD,gEAAgE;AAChE,wBAAgB,sBAAsB,IAAI,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,KAAK,eAAe,CAWnF;AA6BD,wEAAwE;AACxE,wBAAgB,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAavD;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAatD"}

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