archymedes-cli 2.3.0 → 2.5.0

package/dist/archymedes-w4bjfye7.mjs

@@ -0,0 +1,280 @@
+// packages/core/src/cli/protocol.ts
+import { createHash } from "node:crypto";
+import { promises as fs2 } from "node:fs";
+import path2 from "node:path";
+
+// packages/core/src/cli/file-ownership.ts
+import { randomUUID } from "node:crypto";
+import { promises as fs } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+class OwnershipHeldError extends Error {
+  pid;
+  constructor(pid) {
+    super(`Session is already owned by process ${pid}; close or detach the other writer first.`);
+    this.pid = pid;
+  }
+}
+async function processStart(pid) {
+  if (process.platform !== "linux")
+    return;
+  try {
+    const stat = await fs.readFile(`/proc/${pid}/stat`, "utf8");
+    const boot = await fs.readFile("/proc/sys/kernel/random/boot_id", "utf8");
+    return `${boot.trim()}:${stat.slice(stat.lastIndexOf(")") + 2).split(" ")[19]}`;
+  } catch {
+    return;
+  }
+}
+async function readOwner(file) {
+  try {
+    const owner = JSON.parse(await fs.readFile(file, "utf8"));
+    if (!owner || typeof owner.token !== "string" || !Number.isSafeInteger(owner.pid) || owner.pid < 1 || typeof owner.host !== "string") {
+      throw new Error(`Invalid ownership record: ${file}`);
+    }
+    return owner;
+  } catch (error) {
+    if (error.code === "ENOENT")
+      return null;
+    throw error;
+  }
+}
+async function isAlive(owner) {
+  if (owner.host !== os.hostname())
+    return true;
+  try {
+    process.kill(owner.pid, 0);
+  } catch (error) {
+    return error.code !== "ESRCH";
+  }
+  const started = await processStart(owner.pid);
+  return !owner.started || !started || owner.started === started;
+}
+async function acquireFileOwnership(file, depth = 0) {
+  if (depth > 8)
+    throw new Error(`Ownership recovery requires inspection: ${file}`);
+  await fs.mkdir(path.dirname(file), { recursive: true });
+  const owner = { token: randomUUID(), pid: process.pid, host: os.hostname(), started: await processStart(process.pid) };
+  const candidate = `${file}.${owner.token}.tmp`;
+  const handle = await fs.open(candidate, "wx", 384);
+  try {
+    await handle.writeFile(JSON.stringify(owner));
+    await handle.sync();
+  } finally {
+    await handle.close();
+  }
+  try {
+    for (let attempt = 0;attempt < 8; attempt++) {
+      try {
+        await fs.link(candidate, file);
+        return async () => {
+          if ((await readOwner(file))?.token === owner.token)
+            await fs.unlink(file);
+        };
+      } catch (error) {
+        if (error.code !== "EEXIST")
+          throw error;
+      }
+      const current = await readOwner(file);
+      if (!current)
+        continue;
+      if (await isAlive(current))
+        throw new OwnershipHeldError(current.pid);
+      const release = await acquireFileOwnership(`${file}.reap`, depth + 1);
+      try {
+        if ((await readOwner(file))?.token === current.token)
+          await fs.unlink(file);
+      } finally {
+        await release();
+      }
+    }
+    throw new Error(`Could not acquire session ownership: ${file}`);
+  } finally {
+    await fs.unlink(candidate).catch(() => {
+      return;
+    });
+  }
+}
+
+// packages/core/src/cli/protocol.ts
+var ARCHYMEDES_PROTOCOL_VERSION = 1;
+var JOURNAL_GENESIS_HASH = "0".repeat(64);
+var TRANSITIONS = {
+  queued: ["running", "cancelled", "failed"],
+  running: ["waiting_approval", "completed", "blocked", "needs_verification", "cancelled", "failed", "iteration_limit"],
+  waiting_approval: ["running", "blocked", "cancelled", "failed"],
+  completed: [],
+  blocked: [],
+  needs_verification: [],
+  cancelled: [],
+  failed: [],
+  iteration_limit: []
+};
+function assertTurnTransition(from, to) {
+  if (!TRANSITIONS[from].includes(to))
+    throw new Error(`Illegal Archymedes turn transition: ${from} -> ${to}`);
+}
+var SENSITIVE_KEY = /(authorization|cookie|credential|password|private.?key|secret|token)/i;
+var SECRET_ASSIGNMENT = /((?:[A-Za-z0-9_]*(?:api[_-]?key|access[_-]?key(?:_id)?|authorization|credential|password|passwd|private[_-]?key|secret|token)[A-Za-z0-9_]*)\s*[:=]\s*)([^\s,;]+)/gi;
+var PRIVATE_KEY_BLOCK = /-----BEGIN (?:RSA |EC |OPENSSH )?PRIVATE KEY-----[\s\S]*?-----END (?:RSA |EC |OPENSSH )?PRIVATE KEY-----/g;
+var AUTHENTICATED_URL = /([a-z][a-z0-9+.-]*:\/\/)([^/\s:@]+):([^@\s/]+)@/gi;
+function redactJournalString(value) {
+  return value.replace(PRIVATE_KEY_BLOCK, "[REDACTED PRIVATE KEY]").replace(AUTHENTICATED_URL, "$1[REDACTED]@").replace(SECRET_ASSIGNMENT, "$1[REDACTED]");
+}
+function boundedJournalValue(value, key = "") {
+  if (SENSITIVE_KEY.test(key))
+    return "[REDACTED]";
+  if (typeof value === "string") {
+    const redacted = redactJournalString(value);
+    if (redacted.length <= 4000)
+      return redacted;
+    const digest = createHash("sha256").update(value).digest("hex");
+    return `${redacted.slice(0, 4000)}
+...[${redacted.length - 4000} chars omitted; original sha256=${digest}]`;
+  }
+  if (Array.isArray(value))
+    return value.map((item) => boundedJournalValue(item));
+  if (value && typeof value === "object") {
+    return Object.fromEntries(Object.entries(value).map(([childKey, item]) => [childKey, boundedJournalValue(item, childKey)]));
+  }
+  return value;
+}
+function runtimeEventForJournal(event) {
+  if (event.type === "tool_call")
+    return { ...event, arguments: boundedJournalValue(event.arguments) };
+  if (event.type === "tool_result") {
+    return {
+      ...event,
+      content: boundedJournalValue(event.content),
+      ...event.data ? { data: boundedJournalValue(event.data) } : {}
+    };
+  }
+  return event;
+}
+function hashEnvelope(envelope) {
+  return createHash("sha256").update(JSON.stringify(envelope)).digest("hex");
+}
+function eventJournalPath(root, sessionId) {
+  if (!/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/.test(sessionId))
+    throw new Error("Session id contains unsafe characters");
+  return path2.join(root, ".archymedes", "events", `${sessionId}.jsonl`);
+}
+async function readEventJournal(root, sessionId) {
+  return (await readJournalFile(root, sessionId)).events;
+}
+async function readJournalFile(root, sessionId) {
+  const file = eventJournalPath(root, sessionId);
+  let text;
+  try {
+    text = await fs2.readFile(file, "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT")
+      return { events: [], text: "", completeText: "" };
+    throw error;
+  }
+  const completeText = text.endsWith(`
+`) ? text : text.slice(0, text.lastIndexOf(`
+`) + 1);
+  const events = completeText.split(`
+`).filter(Boolean).map((line) => JSON.parse(line));
+  let previousHash = JOURNAL_GENESIS_HASH;
+  for (let index = 0;index < events.length; index += 1) {
+    const event = events[index];
+    if (event.protocolVersion !== ARCHYMEDES_PROTOCOL_VERSION)
+      throw new Error(`Unsupported Archymedes protocol version ${event.protocolVersion}`);
+    if (event.sessionId !== sessionId || event.sequence !== index + 1 || event.previousHash !== previousHash) {
+      throw new Error(`Invalid Archymedes event chain at sequence ${event.sequence}`);
+    }
+    const { hash, ...withoutHash } = event;
+    if (hash !== hashEnvelope(withoutHash))
+      throw new Error(`Archymedes event integrity check failed at sequence ${event.sequence}`);
+    previousHash = hash;
+  }
+  return { events, text, completeText };
+}
+
+class EventJournal {
+  root;
+  sessionId;
+  handle = null;
+  releaseOwnership;
+  closed = false;
+  sequence = 0;
+  previousHash = JOURNAL_GENESIS_HASH;
+  initialized = null;
+  tail = Promise.resolve();
+  constructor(root, sessionId) {
+    this.root = root;
+    this.sessionId = sessionId;
+  }
+  async initialize() {
+    this.releaseOwnership = await acquireFileOwnership(`${eventJournalPath(this.root, this.sessionId)}.owner`);
+    try {
+      const { events, text, completeText } = await readJournalFile(this.root, this.sessionId);
+      this.sequence = events.length;
+      this.previousHash = events.at(-1)?.hash ?? JOURNAL_GENESIS_HASH;
+      const file = eventJournalPath(this.root, this.sessionId);
+      await fs2.mkdir(path2.dirname(file), { recursive: true });
+      if (text.length !== completeText.length)
+        await fs2.truncate(file, Buffer.byteLength(completeText, "utf8"));
+      this.handle = await fs2.open(file, "a", 384);
+    } catch (error) {
+      await this.releaseOwnership();
+      this.releaseOwnership = undefined;
+      throw error;
+    }
+  }
+  async open() {
+    if (this.closed)
+      throw new Error("Session journal is closed");
+    this.initialized ??= this.initialize();
+    await this.initialized;
+  }
+  append(payload, options = {}) {
+    if (this.closed)
+      return Promise.reject(new Error("Session journal is closed"));
+    let written;
+    const operation = this.tail.then(async () => {
+      await this.open();
+      const withoutHash = {
+        protocolVersion: ARCHYMEDES_PROTOCOL_VERSION,
+        sequence: this.sequence + 1,
+        sessionId: this.sessionId,
+        timestamp: new Date().toISOString(),
+        previousHash: this.previousHash,
+        payload
+      };
+      written = { ...withoutHash, hash: hashEnvelope(withoutHash) };
+      await this.handle.write(`${JSON.stringify(written)}
+`);
+      if (options.durable)
+        await this.handle.sync();
+      this.sequence = written.sequence;
+      this.previousHash = written.hash;
+    });
+    this.tail = operation;
+    return operation.then(() => written);
+  }
+  async flush() {
+    await this.tail;
+    await this.handle?.sync();
+  }
+  async close() {
+    try {
+      await this.initialized;
+      await this.flush();
+    } finally {
+      this.closed = true;
+      try {
+        await this.handle?.close();
+      } finally {
+        this.handle = null;
+        await this.releaseOwnership?.();
+        this.releaseOwnership = undefined;
+      }
+    }
+  }
+}
+
+export { OwnershipHeldError, acquireFileOwnership, assertTurnTransition, runtimeEventForJournal, eventJournalPath, readEventJournal, EventJournal };

