flavor-code 1.3.2 → 1.3.4

package/dist/desktop/main.js

@@ -8025,7 +8025,7 @@ function toModelTool(tool) {
 
 // src/harness/journal.ts
 import { createHash as createHash6, randomUUID as randomUUID8 } from "crypto";
-import { closeSync, constants as constants2, existsSync as existsSync2, fsyncSync, mkdirSync, openSync, readFileSync, realpathSync as realpathSync2, statSync, truncateSync, writeSync } from "fs";
+import { closeSync, constants as constants2, existsSync as existsSync2, fsyncSync, mkdirSync, openSync, readFileSync, realpathSync as realpathSync2, renameSync, statSync, truncateSync, unlinkSync, writeSync } from "fs";
 import { join as join8, relative as relative6, resolve as resolve8, sep as sep6 } from "path";
 import { z as z15 } from "zod";
 
@@ -8036,8 +8036,10 @@ function harnessInvariantViolations(records) {
   const tools = /* @__PURE__ */ new Set();
   const models = /* @__PURE__ */ new Set();
   const turns = /* @__PURE__ */ new Set();
+  const firstSequence = records[0]?.sequence ?? 1;
   records.forEach((record3, index) => {
-    if (record3.sequence !== index + 1) violations.push(`sequence ${record3.sequence} is not ${index + 1}`);
+    const expectedSequence = firstSequence + index;
+    if (record3.sequence !== expectedSequence) violations.push(`sequence ${record3.sequence} is not ${expectedSequence}`);
     const id = typeof record3.payload.id === "string" ? record3.payload.id : "";
     if (record3.type === "queue.admitted") {
       if (queues.has(id)) violations.push(`queue ${id} was admitted twice`);
@@ -8053,13 +8055,13 @@ function harnessInvariantViolations(records) {
       if (!tools.delete(id)) violations.push(`${record3.type} references unknown tool ${id}`);
     } else if (record3.type === "model.requested") {
       if (models.has(id)) violations.push(`model ${id} was requested twice`);
-      if (!Array.isArray(record3.payload.messages)) violations.push(`model ${id} has no replayable messages`);
+      if (!isHash(record3.payload.messagesHash)) violations.push(`model ${id} has no valid messages hash`);
       models.add(id);
     } else if (record3.type === "model.completed") {
       if (!models.delete(id)) violations.push(`model.completed references unknown model ${id}`);
     } else if (record3.type === "turn.started") {
       if (turns.has(id)) violations.push(`turn ${id} was started twice`);
-      if (!("prompt" in record3.payload)) violations.push(`turn ${id} has no replayable prompt`);
+      if (!isHash(record3.payload.promptHash)) violations.push(`turn ${id} has no valid prompt hash`);
       turns.add(id);
     } else if (record3.type === "turn.completed" || record3.type === "turn.interrupted") {
       if (!turns.delete(id)) violations.push(`${record3.type} references unknown turn ${id}`);
@@ -8067,6 +8069,9 @@ function harnessInvariantViolations(records) {
   });
   return violations;
 }
+function isHash(value) {
+  return typeof value === "string" && /^[a-f0-9]{64}$/.test(value);
+}
 function assertHarnessInvariants(records) {
   const violations = harnessInvariantViolations(records);
   if (violations.length > 0) throw new Error(`Harness invariant violation: ${violations.join("; ")}`);
@@ -8147,7 +8152,7 @@ var HarnessJournal = class {
   }
   startTurn(config, prompt) {
     const id = randomUUID8();
-    this.#append("turn.started", { id, config: structuredClone(config), configHash: hashJson(config), prompt: structuredClone(prompt), promptHash: hashJson(prompt) });
+    this.#append("turn.started", { id, configHash: hashJson(config), promptHash: hashJson(prompt) });
     return id;
   }
   completeTurn(id) {
@@ -8158,7 +8163,14 @@ var HarnessJournal = class {
   }
   startModel(input) {
     const id = randomUUID8();
-    this.#append("model.requested", { id, ...structuredClone(input), messagesHash: hashJson(input.messages) });
+    this.#append("model.requested", {
+      id,
+      agent: input.agent,
+      model: input.model,
+      iteration: input.iteration,
+      attempt: input.attempt,
+      messagesHash: hashJson(input.messages)
+    });
     return id;
   }
   completeModel(id, completed, error) {
@@ -8166,11 +8178,11 @@ var HarnessJournal = class {
   }
   startTool(tool, input, retrySafe) {
     const id = randomUUID8();
-    this.#append("tool.started", { id, tool, input: structuredClone(input), inputHash: hashJson(input), retrySafe });
+    this.#append("tool.started", { id, tool, inputHash: hashJson(input), retrySafe });
     return id;
   }
   completeTool(id, result) {
-    this.#append("tool.completed", { id, result: structuredClone(result) });
+    this.#append("tool.completed", { id, resultHash: hashJson(result) });
   }
   interruptTool(id, reason) {
     this.#append("tool.interrupted", { id, reason });
@@ -8247,47 +8259,153 @@ var HarnessJournal = class {
     const committed = raw.endsWith("\n") ? raw : raw.slice(0, Math.max(0, raw.lastIndexOf("\n") + 1));
     if (committed.length !== raw.length) truncateSync(this.#path, Buffer.byteLength(committed));
     const lines = committed.split("\n").filter(Boolean);
-    let previousHash = null;
+    let previousHash;
+    let expectedSequence;
     for (const line of lines) {
       const record3 = JournalRecordSchema.parse(JSON.parse(line));
-      if (record3.sequence !== this.#records.length + 1) throw new Error("Harness journal sequence is not contiguous");
+      expectedSequence ??= record3.sequence;
+      previousHash ??= record3.previousHash;
+      if (record3.sequence !== expectedSequence) throw new Error("Harness journal sequence is not contiguous");
       if (record3.previousHash !== previousHash) throw new Error("Harness journal hash chain is broken");
       if (record3.hash !== recordHash(record3)) throw new Error("Harness journal record hash is invalid");
       this.#records.push(record3);
       previousHash = record3.hash;
+      expectedSequence += 1;
     }
-    this.#sequence = this.#records.length;
-    this.#lastHash = previousHash;
+    this.#sequence = this.#records.at(-1)?.sequence ?? 0;
+    this.#lastHash = previousHash ?? null;
     assertHarnessInvariants(this.#records);
+    const hasRotatedPrefix = (this.#records[0]?.sequence ?? 1) !== 1;
+    if (metadata.size > this.#maxBytes * 0.75 || hasRotatedPrefix || this.#records.some(hasLegacyPayload)) this.#compact();
   }
   #append(type, payload) {
     const normalizedPayload = jsonSafeRecord(payload);
+    let record3 = this.#createRecord(type, normalizedPayload);
+    let line = `${JSON.stringify(record3)}
+`;
+    let priorBytes = existsSync2(this.#path) ? statSync(this.#path).size : 0;
+    if (priorBytes + Buffer.byteLength(line) > this.#maxBytes) {
+      this.#compact();
+      record3 = this.#createRecord(type, normalizedPayload);
+      line = `${JSON.stringify(record3)}
+`;
+      priorBytes = existsSync2(this.#path) ? statSync(this.#path).size : 0;
+      if (priorBytes + Buffer.byteLength(line) > this.#maxBytes) {
+        throw new Error(`Harness journal event exceeds the ${this.#maxBytes} byte bounded journal capacity`);
+      }
+    }
+    const fd = openSync(this.#path, constants2.O_CREAT | constants2.O_APPEND | constants2.O_WRONLY, 384);
+    try {
+      writeSync(fd, line, void 0, "utf8");
+      fsyncSync(fd);
+    } finally {
+      closeSync(fd);
+    }
+    this.#records.push(record3);
+    this.#sequence = record3.sequence;
+    this.#lastHash = record3.hash;
+  }
+  #createRecord(type, payload) {
     const unsigned = {
       version: HARNESS_JOURNAL_VERSION,
       sequence: this.#sequence + 1,
       id: randomUUID8(),
       timestamp: this.#now(),
       type,
-      payload: normalizedPayload,
+      payload,
       previousHash: this.#lastHash
     };
-    const record3 = JournalRecordSchema.parse({ ...unsigned, hash: hashJson(unsigned) });
-    const line = `${JSON.stringify(record3)}
-`;
-    const priorBytes = existsSync2(this.#path) ? statSync(this.#path).size : 0;
-    if (priorBytes + Buffer.byteLength(line) > this.#maxBytes) throw new Error(`Harness journal exceeds ${this.#maxBytes} bytes`);
-    const fd = openSync(this.#path, constants2.O_CREAT | constants2.O_APPEND | constants2.O_WRONLY, 384);
+    return JournalRecordSchema.parse({ ...unsigned, hash: hashJson(unsigned) });
+  }
+  #compact() {
+    const queues = /* @__PURE__ */ new Map();
+    const claims = /* @__PURE__ */ new Map();
+    const tools = /* @__PURE__ */ new Map();
+    const models = /* @__PURE__ */ new Map();
+    const turns = /* @__PURE__ */ new Map();
+    let savepoint;
+    for (const record3 of this.#records) {
+      const id = typeof record3.payload.id === "string" ? record3.payload.id : "";
+      if (record3.type === "queue.admitted") queues.set(id, record3);
+      else if (record3.type === "queue.claimed") claims.set(id, record3);
+      else if (record3.type === "queue.released") claims.delete(id);
+      else if (record3.type === "queue.acked") {
+        queues.delete(id);
+        claims.delete(id);
+      } else if (record3.type === "tool.started") tools.set(id, record3);
+      else if (record3.type === "tool.completed" || record3.type === "tool.interrupted") tools.delete(id);
+      else if (record3.type === "model.requested") models.set(id, record3);
+      else if (record3.type === "model.completed") models.delete(id);
+      else if (record3.type === "turn.started") turns.set(id, record3);
+      else if (record3.type === "turn.completed" || record3.type === "turn.interrupted") turns.delete(id);
+      else if (record3.type === "savepoint.created") savepoint = record3;
+    }
+    const retained = [
+      ...queues.values(),
+      ...claims.values(),
+      ...tools.values(),
+      ...models.values(),
+      ...turns.values(),
+      ...savepoint === void 0 ? [] : [savepoint]
+    ].sort((left, right) => left.sequence - right.sequence);
+    const compacted = [];
+    let previousHash = null;
+    for (const source of retained) {
+      const unsigned = {
+        version: HARNESS_JOURNAL_VERSION,
+        sequence: compacted.length + 1,
+        id: randomUUID8(),
+        timestamp: source.timestamp,
+        type: source.type,
+        payload: compactPayload(source),
+        previousHash
+      };
+      const record3 = JournalRecordSchema.parse({ ...unsigned, hash: hashJson(unsigned) });
+      compacted.push(record3);
+      previousHash = record3.hash;
+    }
+    const contents = compacted.map((record3) => `${JSON.stringify(record3)}
+`).join("");
+    if (Buffer.byteLength(contents) > this.#maxBytes) return;
+    const temporary = `${this.#path}.compact-${process.pid}-${randomUUID8()}`;
+    const fd = openSync(temporary, constants2.O_CREAT | constants2.O_EXCL | constants2.O_WRONLY, 384);
     try {
-      writeSync(fd, line, void 0, "utf8");
+      writeSync(fd, contents, void 0, "utf8");
       fsyncSync(fd);
     } finally {
       closeSync(fd);
     }
-    this.#records.push(record3);
-    this.#sequence = record3.sequence;
-    this.#lastHash = record3.hash;
+    try {
+      renameSync(temporary, this.#path);
+    } catch (error) {
+      if (existsSync2(temporary)) unlinkSync(temporary);
+      throw error;
+    }
+    this.#records = compacted;
+    this.#sequence = compacted.length;
+    this.#lastHash = previousHash;
   }
 };
+function compactPayload(record3) {
+  const payload = record3.payload;
+  if (record3.type === "queue.admitted") return payload;
+  if (record3.type === "queue.claimed") return { id: payload.id };
+  if (record3.type === "tool.started") return pick(payload, ["id", "tool", "inputHash", "retrySafe"]);
+  if (record3.type === "model.requested") return pick(payload, ["id", "agent", "model", "iteration", "attempt", "messagesHash"]);
+  if (record3.type === "turn.started") return pick(payload, ["id", "configHash", "promptHash"]);
+  if (record3.type === "savepoint.created") return pick(payload, ["id", "phase", "configHash"]);
+  return payload;
+}
+function hasLegacyPayload(record3) {
+  if (record3.type === "turn.started") return "config" in record3.payload || "prompt" in record3.payload;
+  if (record3.type === "model.requested") return "messages" in record3.payload;
+  if (record3.type === "tool.started") return "input" in record3.payload;
+  if (record3.type === "tool.completed") return "result" in record3.payload;
+  return false;
+}
+function pick(source, keys) {
+  return Object.fromEntries(keys.flatMap((key) => key in source ? [[key, source[key]]] : []));
+}
 function jsonSafeRecord(value) {
   const json = JSON.stringify(value, (_key, item) => typeof item === "bigint" ? `${item}n` : item);
   return JSON.parse(json);
@@ -10294,7 +10412,7 @@ ${result.stderr.slice(-4e3)}` : ""}`;
 
 // src/init/project.ts
 import { lstat as lstat4, mkdir as mkdir9, readdir as readdir4, readFile as readFile9, realpath as realpath7, writeFile as writeFile8 } from "fs/promises";
-import { copyFileSync, mkdirSync as mkdirSync2, readdirSync, readFileSync as readFileSync2 } from "fs";
+import { copyFileSync, mkdirSync as mkdirSync2, readdirSync } from "fs";
 import { basename as basename4, dirname as dirname9, isAbsolute as isAbsolute7, join as join12, relative as relative8, sep as sep8 } from "path";
 import { fileURLToPath } from "url";
 var GENERATED_START = "<!-- flavor-code:start -->";
@@ -10747,22 +10865,6 @@ async function createExampleFlavorConfig(cwd) {
   };
   await writeFile8(configPath, JSON.stringify(example, null, 2) + "\n");
 }
-var CODEISLAND_SRC_DIR = join12(dirname9(fileURLToPath(import.meta.url)), "codeisland");
-var CODEISLAND_FILES = ["flavor-plugin.json", "activate.mjs", "bridge.mjs"];
-async function copyCodeIslandPlugin(cwd) {
-  const pluginDir = join12(cwd, ".flavor", "plugins", "codeisland");
-  try {
-    await lstat4(pluginDir);
-    return;
-  } catch (error) {
-    if (!isMissingPathError(error)) throw error;
-  }
-  await mkdir9(pluginDir, { recursive: true, mode: 448 });
-  for (const name of CODEISLAND_FILES) {
-    const content = readFileSync2(join12(CODEISLAND_SRC_DIR, name), "utf8");
-    await writeFile8(join12(pluginDir, name), content);
-  }
-}
 var ASTGRAPH_SRC_DIR = join12(dirname9(fileURLToPath(import.meta.url)), "astgraph");
 async function copyAstgraphPlugin(cwd) {
   const pluginDir = join12(cwd, ".flavor", "plugins", "astgraph");
@@ -10785,7 +10887,6 @@ function copyDirectory(from, to) {
 }
 async function initializeFlavor(cwd) {
   await ensureFlavorDirectories(cwd);
-  await copyCodeIslandPlugin(cwd);
   await copyAstgraphPlugin(cwd);
   await createExampleFlavorConfig(cwd);
   const facts = await inspectProject(cwd);
@@ -13686,7 +13787,7 @@ import {
 } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
 
 // src/utils/version.ts
-import { readFileSync as readFileSync3 } from "fs";
+import { readFileSync as readFileSync2 } from "fs";
 import { dirname as dirname13, join as join20 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 var cached;
@@ -13695,7 +13796,7 @@ function packageVersion() {
   let directory = dirname13(fileURLToPath2(import.meta.url));
   for (; ; ) {
     try {
-      const manifest = JSON.parse(readFileSync3(join20(directory, "package.json"), "utf8"));
+      const manifest = JSON.parse(readFileSync2(join20(directory, "package.json"), "utf8"));
       if (typeof manifest.version === "string" && manifest.version.length > 0) {
         cached = manifest.version;
         return cached;
@@ -24309,7 +24410,10 @@ async function createProductionRuntime(options) {
     globalPluginDirs: [join31(home, ".flavor-code", "plugins")],
     projectPluginDirs: [join31(workspace, ".flavor", "plugins")],
     config,
-    sandbox: options.pluginSandbox ?? true,
+    // Existing project plugins (including astgraph and superharness) use Node.js
+    // built-ins. The Worker/vm sandbox deliberately blocks those imports, so it
+    // must stay opt-in until equivalent mediated capabilities are available.
+    sandbox: options.pluginSandbox ?? false,
     registrations: {
       command(name, handler, description) {
         if (typeof handler !== "function") throw new Error(`Plugin command "${name}" must be a function.`);