very-happy-cli 0.2.159 → 0.2.161

package/dist/codexThreadFork-BCaEMBiM.mjs

@@ -0,0 +1,338 @@
+import { randomUUID } from 'node:crypto';
+import { copyFile, unlink, readFile, rename, writeFile } from 'node:fs/promises';
+import { createReadStream, createWriteStream } from 'node:fs';
+import { join } from 'node:path';
+import { createInterface } from 'node:readline';
+import { l as logger } from './logger-fXoNzNuB.mjs';
+
+class ForkTruncateUuidNotFoundError extends Error {
+  constructor(cutAfterUuid, sourcePath) {
+    super(`Truncation UUID ${cutAfterUuid} not found in ${sourcePath}`);
+    this.cutAfterUuid = cutAfterUuid;
+    this.sourcePath = sourcePath;
+    this.name = "ForkTruncateUuidNotFoundError";
+  }
+}
+class ForkSourceMissingError extends Error {
+  constructor(sourcePath) {
+    super(`Source Claude session JSONL not found: ${sourcePath}`);
+    this.sourcePath = sourcePath;
+    this.name = "ForkSourceMissingError";
+  }
+}
+function jsonlPath(projectDir, sessionId) {
+  return join(projectDir, `${sessionId}.jsonl`);
+}
+function isUserPrompt(parsed) {
+  if (!parsed || parsed.type !== "user") return false;
+  if (parsed.isSidechain) return false;
+  const content = parsed.message?.content;
+  return typeof content === "string";
+}
+function hasPromptAttachments(parsed) {
+  const content = parsed.message?.content;
+  return typeof content === "string" && content.includes("<attached_files>") || Array.isArray(content) && content.some((block) => block?.type !== "text" || typeof block.text === "string" && block.text.includes("<attached_files>"));
+}
+function userPromptText(parsed) {
+  if (parsed?.type !== "user" || parsed.isSidechain || parsed.isMeta || parsed.isSynthetic) return null;
+  const content = parsed.message?.content;
+  if (typeof content === "string") return content.trim() ? content : null;
+  if (!Array.isArray(content) || content.some((block) => block?.type === "tool_result")) return null;
+  const text = content.filter((block) => block?.type === "text" && typeof block.text === "string").map((block) => block.text).join("\n");
+  return text.trim() ? text : null;
+}
+async function discardForkedSession(projectDir, claudeSessionId) {
+  try {
+    await unlink(jsonlPath(projectDir, claudeSessionId));
+    logger.debug(`[CLAUDE FORK] Discarded unused fork ${claudeSessionId}`);
+  } catch (error) {
+    if (error.code !== "ENOENT") {
+      logger.debug(`[CLAUDE FORK] Failed to discard fork ${claudeSessionId}:`, error);
+    }
+  }
+}
+async function forkSession(projectDir, sourceClaudeSessionId) {
+  const newId = randomUUID();
+  const src = jsonlPath(projectDir, sourceClaudeSessionId);
+  const dst = jsonlPath(projectDir, newId);
+  try {
+    await copyFile(src, dst);
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      throw new ForkSourceMissingError(src);
+    }
+    throw error;
+  }
+  logger.debug(`[CLAUDE FORK] Forked ${sourceClaudeSessionId} -> ${newId}`);
+  return newId;
+}
+async function forkAndTruncateSession(projectDir, sourceClaudeSessionId, cutAfterUuid) {
+  const newId = randomUUID();
+  const src = jsonlPath(projectDir, sourceClaudeSessionId);
+  const finalDst = jsonlPath(projectDir, newId);
+  const tempDst = `${finalDst}.tmp-${process.pid}-${Date.now()}`;
+  const readStream = createReadStream(src, { encoding: "utf-8" });
+  const writeStream = createWriteStream(tempDst, { encoding: "utf-8" });
+  const rl = createInterface({ input: readStream, crlfDelay: Infinity });
+  let foundMarker = false;
+  let iterationError = null;
+  try {
+    for await (const line of rl) {
+      if (line.length === 0) {
+        continue;
+      }
+      let parsed = null;
+      try {
+        parsed = JSON.parse(line);
+      } catch {
+        logger.debug(`[CLAUDE FORK] Skipped malformed JSON line during truncation copy`);
+      }
+      if (foundMarker && parsed && isUserPrompt(parsed)) {
+        break;
+      }
+      await new Promise((resolve, reject) => {
+        writeStream.write(`${line}
+`, (err) => err ? reject(err) : resolve());
+      });
+      if (!foundMarker && parsed && typeof parsed.uuid === "string" && parsed.uuid === cutAfterUuid) {
+        foundMarker = true;
+      }
+    }
+  } catch (e) {
+    iterationError = e;
+  } finally {
+    rl.close();
+    readStream.destroy();
+    await new Promise((resolve, reject) => writeStream.end((err) => err ? reject(err) : resolve()));
+  }
+  if (iterationError) {
+    await unlink(tempDst).catch(() => void 0);
+    if (iterationError.code === "ENOENT") {
+      throw new ForkSourceMissingError(src);
+    }
+    throw iterationError;
+  }
+  if (!foundMarker) {
+    await unlink(tempDst).catch(() => void 0);
+    throw new ForkTruncateUuidNotFoundError(cutAfterUuid, src);
+  }
+  await rename(tempDst, finalDst);
+  logger.debug(`[CLAUDE FORK] Forked ${sourceClaudeSessionId} -> ${newId}, cut after ${cutAfterUuid}`);
+  return newId;
+}
+async function listClaudeRewindPoints(projectDir, claudeSessionId) {
+  const path = jsonlPath(projectDir, claudeSessionId);
+  let raw;
+  try {
+    raw = await readFile(path, "utf-8");
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      throw new ForkSourceMissingError(path);
+    }
+    throw error;
+  }
+  const points = [];
+  for (const line of raw.split("\n")) {
+    if (line.length === 0) continue;
+    let parsed;
+    try {
+      parsed = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    const content = userPromptText(parsed);
+    if (content === null) continue;
+    if (typeof parsed.uuid !== "string" || parsed.uuid.length === 0) continue;
+    const timestampRaw = parsed.timestamp;
+    const timestamp = typeof timestampRaw === "string" ? Date.parse(timestampRaw) : typeof timestampRaw === "number" ? timestampRaw : Date.now();
+    points.push({
+      uuid: parsed.uuid,
+      text: content,
+      ...hasPromptAttachments(parsed) ? { hasAttachments: true } : {},
+      timestamp: Number.isFinite(timestamp) ? timestamp : Date.now()
+    });
+  }
+  return points;
+}
+async function forkBeforeUserMessage(projectDir, sourceClaudeSessionId, cutBeforeUuid) {
+  const src = jsonlPath(projectDir, sourceClaudeSessionId);
+  let raw;
+  try {
+    raw = await readFile(src, "utf-8");
+  } catch (error) {
+    if (error.code === "ENOENT") throw new ForkSourceMissingError(src);
+    throw error;
+  }
+  const lines = raw.split("\n");
+  let hasPreviousConversation = false;
+  let hasPreviousPrompt = false;
+  let cut = -1;
+  for (let i = 0; i < lines.length; i++) {
+    let entry;
+    try {
+      entry = JSON.parse(lines[i]);
+    } catch {
+      continue;
+    }
+    if (userPromptText(entry) !== null && entry.uuid === cutBeforeUuid) {
+      if (hasPromptAttachments(entry)) throw new Error("Cannot edit and rerun a message with attachments");
+      cut = i;
+      break;
+    }
+    if (!entry?.isSidechain && !entry?.isMeta && !entry?.isSynthetic && (entry?.type === "user" || entry?.type === "assistant")) {
+      hasPreviousConversation = true;
+      const content = entry.message?.content;
+      if (entry.type === "user" && (typeof content === "string" || Array.isArray(content) && content.length > 0 && !content.some((block) => block?.type === "tool_result"))) {
+        hasPreviousPrompt = true;
+      }
+    }
+  }
+  if (cut < 0) throw new ForkTruncateUuidNotFoundError(cutBeforeUuid, src);
+  if (!hasPreviousConversation) return null;
+  if (!hasPreviousPrompt) throw new Error("Cannot safely rewind: earlier history has no user prompt");
+  const newId = randomUUID();
+  const destination = jsonlPath(projectDir, newId);
+  const temporary = `${destination}.tmp-${process.pid}`;
+  try {
+    await writeFile(temporary, lines.slice(0, cut).join("\n") + "\n", { encoding: "utf-8", flag: "wx" });
+    await rename(temporary, destination);
+  } catch (error) {
+    await unlink(temporary).catch(() => void 0);
+    throw error;
+  }
+  return newId;
+}
+
+class CodexForkRewindPointNotFoundError extends Error {
+  constructor(itemId, threadId) {
+    super(`Codex rewind point ${itemId} not found in thread ${threadId}`);
+    this.itemId = itemId;
+    this.threadId = threadId;
+    this.name = "CodexForkRewindPointNotFoundError";
+  }
+}
+function hasUserAttachments(item) {
+  const content = item.content;
+  return Array.isArray(content) && content.some((part) => !part || typeof part !== "object" || part.type !== "text" || typeof part.text === "string" && part.text.includes("<attached_files>"));
+}
+function rejectAttachedTarget(thread, itemId) {
+  const item = thread.turns?.flatMap((turn) => turn.items ?? []).find((item2) => item2.id === itemId);
+  if (item && hasUserAttachments(item)) throw new Error("Cannot edit and rerun a message with attachments");
+}
+function textFromUserItem(item) {
+  if (item.type !== "userMessage") {
+    return null;
+  }
+  const content = item.content;
+  if (!Array.isArray(content)) {
+    return null;
+  }
+  const textParts = content.filter((part) => Boolean(part) && typeof part === "object" && part.type === "text" && typeof part.text === "string").map((part) => part.text).join("\n").trim();
+  return textParts.length > 0 ? textParts : null;
+}
+function timestampFromTurn(turn) {
+  const seconds = turn.startedAt ?? turn.completedAt;
+  return typeof seconds === "number" && Number.isFinite(seconds) ? seconds * 1e3 : Date.now();
+}
+function listCodexRewindPoints(thread) {
+  const points = [];
+  for (const turn of thread.turns ?? []) {
+    for (const item of turn.items ?? []) {
+      const text = textFromUserItem(item);
+      if (!text) {
+        continue;
+      }
+      points.push({
+        itemId: item.id,
+        text,
+        ...hasUserAttachments(item) ? { hasAttachments: true } : {},
+        timestamp: timestampFromTurn(turn)
+      });
+    }
+  }
+  return points;
+}
+function findCutTurn(thread, itemId) {
+  const turns = thread.turns ?? [];
+  for (let index = 0; index < turns.length; index++) {
+    const turn = turns[index];
+    const item = (turn.items ?? []).find((candidate) => candidate.id === itemId);
+    if (!item) {
+      continue;
+    }
+    const text = textFromUserItem(item);
+    if (text) {
+      return { index, text };
+    }
+  }
+  return null;
+}
+async function forkCodexThread(client, opts) {
+  const forked = await client.forkThread({
+    threadId: opts.threadId,
+    ...opts.cwd ? { cwd: opts.cwd } : {},
+    ...opts.model ? { model: opts.model } : {},
+    ...opts.approvalPolicy ? { approvalPolicy: opts.approvalPolicy } : {},
+    ...opts.sandbox ? { sandbox: opts.sandbox } : {},
+    ...opts.mcpServers ? { mcpServers: opts.mcpServers } : {}
+  });
+  if (opts.cutAfterItemId) {
+    const cutTurn = findCutTurn(forked.thread, opts.cutAfterItemId);
+    if (!cutTurn) {
+      throw new CodexForkRewindPointNotFoundError(opts.cutAfterItemId, opts.threadId);
+    }
+    const turns = forked.thread.turns ?? [];
+    const turnsToDrop = turns.length - cutTurn.index;
+    if (turnsToDrop > 0) {
+      await client.rollbackThread({
+        threadId: forked.threadId,
+        numTurns: turnsToDrop
+      });
+    }
+    await client.injectItems({
+      threadId: forked.threadId,
+      items: [{
+        type: "message",
+        role: "user",
+        content: [{ type: "input_text", text: cutTurn.text }]
+      }]
+    });
+  }
+  return {
+    type: "success",
+    newCodexThreadId: forked.threadId
+  };
+}
+async function forkCodexBeforeUserMessage(client, opts) {
+  const { thread: source } = await client.readThread({ threadId: opts.threadId, includeTurns: true });
+  rejectAttachedTarget(source, opts.cutBeforeItemId);
+  const sourceCut = findCutTurn(source, opts.cutBeforeItemId);
+  if (!sourceCut) throw new CodexForkRewindPointNotFoundError(opts.cutBeforeItemId, opts.threadId);
+  if ((source.turns?.[sourceCut.index].items ?? []).findIndex((item) => item.id === opts.cutBeforeItemId) !== 0) {
+    throw new Error("Cannot safely rewind a user message inside an existing turn");
+  }
+  if (sourceCut.index === 0) return { type: "success", startFresh: true };
+  const forked = await client.forkThread({ threadId: opts.threadId, cwd: opts.cwd });
+  if (forked.threadId === opts.threadId) throw new Error("Codex did not create an independent fork");
+  rejectAttachedTarget(forked.thread, opts.cutBeforeItemId);
+  const cut = findCutTurn(forked.thread, opts.cutBeforeItemId);
+  if (!cut) throw new CodexForkRewindPointNotFoundError(opts.cutBeforeItemId, opts.threadId);
+  const turns = forked.thread.turns ?? [];
+  const items = turns[cut.index].items ?? [];
+  if (items.findIndex((item) => item.id === opts.cutBeforeItemId) !== 0) {
+    throw new Error("Cannot safely rewind a user message inside an existing turn");
+  }
+  if (cut.index === 0) return { type: "success", startFresh: true };
+  const expectedTurnIds = turns.slice(0, cut.index).map((turn) => turn.id);
+  const { thread } = await client.rollbackThread({
+    threadId: forked.threadId,
+    numTurns: turns.length - cut.index
+  });
+  const remaining = thread.turns ?? [];
+  if (remaining.length !== cut.index || remaining.some((turn, index) => turn.id !== expectedTurnIds[index])) {
+    throw new Error("Codex rollback did not preserve the expected history");
+  }
+  return { type: "success", newCodexThreadId: forked.threadId };
+}
+
+export { CodexForkRewindPointNotFoundError as C, ForkSourceMissingError as F, forkCodexThread as a, forkAndTruncateSession as b, ForkTruncateUuidNotFoundError as c, discardForkedSession as d, forkBeforeUserMessage as e, forkSession as f, listCodexRewindPoints as g, forkCodexBeforeUserMessage as h, listClaudeRewindPoints as l };

