@propel-code/codex-mover 0.1.0

package/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -0,0 +1,100 @@
+# codex-mover
+
+`codex-mover` packages portable Codex and Claude Code history/context into a tarball and merges that tarball into another machine's local data.
+
+The package installs a primary `codex-mover` CLI and a `codeport` alias for compatibility with the old `codegraph`-embedded command.
+
+## Install
+
+Use without installing:
+
+```bash
+npx @propel-code/codex-mover --help
+```
+
+Install globally:
+
+```bash
+npm install -g @propel-code/codex-mover
+codex-mover --help
+codeport --help
+```
+
+Use with Bun:
+
+```bash
+bunx @propel-code/codex-mover --help
+```
+
+## Usage
+
+```bash
+codex-mover pack [--output ./codex-mover-archive.tar.gz] [--provider codex|claude|all]
+codex-mover merge --input ./codex-mover-archive.tar.gz [--provider codex|claude|all] [--path-map /old=/new]
+```
+
+Examples:
+
+```bash
+codex-mover pack --output ./tony-context.tar.gz
+codex-mover merge --input ./tony-context.tar.gz
+codex-mover merge --input ./tony-context.tar.gz --path-map /Users/tony/dev=/Users/alice/dev
+```
+
+Options:
+
+- `--input`
+  Archive path to merge in `merge` mode.
+- `--output`
+  Archive path to create in `pack` mode. Defaults to `./codex-mover-<timestamp>.tar.gz`.
+- `--provider codex|claude|all`
+  Package or merge a single provider or both. Default is `all`.
+- `--codex-home PATH`
+  Override the Codex home directory.
+- `--claude-config-dir PATH`
+  Override the Claude config directory.
+- `--path-map OLD=NEW`
+  Rewrite stored project paths during merge. Repeat this flag when multiple roots moved.
+- `--help`
+  Print usage information.
+
+## What It Copies
+
+By default, `codex-mover` includes portable history and context:
+
+- Codex: `sessions/`, `archived_sessions/`, `history.jsonl`, `session_index.jsonl`
+- Codex context: `memories/`, `automations/`, `AGENTS.md`, `rules/`, `policy/`, `skills/`
+- Claude Code: `projects/`, `history.jsonl`, `todos/`
+
+## What It Excludes
+
+By default, `codex-mover` excludes machine- and account-local state:
+
+- Codex: `auth.json`, `config.toml`, caches, logs, sqlite state, shell snapshots, temp files, vendor imports, worktrees
+- Claude Code: backups, caches, debug logs, plugins, `settings.json`, shell snapshots, stats caches
+
+## Merge Behavior
+
+- JSONL history files are merged by unique line content. Session JSONL files prefer the imported copy when both sides identify the same session.
+- Claude project roots can be rewritten with `--path-map`, which updates both file paths and stored `cwd` and `project` references.
+- Non-appendable conflicting files are preserved as `*.imported-<bundle>` siblings instead of overwriting local data.
+
+## Development
+
+```bash
+cd /Users/tony/dev/codex-mover
+bun install
+bun test
+bun run typecheck
+```
+
+## Verification
+
+```bash
+bun run typecheck
+bun test
+bun run build
+npx @propel-code/codex-mover --help
+node dist/bin.js pack --provider codex --output /tmp/codex-mover.tar.gz
+node dist/bin.js merge --input /tmp/codex-mover.tar.gz
+```

package/dist/bin.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import "./cli.js";

package/dist/cli.js

