bisync-cli 0.0.10 → 0.0.12

package/dist/bisync.js

@@ -2,207 +2,52 @@
 // @bun
 
 // src/bin.ts
-import { createHash } from "crypto";
-import { createWriteStream, mkdirSync } from "fs";
-import { readdir, stat } from "fs/promises";
-import { homedir } from "os";
-import { join, relative, resolve, sep } from "path";
+import { appendFileSync, mkdirSync } from "fs";
+import { homedir as homedir3 } from "os";
+import { join as join3, resolve as resolve2 } from "path";
 import { createInterface } from "readline";
 import { setTimeout } from "timers/promises";
 import { parseArgs as parseArgsUtil } from "util";
 // package.json
-var version = "0.0.9";
-
-// src/bin.ts
-var CONFIG_DIR = join(homedir(), ".agent-bisync");
-var CONFIG_PATH = join(CONFIG_DIR, "config.json");
-var CLAUDE_SETTINGS_PATH = join(homedir(), ".claude", "settings.json");
-var CLAUDE_PROJECTS_DIR = join(homedir(), ".claude", "projects");
-var DEBUG_LOG_PATH = join(CONFIG_DIR, "debug.log");
-var CLIENT_ID = "bisync-cli";
-var MAX_LINES_PER_BATCH = 200;
-var parseArgs = () => {
-  const parsed = parseArgsUtil({
-    args: process.argv.slice(2),
-    options: {
-      verbose: { type: "boolean" },
-      version: { type: "boolean" },
-      help: { type: "boolean" },
-      force: { type: "boolean" },
-      "site-url": { type: "string" },
-      siteUrl: { type: "string" }
-    },
-    allowPositionals: true
-  });
-  const values = parsed.values;
-  const positionals = parsed.positionals;
-  return { values, positionals };
-};
-var printUsage = () => {
-  console.log(`bisync <command>
-
-Commands:
-  auth login --site-url <url>   Authenticate via device flow
-  auth logout                   Sign out of the CLI
-  session list                  List session ids
-  setup --site-url <url>        Configure hooks and authenticate
-  hook <HOOK>                   Handle Claude hook input (stdin JSON)
+var version = "0.0.11";
 
-Global options:
-  --verbose                Enable verbose logging
-  --help                   Show usage
+// src/claude.ts
+import { readdir, stat } from "fs/promises";
+import { homedir } from "os";
+import { join, relative, sep } from "path";
 
-Version: ${version} (Bun ${Bun.version})
-`);
-};
-var LOG_LEVEL = "info";
-var debugLogStream = null;
-var getDebugLogStream = () => {
-  if (debugLogStream)
-    return debugLogStream;
-  try {
-    mkdirSync(CONFIG_DIR, { recursive: true });
-    debugLogStream = createWriteStream(DEBUG_LOG_PATH, { flags: "a" });
-    debugLogStream.on("error", () => {
-      debugLogStream = null;
-    });
-    return debugLogStream;
-  } catch {
-    return null;
-  }
-};
-var log = (level, message, fields) => {
-  let logMessage = `[${level}] ${message}`;
-  if (fields) {
-    for (const [key, value] of Object.entries(fields)) {
-      logMessage += ` ${key}=${value}`;
-    }
-  }
-  getDebugLogStream()?.write(`[${new Date().toISOString()}]${logMessage}
-`);
-  if (level < LOG_LEVEL) {
-    return;
-  }
-  console.log(`[bisync]${logMessage}`);
-};
-var readConfig = async () => {
-  return await Bun.file(CONFIG_PATH).json();
-};
-var writeConfig = async (config) => {
-  await Bun.write(CONFIG_PATH, JSON.stringify(config, null, 2), {
-    createPath: true
-  });
-};
-var readConfigIfExists = async () => {
-  const configFile = Bun.file(CONFIG_PATH);
-  if (!await configFile.exists()) {
-    return null;
-  }
-  try {
-    return await configFile.json();
-  } catch {
-    return null;
-  }
-};
-var promptYesNo = async (question, defaultValue) => {
-  if (!process.stdin.isTTY) {
-    log("warn", `${question} Using default ${defaultValue ? "yes" : "no"} (stdin not interactive).`);
-    return defaultValue;
-  }
-  const suffix = defaultValue ? " [Y/n] " : " [y/N] ";
-  const rl = createInterface({ input: process.stdin, output: process.stdout });
-  const answer = await new Promise((resolve2) => rl.question(`${question}${suffix}`, resolve2));
-  rl.close();
-  const normalized = answer.trim().toLowerCase();
-  if (!normalized) {
-    return defaultValue;
-  }
-  return normalized === "y" || normalized === "yes";
-};
-var resolveSiteUrl = (args) => {
-  const argValue = args["site-url"] ?? args.siteUrl;
-  const envValue = process.env.BISYNC_SITE_URL;
-  if (argValue) {
-    return { siteUrl: argValue, source: "arg" };
-  }
-  if (envValue) {
-    return { siteUrl: envValue, source: "env" };
-  }
-  return { siteUrl: null, source: "missing" };
-};
-var openBrowser = async (url) => {
-  if (process.platform !== "darwin") {
-    return;
-  }
-  try {
-    await Bun.$`open ${url}`;
-  } catch {}
-};
-var buildVerificationUrl = (data) => {
-  if (data.verification_uri_complete) {
-    return data.verification_uri_complete;
-  }
-  try {
-    const url = new URL(data.verification_uri);
-    url.searchParams.set("user_code", data.user_code);
-    return url.toString();
-  } catch {
-    const separator = data.verification_uri.includes("?") ? "&" : "?";
-    return `${data.verification_uri}${separator}user_code=${encodeURIComponent(data.user_code)}`;
-  }
-};
-var deviceAuthFlow = async (siteUrl) => {
-  log("debug", `device auth start`, { siteUrl });
-  const codeResponse = await fetch(`${siteUrl}/api/auth/device/code`, {
-    method: "POST",
-    headers: { "Content-Type": "application/json" },
-    body: JSON.stringify({ client_id: CLIENT_ID })
-  });
-  if (!codeResponse.ok) {
-    const errorText = await codeResponse.text();
-    log("debug", `device code request failed`, { status: codeResponse.status });
-    throw new Error(`Device code request failed: ${codeResponse.status} ${errorText}`);
+// src/shared.ts
+import { createHash } from "crypto";
+var buildStateFilesFromCollection = async (files, kind, siteUrl, token, helpers) => {
+  if (files.length === 0) {
+    return [];
   }
-  log("debug", `device code request ok`, { status: codeResponse.status });
-  const codeData = await codeResponse.json();
-  const verificationUrl = buildVerificationUrl(codeData);
-  console.log(`Authorize this device: ${verificationUrl}`);
-  console.log(`Your Verification Code: ${codeData.user_code}`);
-  await openBrowser(verificationUrl);
-  const intervalMs = Math.max(1, codeData.interval ?? 5) * 1000;
-  log("debug", `device auth polling`, { intervalMs });
-  let pollDelay = intervalMs;
-  while (true) {
-    await setTimeout(pollDelay);
-    const tokenResponse = await fetch(`${siteUrl}/api/auth/device/token`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({
-        grant_type: "urn:ietf:params:oauth:grant-type:device_code",
-        device_code: codeData.device_code,
-        client_id: CLIENT_ID
-      })
-    });
-    const tokenData = await tokenResponse.json();
-    if (tokenResponse.ok && tokenData.access_token) {
-      log("debug", `device auth success`, { status: tokenResponse.status });
-      return tokenData.access_token;
-    }
-    if (tokenData.error === "authorization_pending") {
-      continue;
-    }
-    if (tokenData.error === "slow_down") {
-      pollDelay += 1000;
-      log("debug", `device auth slow_down`, { nextDelayMs: pollDelay });
-      continue;
+  const uploadUrls = await helpers.getStateUploadUrls(siteUrl, token, files.length);
+  const entries = [];
+  for (let index = 0;index < files.length; index += 1) {
+    const file = files[index];
+    const uploadUrl = uploadUrls[index];
+    if (!file || !uploadUrl) {
+      throw new Error("Upload URL list did not match file list");
     }
-    log("debug", `device auth failed`, {
-      status: tokenResponse.status,
-      error: tokenData.error ?? "unknown"
+    const data = new Uint8Array(await Bun.file(file.fullPath).arrayBuffer());
+    const fileHash = createHash("sha256").update(data).digest("hex");
+    const storageId = await helpers.uploadStateFileToUrl(uploadUrl, file.fullPath);
+    entries.push({
+      path: file.relativePath,
+      fileHash,
+      storageId,
+      size: file.size,
+      mtimeMs: file.mtimeMs,
+      kind
     });
-    throw new Error(`Device auth failed: ${tokenData.error ?? "unknown"} ${tokenData.error_description ?? ""}`.trim());
   }
+  return entries;
 };
+
+// src/claude.ts
+var CLAUDE_SETTINGS_PATH = join(homedir(), ".claude", "settings.json");
+var CLAUDE_PROJECTS_DIR = join(homedir(), ".claude", "projects");
 var ensureHookEntry = (entries, next) => {
   const sameMatcher = (entry) => (entry.matcher ?? null) === (next.matcher ?? null);
   const command = next.hooks[0]?.command;
@@ -219,7 +64,7 @@ var ensureHookEntry = (entries, next) => {
   }
   return entries;
 };
-var mergeSettings = async () => {
+var mergeClaudeSettings = async (log, options) => {
   log("debug", `mergeSettings`, { path: CLAUDE_SETTINGS_PATH });
   const settingsFile = Bun.file(CLAUDE_SETTINGS_PATH);
   const settingsExists = await settingsFile.exists();
@@ -256,7 +101,14 @@ var mergeSettings = async () => {
     enabledPlugins: current.enabledPlugins ?? {},
     hooks
   };
-  await Bun.write(CLAUDE_SETTINGS_PATH, JSON.stringify(nextConfig, null, 2), {
+  const serialized = JSON.stringify(nextConfig, null, 2);
+  if (options?.dry) {
+    console.log(`# ${CLAUDE_SETTINGS_PATH}`);
+    console.log(serialized);
+    log("debug", `mergeSettings dry run complete`);
+    return;
+  }
+  await Bun.write(CLAUDE_SETTINGS_PATH, serialized, {
     createPath: true
   });
   log("debug", `mergeSettings wrote settings`);
@@ -272,7 +124,7 @@ var mergeSettings = async () => {
     });
   }
 };
-var findSessionFile = async (sessionId) => {
+var findClaudeSessionFile = async (sessionId) => {
   let bestPath = null;
   let bestMtimeMs = 0;
   const targetName = `${sessionId}.jsonl`;
@@ -309,14 +161,14 @@ var isDirectory = async (path) => {
     return false;
   }
 };
-var resolveSessionDir = async (sessionFile) => {
+var resolveClaudeSessionDir = async (sessionFile) => {
   if (!sessionFile.endsWith(".jsonl")) {
     return null;
   }
   const candidate = sessionFile.slice(0, -".jsonl".length);
   return await isDirectory(candidate) ? candidate : null;
 };
-var findSessionDir = async (sessionId) => {
+var findClaudeSessionDir = async (sessionId) => {
   let bestPath = null;
   let bestMtimeMs = 0;
   const walk = async (dir) => {
@@ -345,7 +197,7 @@ var findSessionDir = async (sessionId) => {
   return bestPath;
 };
 var normalizePath = (value) => value.split(sep).join("/");
-var collectSessionStateFiles = async (sessionDir) => {
+var collectClaudeStateFiles = async (sessionDir) => {
   const files = [];
   const walk = async (dir) => {
     let entries;
@@ -375,6 +227,329 @@ var collectSessionStateFiles = async (sessionDir) => {
   await walk(sessionDir);
   return files;
 };
+var buildClaudeStateFiles = async (sessionDir, siteUrl, token, helpers) => {
+  const files = await collectClaudeStateFiles(sessionDir);
+  return buildStateFilesFromCollection(files, "claude-state", siteUrl, token, helpers);
+};
+
+// src/codex.ts
+import { stat as stat2 } from "fs/promises";
+import { homedir as homedir2, userInfo } from "os";
+import { join as join2, resolve } from "path";
+var resolveHomeDir = () => {
+  const envHome = process.env.HOME ?? process.env.USERPROFILE;
+  if (envHome) {
+    return envHome;
+  }
+  try {
+    return userInfo().homedir;
+  } catch {
+    return homedir2();
+  }
+};
+var CODEX_HOME = process.env.CODEX_HOME ? resolve(process.env.CODEX_HOME) : join2(resolveHomeDir(), ".codex");
+var CODEX_CONFIG_PATH = join2(CODEX_HOME, "config.toml");
+var CODEX_SESSIONS_DIR = join2(CODEX_HOME, "sessions");
+var CODEX_ARCHIVED_SESSIONS_DIR = join2(CODEX_HOME, "archived_sessions");
+var CODEX_STATE_FILES = ["state.sqlite", "session_index.jsonl", "history.jsonl"];
+var CODEX_NOTIFY_COMMAND = ["bisync", "hook", "Codex"];
+var getCodexPaths = () => ({
+  home: CODEX_HOME,
+  sessionsDir: CODEX_SESSIONS_DIR,
+  archivedSessionsDir: CODEX_ARCHIVED_SESSIONS_DIR
+});
+var mergeCodexConfig = async (force, log, options) => {
+  let current = {};
+  const configFile = Bun.file(CODEX_CONFIG_PATH);
+  if (await configFile.exists()) {
+    try {
+      const parsed = Bun.TOML.parse(await configFile.text());
+      if (parsed && typeof parsed === "object") {
+        current = parsed;
+      }
+    } catch (error) {
+      log("debug", "mergeCodexConfig parse failed", {
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  const existingNotify = current.notify;
+  const isArray = Array.isArray(existingNotify);
+  const matches = isArray && existingNotify.length === CODEX_NOTIFY_COMMAND.length && existingNotify.every((value, index) => value === CODEX_NOTIFY_COMMAND[index]);
+  const hasNotify = Object.prototype.hasOwnProperty.call(current, "notify");
+  if (!force && hasNotify) {
+    if (matches) {
+      log("debug", "mergeCodexConfig notify already configured");
+      return;
+    }
+    log("debug", "mergeCodexConfig existing notify preserved");
+    return;
+  }
+  const nextConfig = {
+    ...current,
+    notify: CODEX_NOTIFY_COMMAND
+  };
+  try {
+    const tomlStringify = Bun.TOML.stringify ?? ((obj) => {
+      const lines = [];
+      for (const [key, value] of Object.entries(obj)) {
+        if (Array.isArray(value)) {
+          const items = value.map((v) => typeof v === "string" ? `"${v.replace(/\\/g, "\\\\").replace(/"/g, "\\\"")}"` : String(v));
+          lines.push(`${key} = [${items.join(", ")}]`);
+        } else if (typeof value === "string") {
+          lines.push(`${key} = "${value.replace(/\\/g, "\\\\").replace(/"/g, "\\\"")}"`);
+        } else if (typeof value === "number" || typeof value === "boolean") {
+          lines.push(`${key} = ${value}`);
+        }
+      }
+      return lines.join(`
+`) + `
+`;
+    });
+    const serialized = tomlStringify(nextConfig);
+    if (options?.dry) {
+      console.log(`# ${CODEX_CONFIG_PATH}`);
+      console.log(serialized);
+      log("debug", "mergeCodexConfig dry run complete");
+      return;
+    }
+    await Bun.write(CODEX_CONFIG_PATH, serialized, { createPath: true });
+    log("debug", "mergeCodexConfig wrote config");
+  } catch (error) {
+    log("debug", "mergeCodexConfig write failed", {
+      error: error instanceof Error ? error.message : String(error)
+    });
+  }
+};
+var findCodexRolloutFile = async (threadId, options) => {
+  const log = options?.log;
+  const roots = [CODEX_SESSIONS_DIR, CODEX_ARCHIVED_SESSIONS_DIR];
+  const glob = new Bun.Glob(`**/rollout-*-${threadId}.jsonl`);
+  let bestPath = null;
+  let bestMtimeMs = 0;
+  for (const root of roots) {
+    try {
+      for await (const match of glob.scan({ cwd: root, absolute: true })) {
+        const info = await stat2(match);
+        if (!bestPath || info.mtimeMs > bestMtimeMs) {
+          bestPath = match;
+          bestMtimeMs = info.mtimeMs;
+        }
+      }
+    } catch (error) {
+      log?.("debug", "findCodexRolloutFile scan failed", {
+        root,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  return bestPath;
+};
+var collectCodexStateFiles = async () => {
+  const files = [];
+  for (const name of CODEX_STATE_FILES) {
+    const fullPath = join2(CODEX_HOME, name);
+    try {
+      const info = await stat2(fullPath);
+      if (!info.isFile()) {
+        continue;
+      }
+      files.push({
+        fullPath,
+        relativePath: name,
+        size: info.size,
+        mtimeMs: info.mtimeMs
+      });
+    } catch {}
+  }
+  return files;
+};
+var buildCodexStateFiles = async (siteUrl, token, helpers) => {
+  const files = await collectCodexStateFiles();
+  return buildStateFilesFromCollection(files, "codex-state", siteUrl, token, helpers);
+};
+
+// src/bin.ts
+var CONFIG_DIR = join3(homedir3(), ".agent-bisync");
+var CONFIG_PATH = join3(CONFIG_DIR, "config.json");
+var DEBUG_LOG_PATH = join3(CONFIG_DIR, "debug.log");
+var CLIENT_ID = "bisync-cli";
+var MAX_LINES_PER_BATCH = 200;
+var parseArgs = () => {
+  const parsed = parseArgsUtil({
+    args: process.argv.slice(2),
+    options: {
+      verbose: { type: "boolean" },
+      version: { type: "boolean" },
+      help: { type: "boolean" },
+      force: { type: "boolean" },
+      dry: { type: "boolean" },
+      "site-url": { type: "string" },
+      siteUrl: { type: "string" }
+    },
+    allowPositionals: true
+  });
+  const values = parsed.values;
+  const positionals = parsed.positionals;
+  return { values, positionals };
+};
+var printUsage = () => {
+  console.log(`bisync <command>
+
+Commands:
+  auth login --site-url <url>   Authenticate via device flow
+  auth logout                   Sign out of the CLI
+  session list                  List session ids
+  setup [claude|codex] --site-url <url>  Configure hooks and authenticate
+  hook <HOOK>                   Handle Claude/Codex hook input (stdin JSON)
+
+Global options:
+  --verbose                Enable verbose logging
+  --dry                    Print updated configs instead of writing files
+  --help                   Show usage
+
+Version: ${version} (Bun ${Bun.version})
+`);
+};
+var LOG_LEVEL = "info";
+var appendDebugLog = (line) => {
+  try {
+    mkdirSync(CONFIG_DIR, { recursive: true });
+    appendFileSync(DEBUG_LOG_PATH, line);
+  } catch {}
+};
+var log = (level, message, fields) => {
+  let logMessage = `[${level}] ${message}`;
+  if (fields) {
+    for (const [key, value] of Object.entries(fields)) {
+      logMessage += ` ${key}=${value}`;
+    }
+  }
+  appendDebugLog(`[${new Date().toISOString()}]${logMessage}
+`);
+  if (level < LOG_LEVEL) {
+    return;
+  }
+  console.log(`[bisync]${logMessage}`);
+};
+var readConfig = async () => {
+  return await Bun.file(CONFIG_PATH).json();
+};
+var writeConfig = async (config) => {
+  await Bun.write(CONFIG_PATH, JSON.stringify(config, null, 2), {
+    createPath: true
+  });
+};
+var readConfigIfExists = async () => {
+  const configFile = Bun.file(CONFIG_PATH);
+  if (!await configFile.exists()) {
+    return null;
+  }
+  try {
+    return await configFile.json();
+  } catch {
+    return null;
+  }
+};
+var promptYesNo = async (question, defaultValue) => {
+  if (!process.stdin.isTTY) {
+    log("warn", `${question} Using default ${defaultValue ? "yes" : "no"} (stdin not interactive).`);
+    return defaultValue;
+  }
+  const suffix = defaultValue ? " [Y/n] " : " [y/N] ";
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  const answer = await new Promise((resolve3) => rl.question(`${question}${suffix}`, resolve3));
+  rl.close();
+  const normalized = answer.trim().toLowerCase();
+  if (!normalized) {
+    return defaultValue;
+  }
+  return normalized === "y" || normalized === "yes";
+};
+var resolveSiteUrl = (args) => {
+  const argValue = args["site-url"] ?? args.siteUrl;
+  const envValue = process.env.BISYNC_SITE_URL;
+  if (argValue) {
+    return { siteUrl: argValue, source: "arg" };
+  }
+  if (envValue) {
+    return { siteUrl: envValue, source: "env" };
+  }
+  return { siteUrl: null, source: "missing" };
+};
+var openBrowser = async (url) => {
+  if (process.platform !== "darwin") {
+    return;
+  }
+  try {
+    await Bun.$`open ${url}`;
+  } catch {}
+};
+var buildVerificationUrl = (data) => {
+  if (data.verification_uri_complete) {
+    return data.verification_uri_complete;
+  }
+  try {
+    const url = new URL(data.verification_uri);
+    url.searchParams.set("user_code", data.user_code);
+    return url.toString();
+  } catch {
+    const separator = data.verification_uri.includes("?") ? "&" : "?";
+    return `${data.verification_uri}${separator}user_code=${encodeURIComponent(data.user_code)}`;
+  }
+};
+var deviceAuthFlow = async (siteUrl) => {
+  log("debug", `device auth start`, { siteUrl });
+  const codeResponse = await fetch(`${siteUrl}/api/auth/device/code`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ client_id: CLIENT_ID })
+  });
+  if (!codeResponse.ok) {
+    const errorText = await codeResponse.text();
+    log("debug", `device code request failed`, { status: codeResponse.status });
+    throw new Error(`Device code request failed: ${codeResponse.status} ${errorText}`);
+  }
+  log("debug", `device code request ok`, { status: codeResponse.status });
+  const codeData = await codeResponse.json();
+  const verificationUrl = buildVerificationUrl(codeData);
+  console.log(`Authorize this device: ${verificationUrl}`);
+  console.log(`Your Verification Code: ${codeData.user_code}`);
+  await openBrowser(verificationUrl);
+  const intervalMs = Math.max(1, codeData.interval ?? 5) * 1000;
+  log("debug", `device auth polling`, { intervalMs });
+  let pollDelay = intervalMs;
+  while (true) {
+    await setTimeout(pollDelay);
+    const tokenResponse = await fetch(`${siteUrl}/api/auth/device/token`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        grant_type: "urn:ietf:params:oauth:grant-type:device_code",
+        device_code: codeData.device_code,
+        client_id: CLIENT_ID
+      })
+    });
+    const tokenData = await tokenResponse.json();
+    if (tokenResponse.ok && tokenData.access_token) {
+      log("debug", `device auth success`, { status: tokenResponse.status });
+      return tokenData.access_token;
+    }
+    if (tokenData.error === "authorization_pending") {
+      continue;
+    }
+    if (tokenData.error === "slow_down") {
+      pollDelay += 1000;
+      log("debug", `device auth slow_down`, { nextDelayMs: pollDelay });
+      continue;
+    }
+    log("debug", `device auth failed`, {
+      status: tokenResponse.status,
+      error: tokenData.error ?? "unknown"
+    });
+    throw new Error(`Device auth failed: ${tokenData.error ?? "unknown"} ${tokenData.error_description ?? ""}`.trim());
+  }
+};
 var getStateUploadUrls = async (siteUrl, token, count) => {
   const response = await fetch(`${siteUrl}/api/storage/upload-url`, {
     method: "POST",
@@ -411,32 +586,6 @@ var uploadStateFileToUrl = async (uploadUrl, filePath) => {
   }
   return data.storageId;
 };
-var buildStateFiles = async (sessionDir, siteUrl, token) => {
-  const files = await collectSessionStateFiles(sessionDir);
-  if (files.length === 0) {
-    return [];
-  }
-  const uploadUrls = await getStateUploadUrls(siteUrl, token, files.length);
-  const entries = [];
-  for (let index = 0;index < files.length; index += 1) {
-    const file = files[index];
-    const uploadUrl = uploadUrls[index];
-    if (!file || !uploadUrl) {
-      throw new Error("Upload URL list did not match file list");
-    }
-    const data = new Uint8Array(await Bun.file(file.fullPath).arrayBuffer());
-    const fileHash = createHash("sha256").update(data).digest("hex");
-    const storageId = await uploadStateFileToUrl(uploadUrl, file.fullPath);
-    entries.push({
-      path: file.relativePath,
-      fileHash,
-      storageId,
-      size: file.size,
-      mtimeMs: file.mtimeMs
-    });
-  }
-  return entries;
-};
 var buildLogLines = (raw) => {
   const lines = raw.split(`
 `).filter((line) => line.trim().length > 0);
@@ -449,6 +598,11 @@ var buildLogLines = (raw) => {
         ts = parsed.ts;
       } else if (typeof parsed.timestamp === "number") {
         ts = parsed.timestamp;
+      } else if (typeof parsed.timestamp === "string") {
+        const parsedTs = Date.parse(parsed.timestamp);
+        if (!Number.isNaN(parsedTs)) {
+          ts = parsedTs;
+        }
       }
     } catch {}
     return { ts, log: line, encoding: "utf8" };
@@ -523,9 +677,25 @@ var signOutRemote = async (siteUrl, token) => {
     };
   }
 };
-var runSetup = async (args) => {
-  log("debug", `runSetup start`);
+var describeSetupTarget = (target) => {
+  if (target === "claude")
+    return "Claude";
+  if (target === "codex")
+    return "Codex";
+  return "Claude + Codex";
+};
+var updateSettingsForTarget = async (target, force, dry) => {
+  if (target === "claude" || target === "all") {
+    await mergeClaudeSettings(log, { dry });
+  }
+  if (target === "codex" || target === "all") {
+    await mergeCodexConfig(force, log, { dry });
+  }
+};
+var runSetup = async (args, target) => {
+  log("debug", `runSetup start`, { target });
   const force = Boolean(args.force);
+  const dry = Boolean(args.dry);
   log("debug", "runSetup", { force });
   const configExists = await Bun.file(CONFIG_PATH).exists();
   log("debug", "config", { path: CONFIG_PATH, exists: configExists });
@@ -556,16 +726,37 @@ var runSetup = async (args) => {
     throw new Error("Missing site URL. Provide --site-url or BISYNC_SITE_URL.");
   }
   if (configExists && existingConfig?.token && !force) {
-    log("debug", "using existing token; updating Claude settings only");
-    await mergeSettings();
-    log("info", "Updated Claude settings using existing credentials", { path: CONFIG_PATH });
+    log("debug", "using existing token; updating settings only", { target });
+    await updateSettingsForTarget(target, force, dry);
+    if (dry) {
+      log("info", `Printed ${describeSetupTarget(target)} settings (dry run)`, {
+        path: CONFIG_PATH
+      });
+    } else {
+      log("info", `Updated ${describeSetupTarget(target)} settings using existing credentials`, {
+        path: CONFIG_PATH
+      });
+    }
     return;
   }
   const token = await deviceAuthFlow(siteUrl);
-  await writeConfig({ siteUrl, token, clientId: CLIENT_ID });
-  log("debug", "config written", { path: CONFIG_PATH });
-  await mergeSettings();
-  log("info", "Configured Claude settings and saved credentials", { path: CONFIG_PATH });
+  if (dry) {
+    console.log(`# ${CONFIG_PATH}`);
+    console.log(JSON.stringify({ siteUrl, token, clientId: CLIENT_ID }, null, 2));
+  } else {
+    await writeConfig({ siteUrl, token, clientId: CLIENT_ID });
+    log("debug", "config written", { path: CONFIG_PATH });
+  }
+  await updateSettingsForTarget(target, force, dry);
+  if (dry) {
+    log("info", `Printed ${describeSetupTarget(target)} settings (dry run)`, {
+      path: CONFIG_PATH
+    });
+  } else {
+    log("info", `Configured ${describeSetupTarget(target)} settings and saved credentials`, {
+      path: CONFIG_PATH
+    });
+  }
 };
 var runAuthLogin = async (args) => {
   log("debug", "runAuthLogin start");
@@ -644,22 +835,91 @@ var runSessionList = async () => {
     console.log(session.externalId);
   }
 };
-var runHook = async (hookName) => {
+var runHook = async (hookName, payloadArg) => {
   log("debug", `runHook start`, { hook: hookName });
-  const stdinRaw = await new Promise((resolve2, reject) => {
+  const stdinRaw = payloadArg && payloadArg.trim().length > 0 ? "" : await new Promise((resolve3, reject) => {
     let data = "";
     process.stdin.setEncoding("utf8");
     process.stdin.on("data", (chunk) => {
       data += chunk;
     });
-    process.stdin.on("end", () => resolve2(data));
+    process.stdin.on("end", () => resolve3(data));
     process.stdin.on("error", (error) => reject(error));
   });
-  log("debug", `runHook`, { hook: hookName, stdin: stdinRaw.trim() });
-  if (!stdinRaw.trim())
+  const rawPayload = stdinRaw.trim() || payloadArg?.trim() || "";
+  log("debug", `runHook`, { hook: hookName, stdin: stdinRaw.trim(), arg: payloadArg ?? "" });
+  if (!rawPayload)
+    return;
+  let payload;
+  try {
+    payload = JSON.parse(rawPayload);
+  } catch (error) {
+    log("debug", `runHook`, {
+      hook: hookName,
+      error: error instanceof Error ? error.message : String(error)
+    });
     return;
-  const stdinPayload = JSON.parse(stdinRaw);
-  const sessionId = stdinPayload.session_id;
+  }
+  if (hookName === "Codex") {
+    const threadId = (typeof payload["thread-id"] === "string" ? payload["thread-id"] : undefined) ?? (typeof payload.thread_id === "string" ? payload.thread_id : undefined) ?? (typeof payload.threadId === "string" ? payload.threadId : undefined);
+    if (!threadId) {
+      log("debug", `runHook`, { hook: hookName, error: "missing-thread-id" });
+      return;
+    }
+    const config2 = await readConfig();
+    const siteUrl2 = process.env.BISYNC_SITE_URL ?? config2.siteUrl;
+    const token2 = config2.token;
+    const codexPaths = getCodexPaths();
+    const sessionsExists = await Bun.file(codexPaths.sessionsDir).exists();
+    const archivedExists = await Bun.file(codexPaths.archivedSessionsDir).exists();
+    log("debug", `runHook`, {
+      threadId,
+      codexHome: codexPaths.home,
+      sessionsDir: codexPaths.sessionsDir,
+      sessionsExists,
+      archivedSessionsDir: codexPaths.archivedSessionsDir,
+      archivedExists
+    });
+    const rolloutFile = await findCodexRolloutFile(threadId, { log });
+    if (!rolloutFile) {
+      log("debug", `runHook`, { threadId, error: "rollout-not-found" });
+      return;
+    }
+    log("debug", `runHook`, { threadId, rolloutFile });
+    const raw = await Bun.file(rolloutFile).text();
+    if (!raw.trim()) {
+      log("debug", `runHook`, { threadId, error: "empty-log" });
+    } else {
+      try {
+        await uploadLogs(siteUrl2, token2, threadId, raw);
+        log("debug", `runHook`, { threadId, error: "upload-ok" });
+      } catch (error) {
+        log("debug", `runHook`, {
+          threadId,
+          error: error instanceof Error ? error.message : String(error)
+        });
+      }
+    }
+    try {
+      const stateFiles = await buildCodexStateFiles(siteUrl2, token2, {
+        getStateUploadUrls,
+        uploadStateFileToUrl
+      });
+      if (stateFiles.length === 0) {
+        log("debug", `runHook`, { threadId, error: "no-state-files" });
+      } else {
+        await uploadStateFiles(siteUrl2, token2, threadId, stateFiles);
+        log("debug", `runHook`, { threadId, error: "state-upload-ok" });
+      }
+    } catch (error) {
+      log("debug", `runHook`, {
+        threadId,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+    return;
+  }
+  const sessionId = typeof payload.session_id === "string" ? payload.session_id : undefined;
   if (!sessionId) {
     log("debug", `runHook`, { hook: hookName, error: "missing-session-id" });
     return;
@@ -669,24 +929,25 @@ var runHook = async (hookName) => {
   const token = config.token;
   log("debug", `runHook`, { siteUrl });
   let sessionFile = null;
-  if (typeof stdinPayload.transcript_path === "string") {
-    const resolvedPath = resolve(stdinPayload.transcript_path);
+  const transcriptPath = typeof payload.transcript_path === "string" ? payload.transcript_path : undefined;
+  if (transcriptPath) {
+    const resolvedPath = resolve2(transcriptPath);
     if (await Bun.file(resolvedPath).exists()) {
       sessionFile = resolvedPath;
     }
   }
   if (!sessionFile) {
-    sessionFile = await findSessionFile(sessionId);
+    sessionFile = await findClaudeSessionFile(sessionId);
   }
   if (!sessionFile) {
     log("debug", `runHook`, { sessionId, error: "session-file-not-found" });
   }
   let sessionDir = null;
   if (sessionFile) {
-    sessionDir = await resolveSessionDir(sessionFile);
+    sessionDir = await resolveClaudeSessionDir(sessionFile);
   }
   if (!sessionDir) {
-    sessionDir = await findSessionDir(sessionId);
+    sessionDir = await findClaudeSessionDir(sessionId);
   }
   if (!sessionFile && !sessionDir) {
     return;
@@ -711,7 +972,10 @@ var runHook = async (hookName) => {
   if (sessionDir && hookName === "SessionEnd") {
     log("debug", `runHook`, { sessionDir });
     try {
-      const stateFiles = await buildStateFiles(sessionDir, siteUrl, token);
+      const stateFiles = await buildClaudeStateFiles(sessionDir, siteUrl, token, {
+        getStateUploadUrls,
+        uploadStateFileToUrl
+      });
       if (stateFiles.length === 0) {
         log("debug", `runHook`, { sessionId, error: "no-state-files" });
         return;
@@ -739,7 +1003,7 @@ var main = async () => {
   if (values.verbose) {
     LOG_LEVEL = "debug";
   }
-  const [command, subcommand] = positionals;
+  const [command, subcommand, ...rest] = positionals;
   log("debug", "argv", { argv: JSON.stringify(process.argv.slice(2)) });
   if (!command) {
     printUsage();
@@ -747,7 +1011,12 @@ var main = async () => {
   }
   try {
     if (command === "setup") {
-      await runSetup(values);
+      if (subcommand && subcommand !== "claude" && subcommand !== "codex") {
+        printUsage();
+        process.exit(1);
+      }
+      const target = subcommand ?? "all";
+      await runSetup(values, target);
       process.exit(0);
     }
     if (command === "auth") {
@@ -771,7 +1040,8 @@ var main = async () => {
       process.exit(1);
     }
     if (command === "hook") {
-      await runHook(subcommand ?? "unknown");
+      const payloadArg = rest.length > 0 ? rest.join(" ") : null;
+      await runHook(subcommand ?? "unknown", payloadArg);
       process.exit(0);
     }
     printUsage();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bisync-cli",
-  "version": "0.0.10",
+  "version": "0.0.12",
   "bin": {
     "bisync": "dist/bisync.js"
   },
@@ -9,7 +9,7 @@
   ],
   "type": "module",
   "scripts": {
-    "build": "bun build src/bin.ts --outfile dist/bisync.js"
+    "build": "bun build --target bun src/bin.ts --outfile dist/bisync.js"
   },
   "devDependencies": {
     "@types/bun": "^1.3.5"