package/dist/codexThreadFork-BZqF-9bX.cjs

@@ -0,0 +1,350 @@
+'use strict';
+
+var node_crypto = require('node:crypto');
+var promises = require('node:fs/promises');
+var node_fs = require('node:fs');
+var path = require('node:path');
+var node_readline = require('node:readline');
+var logger = require('./logger-Bc8-u1w0.cjs');
+
+class ForkTruncateUuidNotFoundError extends Error {
+  constructor(cutAfterUuid, sourcePath) {
+    super(`Truncation UUID ${cutAfterUuid} not found in ${sourcePath}`);
+    this.cutAfterUuid = cutAfterUuid;
+    this.sourcePath = sourcePath;
+    this.name = "ForkTruncateUuidNotFoundError";
+  }
+}
+class ForkSourceMissingError extends Error {
+  constructor(sourcePath) {
+    super(`Source Claude session JSONL not found: ${sourcePath}`);
+    this.sourcePath = sourcePath;
+    this.name = "ForkSourceMissingError";
+  }
+}
+function jsonlPath(projectDir, sessionId) {
+  return path.join(projectDir, `${sessionId}.jsonl`);
+}
+function isUserPrompt(parsed) {
+  if (!parsed || parsed.type !== "user") return false;
+  if (parsed.isSidechain) return false;
+  const content = parsed.message?.content;
+  return typeof content === "string";
+}
+function hasPromptAttachments(parsed) {
+  const content = parsed.message?.content;
+  return typeof content === "string" && content.includes("<attached_files>") || Array.isArray(content) && content.some((block) => block?.type !== "text" || typeof block.text === "string" && block.text.includes("<attached_files>"));
+}
+function userPromptText(parsed) {
+  if (parsed?.type !== "user" || parsed.isSidechain || parsed.isMeta || parsed.isSynthetic) return null;
+  const content = parsed.message?.content;
+  if (typeof content === "string") return content.trim() ? content : null;
+  if (!Array.isArray(content) || content.some((block) => block?.type === "tool_result")) return null;
+  const text = content.filter((block) => block?.type === "text" && typeof block.text === "string").map((block) => block.text).join("\n");
+  return text.trim() ? text : null;
+}
+async function discardForkedSession(projectDir, claudeSessionId) {
+  try {
+    await promises.unlink(jsonlPath(projectDir, claudeSessionId));
+    logger.logger.debug(`[CLAUDE FORK] Discarded unused fork ${claudeSessionId}`);
+  } catch (error) {
+    if (error.code !== "ENOENT") {
+      logger.logger.debug(`[CLAUDE FORK] Failed to discard fork ${claudeSessionId}:`, error);
+    }
+  }
+}
+async function forkSession(projectDir, sourceClaudeSessionId) {
+  const newId = node_crypto.randomUUID();
+  const src = jsonlPath(projectDir, sourceClaudeSessionId);
+  const dst = jsonlPath(projectDir, newId);
+  try {
+    await promises.copyFile(src, dst);
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      throw new ForkSourceMissingError(src);
+    }
+    throw error;
+  }
+  logger.logger.debug(`[CLAUDE FORK] Forked ${sourceClaudeSessionId} -> ${newId}`);
+  return newId;
+}
+async function forkAndTruncateSession(projectDir, sourceClaudeSessionId, cutAfterUuid) {
+  const newId = node_crypto.randomUUID();
+  const src = jsonlPath(projectDir, sourceClaudeSessionId);
+  const finalDst = jsonlPath(projectDir, newId);
+  const tempDst = `${finalDst}.tmp-${process.pid}-${Date.now()}`;
+  const readStream = node_fs.createReadStream(src, { encoding: "utf-8" });
+  const writeStream = node_fs.createWriteStream(tempDst, { encoding: "utf-8" });
+  const rl = node_readline.createInterface({ input: readStream, crlfDelay: Infinity });
+  let foundMarker = false;
+  let iterationError = null;
+  try {
+    for await (const line of rl) {
+      if (line.length === 0) {
+        continue;
+      }
+      let parsed = null;
+      try {
+        parsed = JSON.parse(line);
+      } catch {
+        logger.logger.debug(`[CLAUDE FORK] Skipped malformed JSON line during truncation copy`);
+      }
+      if (foundMarker && parsed && isUserPrompt(parsed)) {
+        break;
+      }
+      await new Promise((resolve, reject) => {
+        writeStream.write(`${line}
+`, (err) => err ? reject(err) : resolve());
+      });
+      if (!foundMarker && parsed && typeof parsed.uuid === "string" && parsed.uuid === cutAfterUuid) {
+        foundMarker = true;
+      }
+    }
+  } catch (e) {
+    iterationError = e;
+  } finally {
+    rl.close();
+    readStream.destroy();
+    await new Promise((resolve, reject) => writeStream.end((err) => err ? reject(err) : resolve()));
+  }
+  if (iterationError) {
+    await promises.unlink(tempDst).catch(() => void 0);
+    if (iterationError.code === "ENOENT") {
+      throw new ForkSourceMissingError(src);
+    }
+    throw iterationError;
+  }
+  if (!foundMarker) {
+    await promises.unlink(tempDst).catch(() => void 0);
+    throw new ForkTruncateUuidNotFoundError(cutAfterUuid, src);
+  }
+  await promises.rename(tempDst, finalDst);
+  logger.logger.debug(`[CLAUDE FORK] Forked ${sourceClaudeSessionId} -> ${newId}, cut after ${cutAfterUuid}`);
+  return newId;
+}
+async function listClaudeRewindPoints(projectDir, claudeSessionId) {
+  const path = jsonlPath(projectDir, claudeSessionId);
+  let raw;
+  try {
+    raw = await promises.readFile(path, "utf-8");
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      throw new ForkSourceMissingError(path);
+    }
+    throw error;
+  }
+  const points = [];
+  for (const line of raw.split("\n")) {
+    if (line.length === 0) continue;
+    let parsed;
+    try {
+      parsed = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    const content = userPromptText(parsed);
+    if (content === null) continue;
+    if (typeof parsed.uuid !== "string" || parsed.uuid.length === 0) continue;
+    const timestampRaw = parsed.timestamp;
+    const timestamp = typeof timestampRaw === "string" ? Date.parse(timestampRaw) : typeof timestampRaw === "number" ? timestampRaw : Date.now();
+    points.push({
+      uuid: parsed.uuid,
+      text: content,
+      ...hasPromptAttachments(parsed) ? { hasAttachments: true } : {},
+      timestamp: Number.isFinite(timestamp) ? timestamp : Date.now()
+    });
+  }
+  return points;
+}
+async function forkBeforeUserMessage(projectDir, sourceClaudeSessionId, cutBeforeUuid) {
+  const src = jsonlPath(projectDir, sourceClaudeSessionId);
+  let raw;
+  try {
+    raw = await promises.readFile(src, "utf-8");
+  } catch (error) {
+    if (error.code === "ENOENT") throw new ForkSourceMissingError(src);
+    throw error;
+  }
+  const lines = raw.split("\n");
+  let hasPreviousConversation = false;
+  let hasPreviousPrompt = false;
+  let cut = -1;
+  for (let i = 0; i < lines.length; i++) {
+    let entry;
+    try {
+      entry = JSON.parse(lines[i]);
+    } catch {
+      continue;
+    }
+    if (userPromptText(entry) !== null && entry.uuid === cutBeforeUuid) {
+      if (hasPromptAttachments(entry)) throw new Error("Cannot edit and rerun a message with attachments");
+      cut = i;
+      break;
+    }
+    if (!entry?.isSidechain && !entry?.isMeta && !entry?.isSynthetic && (entry?.type === "user" || entry?.type === "assistant")) {
+      hasPreviousConversation = true;
+      const content = entry.message?.content;
+      if (entry.type === "user" && (typeof content === "string" || Array.isArray(content) && content.length > 0 && !content.some((block) => block?.type === "tool_result"))) {
+        hasPreviousPrompt = true;
+      }
+    }
+  }
+  if (cut < 0) throw new ForkTruncateUuidNotFoundError(cutBeforeUuid, src);
+  if (!hasPreviousConversation) return null;
+  if (!hasPreviousPrompt) throw new Error("Cannot safely rewind: earlier history has no user prompt");
+  const newId = node_crypto.randomUUID();
+  const destination = jsonlPath(projectDir, newId);
+  const temporary = `${destination}.tmp-${process.pid}`;
+  try {
+    await promises.writeFile(temporary, lines.slice(0, cut).join("\n") + "\n", { encoding: "utf-8", flag: "wx" });
+    await promises.rename(temporary, destination);
+  } catch (error) {
+    await promises.unlink(temporary).catch(() => void 0);
+    throw error;
+  }
+  return newId;
+}
+
+class CodexForkRewindPointNotFoundError extends Error {
+  constructor(itemId, threadId) {
+    super(`Codex rewind point ${itemId} not found in thread ${threadId}`);
+    this.itemId = itemId;
+    this.threadId = threadId;
+    this.name = "CodexForkRewindPointNotFoundError";
+  }
+}
+function hasUserAttachments(item) {
+  const content = item.content;
+  return Array.isArray(content) && content.some((part) => !part || typeof part !== "object" || part.type !== "text" || typeof part.text === "string" && part.text.includes("<attached_files>"));
+}
+function rejectAttachedTarget(thread, itemId) {
+  const item = thread.turns?.flatMap((turn) => turn.items ?? []).find((item2) => item2.id === itemId);
+  if (item && hasUserAttachments(item)) throw new Error("Cannot edit and rerun a message with attachments");
+}
+function textFromUserItem(item) {
+  if (item.type !== "userMessage") {
+    return null;
+  }
+  const content = item.content;
+  if (!Array.isArray(content)) {
+    return null;
+  }
+  const textParts = content.filter((part) => Boolean(part) && typeof part === "object" && part.type === "text" && typeof part.text === "string").map((part) => part.text).join("\n").trim();
+  return textParts.length > 0 ? textParts : null;
+}
+function timestampFromTurn(turn) {
+  const seconds = turn.startedAt ?? turn.completedAt;
+  return typeof seconds === "number" && Number.isFinite(seconds) ? seconds * 1e3 : Date.now();
+}
+function listCodexRewindPoints(thread) {
+  const points = [];
+  for (const turn of thread.turns ?? []) {
+    for (const item of turn.items ?? []) {
+      const text = textFromUserItem(item);
+      if (!text) {
+        continue;
+      }
+      points.push({
+        itemId: item.id,
+        text,
+        ...hasUserAttachments(item) ? { hasAttachments: true } : {},
+        timestamp: timestampFromTurn(turn)
+      });
+    }
+  }
+  return points;
+}
+function findCutTurn(thread, itemId) {
+  const turns = thread.turns ?? [];
+  for (let index = 0; index < turns.length; index++) {
+    const turn = turns[index];
+    const item = (turn.items ?? []).find((candidate) => candidate.id === itemId);
+    if (!item) {
+      continue;
+    }
+    const text = textFromUserItem(item);
+    if (text) {
+      return { index, text };
+    }
+  }
+  return null;
+}
+async function forkCodexThread(client, opts) {
+  const forked = await client.forkThread({
+    threadId: opts.threadId,
+    ...opts.cwd ? { cwd: opts.cwd } : {},
+    ...opts.model ? { model: opts.model } : {},
+    ...opts.approvalPolicy ? { approvalPolicy: opts.approvalPolicy } : {},
+    ...opts.sandbox ? { sandbox: opts.sandbox } : {},
+    ...opts.mcpServers ? { mcpServers: opts.mcpServers } : {}
+  });
+  if (opts.cutAfterItemId) {
+    const cutTurn = findCutTurn(forked.thread, opts.cutAfterItemId);
+    if (!cutTurn) {
+      throw new CodexForkRewindPointNotFoundError(opts.cutAfterItemId, opts.threadId);
+    }
+    const turns = forked.thread.turns ?? [];
+    const turnsToDrop = turns.length - cutTurn.index;
+    if (turnsToDrop > 0) {
+      await client.rollbackThread({
+        threadId: forked.threadId,
+        numTurns: turnsToDrop
+      });
+    }
+    await client.injectItems({
+      threadId: forked.threadId,
+      items: [{
+        type: "message",
+        role: "user",
+        content: [{ type: "input_text", text: cutTurn.text }]
+      }]
+    });
+  }
+  return {
+    type: "success",
+    newCodexThreadId: forked.threadId
+  };
+}
+async function forkCodexBeforeUserMessage(client, opts) {
+  const { thread: source } = await client.readThread({ threadId: opts.threadId, includeTurns: true });
+  rejectAttachedTarget(source, opts.cutBeforeItemId);
+  const sourceCut = findCutTurn(source, opts.cutBeforeItemId);
+  if (!sourceCut) throw new CodexForkRewindPointNotFoundError(opts.cutBeforeItemId, opts.threadId);
+  if ((source.turns?.[sourceCut.index].items ?? []).findIndex((item) => item.id === opts.cutBeforeItemId) !== 0) {
+    throw new Error("Cannot safely rewind a user message inside an existing turn");
+  }
+  if (sourceCut.index === 0) return { type: "success", startFresh: true };
+  const forked = await client.forkThread({ threadId: opts.threadId, cwd: opts.cwd });
+  if (forked.threadId === opts.threadId) throw new Error("Codex did not create an independent fork");
+  rejectAttachedTarget(forked.thread, opts.cutBeforeItemId);
+  const cut = findCutTurn(forked.thread, opts.cutBeforeItemId);
+  if (!cut) throw new CodexForkRewindPointNotFoundError(opts.cutBeforeItemId, opts.threadId);
+  const turns = forked.thread.turns ?? [];
+  const items = turns[cut.index].items ?? [];
+  if (items.findIndex((item) => item.id === opts.cutBeforeItemId) !== 0) {
+    throw new Error("Cannot safely rewind a user message inside an existing turn");
+  }
+  if (cut.index === 0) return { type: "success", startFresh: true };
+  const expectedTurnIds = turns.slice(0, cut.index).map((turn) => turn.id);
+  const { thread } = await client.rollbackThread({
+    threadId: forked.threadId,
+    numTurns: turns.length - cut.index
+  });
+  const remaining = thread.turns ?? [];
+  if (remaining.length !== cut.index || remaining.some((turn, index) => turn.id !== expectedTurnIds[index])) {
+    throw new Error("Codex rollback did not preserve the expected history");
+  }
+  return { type: "success", newCodexThreadId: forked.threadId };
+}
+
+exports.CodexForkRewindPointNotFoundError = CodexForkRewindPointNotFoundError;
+exports.ForkSourceMissingError = ForkSourceMissingError;
+exports.ForkTruncateUuidNotFoundError = ForkTruncateUuidNotFoundError;
+exports.discardForkedSession = discardForkedSession;
+exports.forkAndTruncateSession = forkAndTruncateSession;
+exports.forkBeforeUserMessage = forkBeforeUserMessage;
+exports.forkCodexBeforeUserMessage = forkCodexBeforeUserMessage;
+exports.forkCodexThread = forkCodexThread;
+exports.forkSession = forkSession;
+exports.listClaudeRewindPoints = listClaudeRewindPoints;
+exports.listCodexRewindPoints = listCodexRewindPoints;