@@ -0,0 +1,113 @@
+import { basename, resolve } from "node:path";
+import { parseArgs } from "node:util";
+import { mergeMigrationArchive, packMigrationArchive, parsePathMap, } from "./migration.js";
+const DEFAULT_COMMAND_NAME = "codex-mover";
+const PROVIDERS = ["codex", "claude", "all"];
+function getCommandName() {
+    const entryPath = process.argv[1];
+    if (!entryPath) {
+        return DEFAULT_COMMAND_NAME;
+    }
+    const entryName = basename(entryPath);
+    if (entryName.endsWith(".js") || entryName.endsWith(".ts")) {
+        return DEFAULT_COMMAND_NAME;
+    }
+    return entryName;
+}
+function buildHelpText(commandName) {
+    return `${commandName}
+
+Package and merge local Codex and Claude Code history/context between machines.
+
+Usage:
+  ${commandName} pack [--output ./${commandName}-archive.tar.gz] [--provider codex|claude|all]
+  ${commandName} merge --input ./${commandName}-archive.tar.gz [--provider codex|claude|all] [--path-map /old=/new]
+
+Options:
+  --input                  Archive path to merge
+  --output, -o             Archive path to create
+  --provider               Provider selection: codex, claude, or all
+  --codex-home             Override the Codex home directory
+  --claude-config-dir      Override the Claude config directory
+  --path-map               Rewrite stored project paths during merge; repeatable
+  --help, -h               Show this help
+`;
+}
+function printHelp(commandName) {
+    process.stdout.write(buildHelpText(commandName));
+}
+function parseProvider(value) {
+    const normalized = value?.trim().toLowerCase() ?? "all";
+    if (PROVIDERS.includes(normalized)) {
+        return normalized;
+    }
+    throw new Error(`Unsupported provider "${value}". Use codex, claude, or all.`);
+}
+function getDefaultArchiveName(commandName) {
+    const timestamp = new Date().toISOString().replaceAll(/[:.]/g, "-");
+    return `./${commandName}-${timestamp}.tar.gz`;
+}
+async function main() {
+    const commandName = getCommandName();
+    const { values, positionals } = parseArgs({
+        options: {
+            input: { type: "string" },
+            output: { type: "string", short: "o" },
+            provider: { type: "string" },
+            "codex-home": { type: "string" },
+            "claude-config-dir": { type: "string" },
+            "path-map": { type: "string", multiple: true },
+            help: { type: "boolean", short: "h" },
+        },
+        allowPositionals: true,
+    });
+    const command = positionals[0]?.trim().toLowerCase();
+    if (values.help || !command) {
+        printHelp(commandName);
+        return;
+    }
+    const provider = parseProvider(values.provider);
+    if (command === "pack") {
+        const result = await packMigrationArchive({
+            outputPath: resolve(values.output ?? getDefaultArchiveName(commandName)),
+            provider,
+            ...(values["codex-home"] ? { codexHome: values["codex-home"] } : {}),
+            ...(values["claude-config-dir"]
+                ? { claudeConfigDir: values["claude-config-dir"] }
+                : {}),
+        });
+        process.stdout.write(`${JSON.stringify({
+            mode: "pack",
+            output: result.outputPath,
+            providers: [...new Set(result.manifest.files.map((file) => file.provider))],
+            files: result.manifest.files.length,
+            bytes: result.manifest.files.reduce((total, file) => total + file.size, 0),
+            bundleId: result.manifest.bundleId,
+        }, null, 2)}\n`);
+        return;
+    }
+    if (command === "merge") {
+        if (!values.input) {
+            throw new Error("merge requires --input PATH.");
+        }
+        const result = await mergeMigrationArchive({
+            inputPath: values.input,
+            provider,
+            ...(values["codex-home"] ? { codexHome: values["codex-home"] } : {}),
+            ...(values["claude-config-dir"]
+                ? { claudeConfigDir: values["claude-config-dir"] }
+                : {}),
+            ...((values["path-map"] ?? []).length > 0
+                ? { pathMaps: (values["path-map"] ?? []).map(parsePathMap) }
+                : {}),
+        });
+        process.stdout.write(`${JSON.stringify({ mode: "merge", ...result }, null, 2)}\n`);
+        return;
+    }
+    throw new Error(`Unsupported command "${command}". Use pack or merge.`);
+}
+main().catch((error) => {
+    const message = error instanceof Error ? error.message : String(error);
+    process.stderr.write(`${message}\n`);
+    process.exitCode = 1;
+});

package/dist/migration.js

