opencode-swarm 7.152.1 → 7.153.1

package/dist/cli/index-3cegckkq.js

@@ -0,0 +1,239 @@
+// @bun
+import {
+  validateSwarmPath
+} from "./index-4cgee5vh.js";
+import {
+  atomicWriteSwarmFileSync
+} from "./index-td0jz8xe.js";
+
+// src/hooks/delegation-gate/worktree-provisioning-owner.ts
+import { createHash } from "crypto";
+import * as fs from "fs";
+import * as path from "path";
+var PROVISIONING_OWNER_DIR = "worktree-provisioning-owners";
+var MAX_PROVISIONING_OWNERS = 512;
+var MAX_PROVISIONING_OWNER_BYTES = 16 * 1024;
+var PROVISIONING_JOURNAL_PATH = path.join(".swarm", "worktree-provisioning-lifecycle.json");
+var MAX_PROVISIONING_JOURNAL_BYTES = 256 * 1024;
+var MAX_PROVISIONING_JOURNAL_ENTRIES = 512;
+var WORKTREE_PROVISIONING_OWNER_LEASE_MS = 5 * 60 * 1000;
+var WORKTREE_LIFECYCLE_LOCK_FILE = ".swarm/locks/init-orphan-recovery.lock";
+var WORKTREE_PROVISIONING_LIFECYCLE_STATES = [
+  "OWNER_PUBLISHED",
+  "OWNER_REMOVED"
+];
+function ownerDirectory(directory) {
+  return path.dirname(validateSwarmPath(directory, path.join(PROVISIONING_OWNER_DIR, ".containment-anchor")));
+}
+function ownerPath(directory, callID) {
+  const digest = createHash("sha256").update(callID).digest("hex");
+  return validateSwarmPath(directory, path.join(PROVISIONING_OWNER_DIR, `${digest}.json`));
+}
+function journalPath(directory) {
+  return validateSwarmPath(directory, PROVISIONING_JOURNAL_PATH);
+}
+function isOwner(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    return false;
+  const candidate = value;
+  const schemaVersion = candidate.schemaVersion;
+  const validTaskIdentity = schemaVersion === 1 ? candidate.taskId === undefined && candidate.reservationId === undefined && candidate.generation === undefined && candidate.branchName === undefined : schemaVersion === 2 && typeof candidate.taskId === "string" && candidate.taskId.length > 0 && candidate.taskId.length <= 512 && candidate.reservationId === undefined && candidate.generation === undefined && candidate.branchName === undefined;
+  const validV3Identity = schemaVersion === 3 && typeof candidate.taskId === "string" && candidate.taskId.length > 0 && candidate.taskId.length <= 512 && typeof candidate.reservationId === "string" && candidate.reservationId.length > 0 && candidate.reservationId.length <= 512 && typeof candidate.generation === "number" && Number.isInteger(candidate.generation) && candidate.generation > 0 && typeof candidate.branchName === "string" && candidate.branchName.length > 0 && candidate.branchName.length <= 1024;
+  return (schemaVersion === 1 || schemaVersion === 2 || schemaVersion === 3) && (validTaskIdentity || validV3Identity) && typeof candidate.callID === "string" && candidate.callID.length > 0 && candidate.callID.length <= 512 && typeof candidate.parentSessionId === "string" && candidate.parentSessionId.length > 0 && candidate.parentSessionId.length <= 512 && typeof candidate.worktreeSessionId === "string" && candidate.worktreeSessionId.length > 0 && candidate.worktreeSessionId.length <= 512 && typeof candidate.createdAt === "number" && Number.isFinite(candidate.createdAt) && candidate.createdAt >= 0;
+}
+function isLifecycleEntry(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    return false;
+  const candidate = value;
+  const validState = WORKTREE_PROVISIONING_LIFECYCLE_STATES.includes(candidate.state);
+  return candidate.schemaVersion === 1 && validState && typeof candidate.callID === "string" && candidate.callID.length > 0 && candidate.callID.length <= 512 && typeof candidate.parentSessionId === "string" && candidate.parentSessionId.length > 0 && candidate.parentSessionId.length <= 512 && typeof candidate.worktreeSessionId === "string" && candidate.worktreeSessionId.length > 0 && candidate.worktreeSessionId.length <= 512 && (candidate.taskId === undefined || typeof candidate.taskId === "string" && candidate.taskId.length > 0 && candidate.taskId.length <= 512) && (candidate.reservationId === undefined || typeof candidate.reservationId === "string" && candidate.reservationId.length > 0 && candidate.reservationId.length <= 512) && (candidate.generation === undefined || typeof candidate.generation === "number" && Number.isInteger(candidate.generation) && candidate.generation > 0) && (candidate.branchName === undefined || typeof candidate.branchName === "string" && candidate.branchName.length > 0 && candidate.branchName.length <= 1024) && typeof candidate.recordedAt === "number" && Number.isFinite(candidate.recordedAt) && candidate.recordedAt >= 0;
+}
+function readBoundedJsonFile(filePath, maxBytes) {
+  try {
+    const stat = fs.statSync(filePath);
+    if (stat.size > maxBytes) {
+      return {
+        ok: false,
+        reason: `${path.basename(filePath)} exceeds the ${maxBytes}-byte safety bound`
+      };
+    }
+    const raw = fs.readFileSync(filePath, "utf8");
+    if (Buffer.byteLength(raw, "utf8") > maxBytes) {
+      return {
+        ok: false,
+        reason: `${path.basename(filePath)} changed beyond the ${maxBytes}-byte safety bound`
+      };
+    }
+    return { ok: true, value: JSON.parse(raw) };
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return { ok: true, value: undefined };
+    }
+    return {
+      ok: false,
+      reason: `${path.basename(filePath)} is unreadable or malformed: ${error instanceof Error ? error.message : String(error)}`
+    };
+  }
+}
+function readOwner(directory, callID) {
+  const absolutePath = ownerPath(directory, callID);
+  const loaded = readBoundedJsonFile(absolutePath, MAX_PROVISIONING_OWNER_BYTES);
+  if (!loaded.ok || loaded.value === undefined)
+    return null;
+  return isOwner(loaded.value) ? loaded.value : null;
+}
+function loadLifecycleJournal(directory) {
+  const loaded = readBoundedJsonFile(journalPath(directory), MAX_PROVISIONING_JOURNAL_BYTES);
+  if (!loaded.ok)
+    return { status: "uncertain", reason: loaded.reason };
+  if (loaded.value === undefined)
+    return { status: "ok", entries: [] };
+  const parsed = loaded.value;
+  if (parsed.schemaVersion !== 1 || !Array.isArray(parsed.entries)) {
+    return {
+      status: "uncertain",
+      reason: "worktree provisioning lifecycle journal is malformed"
+    };
+  }
+  if (parsed.entries.length > MAX_PROVISIONING_JOURNAL_ENTRIES) {
+    return {
+      status: "uncertain",
+      reason: `worktree provisioning lifecycle journal exceeds the ${MAX_PROVISIONING_JOURNAL_ENTRIES}-entry safety bound`
+    };
+  }
+  const entries = [];
+  for (const entry of parsed.entries) {
+    if (!isLifecycleEntry(entry)) {
+      return {
+        status: "uncertain",
+        reason: "worktree provisioning lifecycle journal contains an invalid entry"
+      };
+    }
+    entries.push(entry);
+  }
+  return { status: "ok", entries };
+}
+function appendLifecycleEntry(directory, owner, state) {
+  const loaded = loadLifecycleJournal(directory);
+  if (loaded.status === "uncertain") {
+    throw new Error(loaded.reason);
+  }
+  const entries = [
+    ...loaded.entries,
+    {
+      schemaVersion: 1,
+      state,
+      callID: owner.callID,
+      parentSessionId: owner.parentSessionId,
+      worktreeSessionId: owner.worktreeSessionId,
+      ...owner.taskId ? { taskId: owner.taskId } : {},
+      ...owner.reservationId ? { reservationId: owner.reservationId } : {},
+      ...owner.generation !== undefined ? { generation: owner.generation } : {},
+      ...owner.branchName ? { branchName: owner.branchName } : {},
+      recordedAt: Date.now()
+    }
+  ];
+  const journal = {
+    schemaVersion: 1,
+    entries: entries.slice(-MAX_PROVISIONING_JOURNAL_ENTRIES)
+  };
+  atomicWriteSwarmFileSync(journalPath(directory), JSON.stringify(journal, null, 2));
+}
+function recordWorktreeProvisioningOwner(directory, input) {
+  const wantsV3 = input.reservationId !== undefined || input.generation !== undefined || input.branchName !== undefined;
+  if (wantsV3 && (!input.taskId || !input.reservationId || input.generation === undefined || !input.branchName)) {
+    throw new Error("worktree provisioning owner v3 requires taskId, reservationId, generation, and branchName");
+  }
+  const owner = {
+    schemaVersion: wantsV3 ? 3 : input.taskId ? 2 : 1,
+    callID: input.callID,
+    parentSessionId: input.parentSessionId,
+    worktreeSessionId: input.worktreeSessionId,
+    ...input.taskId ? { taskId: input.taskId } : {},
+    ...input.reservationId ? { reservationId: input.reservationId } : {},
+    ...input.generation !== undefined ? { generation: input.generation } : {},
+    ...input.branchName ? { branchName: input.branchName } : {},
+    createdAt: Date.now()
+  };
+  if (!isOwner(owner)) {
+    throw new Error("invalid worktree provisioning owner");
+  }
+  const absolutePath = ownerPath(directory, input.callID);
+  fs.mkdirSync(path.dirname(absolutePath), { recursive: true });
+  atomicWriteSwarmFileSync(absolutePath, `${JSON.stringify(owner)}
+`);
+  appendLifecycleEntry(directory, owner, "OWNER_PUBLISHED");
+  return owner;
+}
+function removeWorktreeProvisioningOwner(directory, callID, expected) {
+  try {
+    const owner = readOwner(directory, callID);
+    if (owner?.schemaVersion === 3 && (!expected || expected.reservationId !== owner.reservationId || expected.generation !== owner.generation || expected.branchName !== owner.branchName)) {
+      return false;
+    }
+    fs.unlinkSync(ownerPath(directory, callID));
+    if (owner)
+      appendLifecycleEntry(directory, owner, "OWNER_REMOVED");
+    return true;
+  } catch (error) {
+    return error.code === "ENOENT";
+  }
+}
+function scanWorktreeProvisioningOwnersForRecovery(directory) {
+  let directoryPath;
+  let entries;
+  try {
+    directoryPath = ownerDirectory(directory);
+    entries = fs.readdirSync(directoryPath, { withFileTypes: true }).filter((entry) => entry.isFile() && entry.name.endsWith(".json"));
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return { status: "ok", owners: [] };
+    }
+    return {
+      status: "uncertain",
+      reason: `worktree provisioning-owner directory is unreadable: ${error instanceof Error ? error.message : String(error)}`
+    };
+  }
+  if (entries.length > MAX_PROVISIONING_OWNERS) {
+    return {
+      status: "uncertain",
+      reason: `worktree provisioning-owner count exceeds the ${MAX_PROVISIONING_OWNERS}-marker safety bound`
+    };
+  }
+  const owners = [];
+  for (const entry of entries) {
+    const absolutePath = path.join(directoryPath, entry.name);
+    try {
+      const stat = fs.statSync(absolutePath);
+      if (stat.size > MAX_PROVISIONING_OWNER_BYTES) {
+        return {
+          status: "uncertain",
+          reason: `worktree provisioning owner "${entry.name}" exceeds the recovery size bound`
+        };
+      }
+      const raw = fs.readFileSync(absolutePath, "utf8");
+      if (Buffer.byteLength(raw, "utf8") > MAX_PROVISIONING_OWNER_BYTES) {
+        return {
+          status: "uncertain",
+          reason: `worktree provisioning owner "${entry.name}" changed beyond the recovery size bound`
+        };
+      }
+      const parsed = JSON.parse(raw);
+      if (!isOwner(parsed)) {
+        return {
+          status: "uncertain",
+          reason: `worktree provisioning owner "${entry.name}" is invalid`
+        };
+      }
+      owners.push(parsed);
+    } catch (error) {
+      return {
+        status: "uncertain",
+        reason: `worktree provisioning owner "${entry.name}" is unreadable or malformed: ${error instanceof Error ? error.message : String(error)}`
+      };
+    }
+  }
+  return { status: "ok", owners };
+}
+
+export { WORKTREE_PROVISIONING_OWNER_LEASE_MS, WORKTREE_LIFECYCLE_LOCK_FILE, recordWorktreeProvisioningOwner, removeWorktreeProvisioningOwner, scanWorktreeProvisioningOwnersForRecovery };

package/dist/cli/{index-pvrap7xg.js → index-3ttktt56.js}

@@ -7,7 +7,7 @@ import {
   readLinkPointer,
   resolveKnowledgeStoreDir,
   resolveLinkDir
-} from "./index-79g6edht.js";
+} from "./index-x3y6zhgj.js";
 
 // src/knowledge/curation-policy.ts
 import { appendFile, mkdir as mkdir2, readFile as readFile2 } from "fs/promises";