package/dist/{editor-screen-g08zzt70.mjs → editor-screen-e01mn7dd.mjs}

@@ -1,20 +1,21 @@
 import {
   diffLines,
   languageOf
-} from "./archymedes-dz59nvw7.mjs";
-import"./archymedes-tsne2m7p.mjs";
+} from "./archymedes-2kvjaajw.mjs";
+import"./archymedes-bmtdqqwt.mjs";
 import {
-  NO_COLOR_PALETTE
-} from "./archymedes-a10k8yrk.mjs";
+  NO_COLOR_PALETTE,
+  exitTopTermUIApp
+} from "./archymedes-130jt0wr.mjs";
 import {
   __require
 } from "./archymedes-x67v3n58.mjs";
 
-// src/ui/editor-screen.tsx
-import { useInput, useState } from "@termuijs/jsx";
+// packages/archymedes-cli/src/ui/editor-screen.tsx
+import { useEffect, useInput, useRef, useState } from "@termuijs/jsx";
 import { Box, Text } from "@termuijs/widgets";
 
-// src/ui/editor.ts
+// packages/archymedes-cli/src/ui/editor.ts
 function initialEditorState(path, content, viewportRows = 20) {
   const lines = content.split(`
 `);
@@ -79,6 +80,15 @@ function keyToEditorAction(key, character, state) {
     return { kind: "save" };
   if (key.ctrl && (name === "q" || name === "c"))
     return { kind: "quit" };
+  if (state.confirmLeave) {
+    if (character === "y" || character === "Y" || isEnter)
+      return { kind: "save" };
+    if (character === "n" || character === "N")
+      return { kind: "quit" };
+    if (isEscape)
+      return { kind: "cancelLeave" };
+    return { kind: "none" };
+  }
   if (state.search.typing) {
     if (isEscape)
       return { kind: "searchCommit" };
@@ -116,7 +126,7 @@ function keyToEditorAction(key, character, state) {
   if (state.pending === "g")
     return name === "g" || character === "g" ? { kind: "jump", to: "fileStart" } : { kind: "normal" };
   if (isEscape)
-    return { kind: "normal" };
+    return { kind: "leave" };
   if (name === "up" || character === "k")
     return { kind: "move", rows: -1 };
   if (name === "down" || character === "j")
@@ -269,7 +279,15 @@ function applyEditorAction(state, action) {
     case "save":
       return { state: clamp({ ...state, dirty: false, message: `saved ${state.path}`, pending: undefined }), effect: { kind: "save" } };
     case "quit":
-      return { state, effect: { kind: "quit" } };
+      return { state: { ...state, confirmLeave: false }, effect: { kind: "quit" } };
+    case "leave":
+      if (!state.dirty)
+        return { state, effect: { kind: "quit" } };
+      return { state: { ...state, pending: undefined, confirmLeave: true, message: "Save changes? y yes · n discard · Esc keep editing" }, effect: undefined };
+    case "cancelLeave":
+      return plain({ ...state, confirmLeave: false, message: undefined });
+    case "autosaved":
+      return editorContent(state) === action.content ? plain({ ...state, dirty: false, message: "auto-saved" }) : plain(state);
     case "search":
       return plain({ ...state, search: { query: "", typing: true }, message: undefined });
     case "searchType":
@@ -311,7 +329,8 @@ function editorKeyBar(state, columns = Number.POSITIVE_INFINITY) {
     { text: "u undo" },
     { text: "/ find" },
     { text: "^S save", essential: true },
-    { text: "^Q quit", essential: true }
+    { text: "^Q quit", essential: true },
+    { text: "esc back", essential: true }
   ];
   const optional = hints.filter((hint) => !hint.essential);
   for (let dropped = 0;dropped <= optional.length; dropped += 1) {
@@ -347,7 +366,7 @@ function caretInto(text, cursorCol) {
   return `${padded.slice(0, cursorCol)}█${padded.slice(cursorCol + 1)}`;
 }
 
-// src/ui/explain-view.ts
+// packages/archymedes-cli/src/ui/explain-view.ts
 var PATTERNS = {
   typescript: {
     imports: /^\s*import\b.*from\s+["'](.+)["']/,
@@ -531,7 +550,7 @@ function composeExplainPanel(input, width, height, colors = DEFAULT_EXPLAIN_COLO
   return padded;
 }
 
-// src/ui/editor-screen.tsx
+// packages/archymedes-cli/src/ui/editor-screen.tsx
 import { jsxDEV } from "@termuijs/jsx/jsx-dev-runtime";
 var Panel = Box;
 var Line = Text;
@@ -543,8 +562,22 @@ function panelWidthFor(columns) {
     return 0;
   return Math.min(MAX_PANEL_COLUMNS, Math.floor(columns * 0.38), columns - MIN_CODE_COLUMNS);
 }
-function EditorScreen({ columns, rows, path, content, onExit, palette = NO_COLOR_PALETTE, explain }) {
+function EditorScreen({ columns, rows, path, content, onExit, palette = NO_COLOR_PALETTE, explain, autosave, autosaveDelayMs = 1000 }) {
   const [state, setState] = useState(() => initialEditorState(path, content, Math.max(1, rows - CHROME_ROWS)));
+  const timer = useRef(undefined);
+  const text = editorContent(state);
+  useEffect(() => {
+    if (!autosave || !state.dirty || state.confirmLeave)
+      return;
+    const pending = text;
+    timer.current = setTimeout(() => {
+      autosave(pending).then(() => setState((current) => applyEditorAction(current, { kind: "autosaved", content: pending }).state), () => setState((current) => ({ ...current, message: "auto-save failed — Ctrl+S to retry" })));
+    }, autosaveDelayMs);
+    return () => {
+      if (timer.current)
+        clearTimeout(timer.current);
+    };
+  }, [text, state.dirty, state.confirmLeave]);
   const [panel, setPanel] = useState(() => initialExplainPanelState());
   const panelWidth = panel.open ? panelWidthFor(columns) : 0;
   const codeWidth = panelWidth > 0 ? columns - panelWidth - 1 : columns;
@@ -554,7 +587,7 @@ function EditorScreen({ columns, rows, path, content, onExit, palette = NO_COLOR
       return;
     }
     setPanel((current) => withAiExplanation(current, { status: "loading" }));
-    explain(currentContent, path).then((text) => setPanel((current) => withAiExplanation(current, { status: "ready", text })), (error) => setPanel((current) => withAiExplanation(current, { status: "error", message: error instanceof Error ? error.message : String(error) })));
+    explain(currentContent, path).then((text2) => setPanel((current) => withAiExplanation(current, { status: "ready", text: text2 })), (error) => setPanel((current) => withAiExplanation(current, { status: "error", message: error instanceof Error ? error.message : String(error) })));
   };
   useInput((input, key) => {
     if (key?.ctrl && key?.key === "e") {
@@ -629,6 +662,7 @@ async function runEditorScreen(options) {
       if (settled)
         return;
       settled = true;
+      exitTopTermUIApp();
       resolve(saved);
     };
     renderApp(EditorScreen, {
@@ -638,6 +672,7 @@ async function runEditorScreen(options) {
       content: options.content,
       palette: options.palette,
       explain: options.explain,
+      autosave: options.autosave,
       onExit: finish,
       fullscreen: true
     }).catch(() => finish(undefined));