@@ -0,0 +1,690 @@
+import { createHash, randomUUID } from "node:crypto";
+import { spawn } from "node:child_process";
+import { chmod, copyFile, mkdtemp, mkdir, readFile, readdir, rm, stat, writeFile, } from "node:fs/promises";
+import { homedir } from "node:os";
+import { basename, dirname, extname, join, relative, resolve, } from "node:path";
+const MANIFEST_VERSION = "1";
+const PAYLOAD_DIRECTORY = "payload";
+const PORTABLE_NOTES = [
+    "Portable history and context are included by default.",
+    "Account auth, caches, debug logs, sqlite state, shell snapshots, and worktrees are excluded.",
+    "Use --path-map OLD=NEW during merge if project roots moved between machines.",
+];
+const CODEX_EXCLUSIONS = [
+    "auth.json",
+    "config.toml",
+    ".codex-global-state.json",
+    ".personality_migration",
+    "cache/**",
+    "log/**",
+    "logs_*.sqlite*",
+    "models_cache.json",
+    "shell_snapshots/**",
+    "sqlite/**",
+    "state_*.sqlite*",
+    "tmp/**",
+    "vendor_imports/**",
+    "version.json",
+    "worktrees/**",
+];
+const CLAUDE_EXCLUSIONS = [
+    "backups/**",
+    "cache/**",
+    "debug/**",
+    "plugins/**",
+    "settings.json",
+    "shell-snapshots/**",
+    "stats-cache.json",
+    "statsig/**",
+];
+const PATH_FIELD_NAMES = new Set(["cwd", "originalPath", "project"]);
+function expandProviders(provider) {
+    if (provider === "all") {
+        return ["codex", "claude"];
+    }
+    return [provider];
+}
+function normalizeRelativePath(value) {
+    return value.split("\\").join("/");
+}
+function resolveCodexHome(codexHome) {
+    if (codexHome?.trim()) {
+        return resolve(codexHome);
+    }
+    if (process.env.CODEX_HOME?.trim()) {
+        return resolve(process.env.CODEX_HOME);
+    }
+    return join(homedir(), ".codex");
+}
+async function ensureParentDirectory(filePath) {
+    await mkdir(dirname(filePath), { recursive: true });
+}
+async function pathExists(targetPath) {
+    try {
+        await stat(targetPath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function resolveClaudeConfigDir(claudeConfigDir) {
+    if (claudeConfigDir?.trim()) {
+        return resolve(claudeConfigDir);
+    }
+    if (process.env.CLAUDE_CONFIG_DIR?.trim()) {
+        return resolve(process.env.CLAUDE_CONFIG_DIR);
+    }
+    const dotClaude = join(homedir(), ".claude");
+    if (await pathExists(dotClaude)) {
+        return dotClaude;
+    }
+    return join(homedir(), ".config", "claude");
+}
+async function listAllFilesRecursive(rootDirectory) {
+    const files = [];
+    const stack = [rootDirectory];
+    while (stack.length > 0) {
+        const currentDirectory = stack.pop();
+        if (!currentDirectory) {
+            continue;
+        }
+        let entries;
+        try {
+            entries = await readdir(currentDirectory, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            const fullPath = join(currentDirectory, entry.name);
+            if (entry.isDirectory()) {
+                stack.push(fullPath);
+                continue;
+            }
+            if (entry.isFile()) {
+                files.push(fullPath);
+            }
+        }
+    }
+    return files.sort((left, right) => left.localeCompare(right));
+}
+async function describeFile(descriptor) {
+    const fileStats = await stat(descriptor.absolutePath);
+    const content = await readFile(descriptor.absolutePath);
+    return {
+        provider: descriptor.provider,
+        category: descriptor.category,
+        relativePath: descriptor.relativePath,
+        archivePath: `${PAYLOAD_DIRECTORY}/${descriptor.provider}/${descriptor.relativePath}`,
+        mergeStrategy: descriptor.relativePath.endsWith(".jsonl") ? "jsonl" : "copy",
+        size: fileStats.size,
+        sha256: createHash("sha256").update(content).digest("hex"),
+        mode: fileStats.mode & 0o777,
+        ...(descriptor.projectPath ? { projectPath: descriptor.projectPath } : {}),
+    };
+}
+async function addFileIfExists(descriptors, provider, providerRoot, relativePath, category, projectPath) {
+    const absolutePath = join(providerRoot, ...relativePath.split("/"));
+    if (!(await pathExists(absolutePath))) {
+        return;
+    }
+    descriptors.push({
+        provider,
+        category,
+        relativePath,
+        absolutePath,
+        ...(projectPath ? { projectPath } : {}),
+    });
+}
+async function addTreeIfExists(descriptors, provider, providerRoot, relativeRoot, category, projectPath) {
+    const absoluteRoot = join(providerRoot, ...relativeRoot.split("/"));
+    if (!(await pathExists(absoluteRoot))) {
+        return;
+    }
+    const files = await listAllFilesRecursive(absoluteRoot);
+    for (const absolutePath of files) {
+        const relativePath = normalizeRelativePath(relative(providerRoot, absolutePath));
+        descriptors.push({
+            provider,
+            category,
+            relativePath,
+            absolutePath,
+            ...(projectPath ? { projectPath } : {}),
+        });
+    }
+}
+function applyPathMapsToString(value, pathMaps) {
+    const normalizedValue = value.replaceAll("\\", "/");
+    for (const pathMap of pathMaps) {
+        if (normalizedValue === pathMap.from) {
+            return pathMap.to;
+        }
+        if (normalizedValue.startsWith(`${pathMap.from}/`)) {
+            return `${pathMap.to}${normalizedValue.slice(pathMap.from.length)}`;
+        }
+    }
+    return value;
+}
+function rewriteJsonPaths(value, pathMaps, currentKey) {
+    if (Array.isArray(value)) {
+        return value.map((item) => rewriteJsonPaths(item, pathMaps));
+    }
+    if (!value || typeof value !== "object") {
+        if (typeof value === "string" && currentKey && PATH_FIELD_NAMES.has(currentKey)) {
+            return applyPathMapsToString(value, pathMaps);
+        }
+        return value;
+    }
+    return Object.fromEntries(Object.entries(value).map(([key, entryValue]) => [
+        key,
+        rewriteJsonPaths(entryValue, pathMaps, key),
+    ]));
+}
+function getJsonSortKey(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return null;
+    }
+    const candidate = ["timestamp", "ts", "updated_at"]
+        .map((key) => value[key])
+        .find((entry) => typeof entry === "string" || typeof entry === "number");
+    if (typeof candidate === "number") {
+        return `n:${String(candidate).padStart(20, "0")}`;
+    }
+    if (typeof candidate !== "string") {
+        return null;
+    }
+    const parsed = Date.parse(candidate);
+    if (!Number.isNaN(parsed)) {
+        return `n:${String(parsed).padStart(20, "0")}`;
+    }
+    return `s:${candidate}`;
+}
+function transformJsonContent(content, pathMaps) {
+    const parsed = JSON.parse(content);
+    const rewritten = rewriteJsonPaths(parsed, pathMaps);
+    return `${JSON.stringify(rewritten, null, 2)}\n`;
+}
+function transformJsonlContent(content, pathMaps) {
+    const lines = content.split("\n");
+    const output = [];
+    for (const rawLine of lines) {
+        if (!rawLine.trim()) {
+            continue;
+        }
+        try {
+            const parsed = JSON.parse(rawLine);
+            const rewritten = rewriteJsonPaths(parsed, pathMaps);
+            output.push(JSON.stringify(rewritten));
+        }
+        catch {
+            output.push(rawLine);
+        }
+    }
+    return output.length === 0 ? "" : `${output.join("\n")}\n`;
+}
+async function readTransformedContent(sourcePath, relativePath, pathMaps) {
+    const content = await readFile(sourcePath);
+    if (pathMaps.length === 0) {
+        return content;
+    }
+    if (relativePath.endsWith(".json")) {
+        return Buffer.from(transformJsonContent(content.toString("utf8"), pathMaps), "utf8");
+    }
+    if (relativePath.endsWith(".jsonl")) {
+        return Buffer.from(transformJsonlContent(content.toString("utf8"), pathMaps), "utf8");
+    }
+    return content;
+}
+function parseJsonlRecords(content) {
+    const records = [];
+    for (const rawLine of content.split("\n")) {
+        if (!rawLine.trim()) {
+            continue;
+        }
+        try {
+            const parsed = JSON.parse(rawLine);
+            records.push({
+                line: JSON.stringify(parsed),
+                sortKey: getJsonSortKey(parsed),
+            });
+        }
+        catch {
+            records.push({
+                line: rawLine,
+                sortKey: null,
+            });
+        }
+    }
+    return records;
+}
+function getSessionRecordIdentity(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return null;
+    }
+    const record = value;
+    if (typeof record.sessionId === "string" && record.sessionId.trim()) {
+        return `sessionId:${record.sessionId}`;
+    }
+    if (typeof record.session_id === "string" && record.session_id.trim()) {
+        return `session_id:${record.session_id}`;
+    }
+    if (record.payload &&
+        typeof record.payload === "object" &&
+        !Array.isArray(record.payload)) {
+        const payload = record.payload;
+        if (typeof payload.sessionId === "string" && payload.sessionId.trim()) {
+            return `payload.sessionId:${payload.sessionId}`;
+        }
+        if (record.type === "session_meta" &&
+            typeof payload.id === "string" &&
+            payload.id.trim()) {
+            return `payload.id:${payload.id}`;
+        }
+    }
+    if (record.type === "session_meta" &&
+        typeof record.id === "string" &&
+        record.id.trim()) {
+        return `id:${record.id}`;
+    }
+    return null;
+}
+function extractSessionFileIdentity(content) {
+    for (const rawLine of content.split("\n")) {
+        if (!rawLine.trim()) {
+            continue;
+        }
+        try {
+            const parsed = JSON.parse(rawLine);
+            const identity = getSessionRecordIdentity(parsed);
+            if (identity) {
+                return identity;
+            }
+        }
+        catch {
+            continue;
+        }
+    }
+    return null;
+}
+function isSessionJsonlPath(relativePath) {
+    return (relativePath.endsWith(".jsonl") &&
+        (relativePath.startsWith("sessions/") ||
+            relativePath.startsWith("archived_sessions/") ||
+            relativePath.startsWith("projects/")));
+}
+function mergeJsonlContent(targetContent, sourceContent) {
+    const targetRecords = parseJsonlRecords(targetContent);
+    const sourceRecords = parseJsonlRecords(sourceContent);
+    const seen = new Set(targetRecords.map((record) => record.line));
+    const newRecords = sourceRecords.filter((record) => {
+        if (seen.has(record.line)) {
+            return false;
+        }
+        seen.add(record.line);
+        return true;
+    });
+    if (newRecords.length === 0) {
+        return { mergedContent: targetContent, changed: false };
+    }
+    const mergedRecords = [...targetRecords, ...newRecords];
+    const canSort = mergedRecords.every((record) => record.sortKey !== null);
+    if (canSort) {
+        mergedRecords.sort((left, right) => (left.sortKey ?? "").localeCompare(right.sortKey ?? ""));
+    }
+    return {
+        mergedContent: `${mergedRecords.map((record) => record.line).join("\n")}\n`,
+        changed: true,
+    };
+}
+function mergeSessionJsonlContent(targetContent, sourceContent) {
+    const targetIdentity = extractSessionFileIdentity(targetContent);
+    const sourceIdentity = extractSessionFileIdentity(sourceContent);
+    if (targetIdentity && sourceIdentity && targetIdentity === sourceIdentity) {
+        return {
+            mergedContent: sourceContent,
+            changed: targetContent !== sourceContent,
+        };
+    }
+    return mergeJsonlContent(targetContent, sourceContent);
+}
+function stripTrailingSlash(value) {
+    if (value.length <= 1) {
+        return value;
+    }
+    return value.replace(/\/+$/, "");
+}
+export function parsePathMap(value) {
+    const separatorIndex = value.indexOf("=");
+    if (separatorIndex <= 0 || separatorIndex === value.length - 1) {
+        throw new Error(`Invalid --path-map "${value}". Use OLD=NEW.`);
+    }
+    const from = stripTrailingSlash(resolve(value.slice(0, separatorIndex)));
+    const to = stripTrailingSlash(resolve(value.slice(separatorIndex + 1)));
+    return { from, to };
+}
+function encodeClaudeProjectDirectory(projectPath) {
+    return projectPath.replaceAll("\\", "/").replaceAll("/", "-");
+}
+async function inferProjectPathFromJsonl(sessionPath) {
+    const content = await readFile(sessionPath, "utf8");
+    for (const rawLine of content.split("\n")) {
+        if (!rawLine.trim()) {
+            continue;
+        }
+        try {
+            const parsed = JSON.parse(rawLine);
+            const directProject = typeof parsed.project === "string"
+                ? parsed.project
+                : typeof parsed.cwd === "string"
+                    ? parsed.cwd
+                    : null;
+            if (directProject) {
+                return directProject;
+            }
+            if (parsed.payload &&
+                typeof parsed.payload === "object" &&
+                !Array.isArray(parsed.payload) &&
+                typeof parsed.payload.cwd === "string") {
+                const payload = parsed.payload;
+                return payload.cwd;
+            }
+        }
+        catch {
+            continue;
+        }
+    }
+    return null;
+}
+async function getClaudeProjectPaths(claudeRoot) {
+    const projectRoot = join(claudeRoot, "projects");
+    const projectPaths = new Map();
+    let projectEntries;
+    try {
+        projectEntries = await readdir(projectRoot, { withFileTypes: true });
+    }
+    catch {
+        return projectPaths;
+    }
+    for (const entry of projectEntries) {
+        if (!entry.isDirectory()) {
+            continue;
+        }
+        const projectDirectory = join(projectRoot, entry.name);
+        const sessionsIndexPath = join(projectDirectory, "sessions-index.json");
+        if (await pathExists(sessionsIndexPath)) {
+            try {
+                const sessionsIndex = JSON.parse(await readFile(sessionsIndexPath, "utf8"));
+                if (typeof sessionsIndex.originalPath === "string") {
+                    projectPaths.set(entry.name, sessionsIndex.originalPath);
+                    continue;
+                }
+            }
+            catch {
+                // Ignore malformed indexes and fall back to session inspection.
+            }
+        }
+        const files = await listAllFilesRecursive(projectDirectory);
+        const sessionFile = files.find((filePath) => filePath.endsWith(".jsonl"));
+        if (!sessionFile) {
+            continue;
+        }
+        const projectPath = await inferProjectPathFromJsonl(sessionFile);
+        if (projectPath) {
+            projectPaths.set(entry.name, projectPath);
+        }
+    }
+    return projectPaths;
+}
+async function collectCodexDescriptors(codexRoot) {
+    const descriptors = [];
+    await addTreeIfExists(descriptors, "codex", codexRoot, "sessions", "history");
+    await addTreeIfExists(descriptors, "codex", codexRoot, "archived_sessions", "history");
+    await addFileIfExists(descriptors, "codex", codexRoot, "history.jsonl", "history");
+    await addFileIfExists(descriptors, "codex", codexRoot, "session_index.jsonl", "history");
+    await addTreeIfExists(descriptors, "codex", codexRoot, "memories", "context");
+    await addTreeIfExists(descriptors, "codex", codexRoot, "automations", "context");
+    await addFileIfExists(descriptors, "codex", codexRoot, "AGENTS.md", "context");
+    await addTreeIfExists(descriptors, "codex", codexRoot, "rules", "context");
+    await addTreeIfExists(descriptors, "codex", codexRoot, "policy", "context");
+    await addTreeIfExists(descriptors, "codex", codexRoot, "skills", "skills");
+    return descriptors;
+}
+async function collectClaudeDescriptors(claudeRoot) {
+    const descriptors = [];
+    const projectPaths = await getClaudeProjectPaths(claudeRoot);
+    const projectRoot = join(claudeRoot, "projects");
+    if (await pathExists(projectRoot)) {
+        let projectEntries = [];
+        try {
+            projectEntries = await readdir(projectRoot, { withFileTypes: true });
+        }
+        catch {
+            // Ignore unreadable project roots and fall back to top-level files.
+        }
+        for (const entry of projectEntries) {
+            if (!entry.isDirectory()) {
+                continue;
+            }
+            await addTreeIfExists(descriptors, "claude", claudeRoot, `projects/${entry.name}`, "history", projectPaths.get(entry.name));
+        }
+    }
+    await addFileIfExists(descriptors, "claude", claudeRoot, "history.jsonl", "history");
+    await addTreeIfExists(descriptors, "claude", claudeRoot, "todos", "history");
+    return descriptors;
+}
+async function collectManifest(providers, roots) {
+    const descriptors = (await Promise.all(providers.map((provider) => provider === "codex"
+        ? collectCodexDescriptors(roots.codex)
+        : collectClaudeDescriptors(roots.claude)))).flat();
+    const files = await Promise.all(descriptors.map((descriptor) => describeFile(descriptor)));
+    files.sort((left, right) => left.archivePath.localeCompare(right.archivePath));
+    return {
+        version: MANIFEST_VERSION,
+        bundleId: `${new Date().toISOString().replaceAll(/[:.]/g, "-")}-${randomUUID()}`,
+        createdAt: new Date().toISOString(),
+        notes: PORTABLE_NOTES,
+        exclusions: {
+            codex: CODEX_EXCLUSIONS,
+            claude: CLAUDE_EXCLUSIONS,
+        },
+        files,
+    };
+}
+async function runTar(args, workingDirectory) {
+    await new Promise((resolvePromise, rejectPromise) => {
+        const child = spawn("tar", args, {
+            cwd: workingDirectory,
+            env: {
+                ...process.env,
+                LANG: process.env.LANG ?? "C",
+                LC_ALL: process.env.LC_ALL ?? "C",
+            },
+            stdio: ["ignore", "ignore", "pipe"],
+        });
+        const stderrChunks = [];
+        child.stderr.on("data", (chunk) => {
+            stderrChunks.push(chunk);
+        });
+        child.on("error", rejectPromise);
+        child.on("exit", (code) => {
+            if (code === 0) {
+                resolvePromise();
+                return;
+            }
+            const stderr = Buffer.concat(stderrChunks).toString("utf8").trim();
+            rejectPromise(new Error(stderr || `tar exited with status ${code ?? "unknown"}.`));
+        });
+    });
+}
+function getArchiveCompression(archivePath) {
+    const normalized = archivePath.toLowerCase();
+    if (normalized.endsWith(".tar")) {
+        return "none";
+    }
+    return "gz";
+}
+async function writeBundleArchive(stagingDirectory, outputPath) {
+    const compression = getArchiveCompression(outputPath);
+    const args = compression === "gz"
+        ? ["-czf", outputPath, "-C", stagingDirectory, "."]
+        : ["-cf", outputPath, "-C", stagingDirectory, "."];
+    await runTar(args, stagingDirectory);
+}
+async function extractBundleArchive(inputPath, extractDirectory) {
+    const compression = getArchiveCompression(inputPath);
+    const args = compression === "gz"
+        ? ["-xzf", inputPath, "-C", extractDirectory]
+        : ["-xf", inputPath, "-C", extractDirectory];
+    await runTar(args, extractDirectory);
+}
+function resolveProviderRoot(provider, roots) {
+    return provider === "codex" ? roots.codex : roots.claude;
+}
+function getTargetRelativePath(entry, pathMaps) {
+    if (entry.provider !== "claude" ||
+        pathMaps.length === 0 ||
+        !entry.relativePath.startsWith("projects/") ||
+        !entry.projectPath) {
+        return entry.relativePath;
+    }
+    const mappedProjectPath = applyPathMapsToString(entry.projectPath, pathMaps);
+    if (mappedProjectPath === entry.projectPath) {
+        return entry.relativePath;
+    }
+    const parts = entry.relativePath.split("/");
+    if (parts.length < 2) {
+        return entry.relativePath;
+    }
+    const remainder = parts.slice(2);
+    return ["projects", encodeClaudeProjectDirectory(mappedProjectPath), ...remainder].join("/");
+}
+function getConflictPath(targetPath, bundleId) {
+    const extension = extname(targetPath);
+    const stem = extension ? basename(targetPath, extension) : basename(targetPath);
+    const suffix = bundleId.slice(0, 12);
+    return join(dirname(targetPath), extension
+        ? `${stem}.imported-${suffix}${extension}`
+        : `${stem}.imported-${suffix}`);
+}
+async function writeTargetFile(targetPath, content, mode) {
+    await ensureParentDirectory(targetPath);
+    await writeFile(targetPath, content);
+    await chmod(targetPath, mode);
+}
+async function withTemporaryDirectory(prefix, fn) {
+    const directory = await mkdtemp(join(process.env.TMPDIR ?? "/tmp", prefix));
+    try {
+        return await fn(directory);
+    }
+    finally {
+        await rm(directory, { recursive: true, force: true });
+    }
+}
+export async function packMigrationArchive(options) {
+    const providers = expandProviders(options.provider);
+    const roots = {
+        codex: resolveCodexHome(options.codexHome),
+        claude: await resolveClaudeConfigDir(options.claudeConfigDir),
+    };
+    const manifest = await collectManifest(providers, roots);
+    if (manifest.files.length === 0) {
+        throw new Error("No portable Codex or Claude Code data was found to package.");
+    }
+    const outputPath = resolve(options.outputPath);
+    await ensureParentDirectory(outputPath);
+    await withTemporaryDirectory("codex-mover-pack-", async (stagingDirectory) => {
+        await mkdir(join(stagingDirectory, PAYLOAD_DIRECTORY), { recursive: true });
+        for (const entry of manifest.files) {
+            const providerRoot = resolveProviderRoot(entry.provider, roots);
+            const sourcePath = join(providerRoot, ...entry.relativePath.split("/"));
+            const destinationPath = join(stagingDirectory, ...entry.archivePath.split("/"));
+            await ensureParentDirectory(destinationPath);
+            await copyFile(sourcePath, destinationPath);
+        }
+        await writeFile(join(stagingDirectory, "manifest.json"), `${JSON.stringify(manifest, null, 2)}\n`, "utf8");
+        await writeBundleArchive(stagingDirectory, outputPath);
+    });
+    return {
+        outputPath,
+        manifest,
+    };
+}
+async function loadManifest(extractedDirectory) {
+    const manifestPath = join(extractedDirectory, "manifest.json");
+    if (!(await pathExists(manifestPath))) {
+        throw new Error("Archive is missing manifest.json.");
+    }
+    const manifest = JSON.parse(await readFile(manifestPath, "utf8"));
+    if (manifest.version !== MANIFEST_VERSION || !Array.isArray(manifest.files)) {
+        throw new Error("Archive manifest is invalid or unsupported.");
+    }
+    return manifest;
+}
+export async function mergeMigrationArchive(options) {
+    const providers = expandProviders(options.provider);
+    const pathMaps = [...(options.pathMaps ?? [])].sort((left, right) => right.from.length - left.from.length);
+    const roots = {
+        codex: resolveCodexHome(options.codexHome),
+        claude: await resolveClaudeConfigDir(options.claudeConfigDir),
+    };
+    const inputPath = resolve(options.inputPath);
+    return withTemporaryDirectory("codex-mover-merge-", async (extractDirectory) => {
+        await extractBundleArchive(inputPath, extractDirectory);
+        const manifest = await loadManifest(extractDirectory);
+        const result = {
+            inputPath,
+            bundleId: manifest.bundleId,
+            providers,
+            copied: 0,
+            merged: 0,
+            skipped: 0,
+            conflicts: 0,
+            filesProcessed: 0,
+        };
+        for (const entry of manifest.files) {
+            if (!providers.includes(entry.provider)) {
+                continue;
+            }
+            const providerRoot = resolveProviderRoot(entry.provider, roots);
+            const targetRelativePath = getTargetRelativePath(entry, pathMaps);
+            const sourcePath = join(extractDirectory, ...entry.archivePath.split("/"));
+            const targetPath = join(providerRoot, ...targetRelativePath.split("/"));
+            const sourceContent = await readTransformedContent(sourcePath, targetRelativePath, pathMaps);
+            result.filesProcessed += 1;
+            if (!(await pathExists(targetPath))) {
+                await writeTargetFile(targetPath, sourceContent, entry.mode);
+                result.copied += 1;
+                continue;
+            }
+            const targetContent = await readFile(targetPath);
+            if (targetContent.equals(sourceContent)) {
+                result.skipped += 1;
+                continue;
+            }
+            if (entry.mergeStrategy === "jsonl") {
+                const merged = isSessionJsonlPath(targetRelativePath)
+                    ? mergeSessionJsonlContent(targetContent.toString("utf8"), sourceContent.toString("utf8"))
+                    : mergeJsonlContent(targetContent.toString("utf8"), sourceContent.toString("utf8"));
+                if (!merged.changed) {
+                    result.skipped += 1;
+                    continue;
+                }
+                await writeTargetFile(targetPath, Buffer.from(merged.mergedContent, "utf8"), entry.mode);
+                result.merged += 1;
+                continue;
+            }
+            const conflictPath = getConflictPath(targetPath, manifest.bundleId);
+            if (await pathExists(conflictPath)) {
+                const existingConflict = await readFile(conflictPath);
+                if (existingConflict.equals(sourceContent)) {
+                    result.skipped += 1;
+                    continue;
+                }
+            }
+            await writeTargetFile(conflictPath, sourceContent, entry.mode);
+            result.conflicts += 1;
+        }
+        return result;
+    });
+}

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "@propel-code/codex-mover",
+  "version": "0.1.0",
+  "description": "Package and merge portable Codex and Claude Code history/context between machines.",
+  "type": "module",
+  "packageManager": "bun@1.3.9",
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE",
+    "package.json"
+  ],
+  "bin": {
+    "codex-mover": "./dist/bin.js",
+    "codeport": "./dist/bin.js"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "dev": "bun --watch ./src/cli.ts",
+    "start": "bun ./src/cli.ts",
+    "test": "bun test --timeout 20000",
+    "typecheck": "tsc --noEmit",
+    "check": "bun test --timeout 20000 && bun run typecheck",
+    "prepack": "npm run build"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "keywords": [
+    "codex",
+    "claude",
+    "cli",
+    "migration",
+    "portable",
+    "backup"
+  ],
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/propel-gtm/codex-mover.git"
+  },
+  "homepage": "https://github.com/propel-gtm/codex-mover#readme",
+  "bugs": {
+    "url": "https://github.com/propel-gtm/codex-mover/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "@types/node": "^24.12.0",
+    "typescript": "^5.9.3"
+  }
+}