u-foo 2.5.14 → 3.0.0

package/src/code/runtime/taskRun.js

@@ -0,0 +1,187 @@
+"use strict";
+
+const { randomUUID } = require("crypto");
+
+/**
+ * TaskRun registry — parent Task node identity vs runnable attempt.
+ */
+
+const TASK_RUN_STATUSES = Object.freeze([
+  "queued",
+  "running",
+  "cancelling",
+  "succeeded",
+  "failed",
+  "cancelled",
+]);
+
+const TASK_RUN_PHASES = Object.freeze([
+  "initializing",
+  "planning",
+  "waiting_model",
+  "executing_tools",
+  "finalizing",
+]);
+
+const TERMINAL_TASK_RUN = new Set(["succeeded", "failed", "cancelled"]);
+
+function createTaskRunId() {
+  return `trun_${Date.now().toString(36)}_${randomUUID().slice(0, 6)}`;
+}
+
+function emptyTaskRunStore() {
+  return {
+    byId: {},
+    commandLog: {},
+  };
+}
+
+function ensureTaskRunStore(executionState = null) {
+  const state = executionState && typeof executionState === "object" ? executionState : {};
+  if (!state.taskRuns || typeof state.taskRuns !== "object") {
+    state.taskRuns = emptyTaskRunStore();
+  }
+  if (!state.taskRuns.byId || typeof state.taskRuns.byId !== "object") {
+    state.taskRuns.byId = {};
+  }
+  if (!state.taskRuns.commandLog || typeof state.taskRuns.commandLog !== "object") {
+    state.taskRuns.commandLog = {};
+  }
+  return state.taskRuns;
+}
+
+function createTaskRun({
+  parentGraphId = "",
+  parentNodeId = "",
+  childGraphId = "",
+  attempt = 1,
+} = {}) {
+  const now = new Date().toISOString();
+  return {
+    id: createTaskRunId(),
+    parentGraphId: String(parentGraphId || "").trim(),
+    parentNodeId: String(parentNodeId || "").trim(),
+    childGraphId: String(childGraphId || "").trim(),
+    status: "queued",
+    phase: "initializing",
+    attempt: Number.isFinite(attempt) ? Math.max(1, Math.floor(attempt)) : 1,
+    ignoreUserPrompts: true,
+    cancelRequested: false,
+    result: null,
+    error: null,
+    changedFiles: [],
+    createdAt: now,
+    startedAt: "",
+    completedAt: "",
+  };
+}
+
+function getTaskRun(executionState = null, taskRunId = "") {
+  const store = ensureTaskRunStore(executionState);
+  const id = String(taskRunId || "").trim();
+  return id && store.byId[id] ? store.byId[id] : null;
+}
+
+function putTaskRun(executionState = null, taskRun = null) {
+  if (!taskRun || !taskRun.id) return null;
+  const store = ensureTaskRunStore(executionState);
+  store.byId[taskRun.id] = taskRun;
+  return taskRun;
+}
+
+function findActiveTaskRunForNode(executionState = null, parentNodeId = "") {
+  const store = ensureTaskRunStore(executionState);
+  const nodeId = String(parentNodeId || "").trim();
+  for (const run of Object.values(store.byId)) {
+    if (!run || run.parentNodeId !== nodeId) continue;
+    if (run.status === "queued" || run.status === "running" || run.status === "cancelling") {
+      return run;
+    }
+  }
+  return null;
+}
+
+function listActiveWritingTaskRuns(executionState = null) {
+  const store = ensureTaskRunStore(executionState);
+  return Object.values(store.byId).filter((run) => (
+    run
+    && (run.status === "queued" || run.status === "running" || run.status === "cancelling")
+  ));
+}
+
+function isTerminalTaskRun(run = null) {
+  return Boolean(run && TERMINAL_TASK_RUN.has(String(run.status || "")));
+}
+
+/**
+ * Compare-and-set status transition. Returns { ok, run }.
+ */
+function casTaskRunStatus(executionState = null, taskRunId = "", {
+  expectedStatus = "",
+  nextStatus = "",
+  phase = "",
+  result = null,
+  error = null,
+  changedFiles = null,
+} = {}) {
+  const run = getTaskRun(executionState, taskRunId);
+  if (!run) return { ok: false, code: "TASK_RUN_NOT_FOUND", run: null };
+  const expected = String(expectedStatus || "").trim();
+  if (expected && run.status !== expected) {
+    return {
+      ok: false,
+      code: "TASK_STATUS_CAS_FAILED",
+      run,
+      currentStatus: run.status,
+    };
+  }
+  const next = String(nextStatus || "").trim();
+  if (!TASK_RUN_STATUSES.includes(next)) {
+    return { ok: false, code: "INVALID_TASK_STATUS", run };
+  }
+  run.status = next;
+  if (phase && TASK_RUN_PHASES.includes(phase)) run.phase = phase;
+  if (result !== null) run.result = result;
+  if (error !== null) run.error = error;
+  if (Array.isArray(changedFiles)) run.changedFiles = changedFiles.map(String);
+  if (next === "running" && !run.startedAt) run.startedAt = new Date().toISOString();
+  if (TERMINAL_TASK_RUN.has(next)) {
+    run.completedAt = new Date().toISOString();
+    run.phase = "finalizing";
+  }
+  if (next === "cancelling") run.cancelRequested = true;
+  putTaskRun(executionState, run);
+  return { ok: true, run };
+}
+
+function cacheControlCommand(executionState = null, commandId = "", payload = {}) {
+  const id = String(commandId || "").trim();
+  if (!id) return;
+  const store = ensureTaskRunStore(executionState);
+  store.commandLog[id] = JSON.parse(JSON.stringify(payload));
+}
+
+function getCachedControlCommand(executionState = null, commandId = "") {
+  const id = String(commandId || "").trim();
+  if (!id) return null;
+  const store = ensureTaskRunStore(executionState);
+  return store.commandLog[id] ? JSON.parse(JSON.stringify(store.commandLog[id])) : null;
+}
+
+module.exports = {
+  TASK_RUN_STATUSES,
+  TASK_RUN_PHASES,
+  TERMINAL_TASK_RUN,
+  createTaskRunId,
+  emptyTaskRunStore,
+  ensureTaskRunStore,
+  createTaskRun,
+  getTaskRun,
+  putTaskRun,
+  findActiveTaskRunForNode,
+  listActiveWritingTaskRuns,
+  isTerminalTaskRun,
+  casTaskRunStatus,
+  cacheControlCommand,
+  getCachedControlCommand,
+};

package/src/code/runtime/toolProvenance.js

@@ -0,0 +1,70 @@
+"use strict";
+
+/**
+ * Per-TaskRun tool provenance for changedFiles (not git diff attribution).
+ */
+
+function ensureProvenanceStore(executionState = null) {
+  const state = executionState && typeof executionState === "object" ? executionState : {};
+  if (!state.toolProvenance || typeof state.toolProvenance !== "object") {
+    state.toolProvenance = { byTaskRunId: {} };
+  }
+  if (!state.toolProvenance.byTaskRunId || typeof state.toolProvenance.byTaskRunId !== "object") {
+    state.toolProvenance.byTaskRunId = {};
+  }
+  return state.toolProvenance;
+}
+
+function touchedPathsFromTool(tool = "", args = {}) {
+  const name = String(tool || "").trim().toLowerCase();
+  const paths = [];
+  if (name === "write" || name === "edit") {
+    const path = String(args && args.path || "").trim();
+    if (path) paths.push(path);
+  }
+  return paths;
+}
+
+function recordToolProvenance(executionState = null, {
+  taskRunId = "",
+  tool = "",
+  args = {},
+  graphId = "",
+  nodeId = "",
+} = {}) {
+  const id = String(taskRunId || "").trim();
+  if (!id) return [];
+  const store = ensureProvenanceStore(executionState);
+  if (!store.byTaskRunId[id]) {
+    store.byTaskRunId[id] = { paths: [], events: [] };
+  }
+  const bucket = store.byTaskRunId[id];
+  const paths = touchedPathsFromTool(tool, args);
+  for (const path of paths) {
+    if (!bucket.paths.includes(path)) bucket.paths.push(path);
+  }
+  bucket.events.push({
+    at: new Date().toISOString(),
+    tool: String(tool || ""),
+    graphId: String(graphId || ""),
+    nodeId: String(nodeId || ""),
+    paths,
+  });
+  // Cap event log
+  if (bucket.events.length > 200) bucket.events = bucket.events.slice(-200);
+  return paths;
+}
+
+function getProvenanceChangedFiles(executionState = null, taskRunId = "") {
+  const store = ensureProvenanceStore(executionState);
+  const id = String(taskRunId || "").trim();
+  const bucket = store.byTaskRunId[id];
+  return bucket && Array.isArray(bucket.paths) ? bucket.paths.slice() : [];
+}
+
+module.exports = {
+  ensureProvenanceStore,
+  touchedPathsFromTool,
+  recordToolProvenance,
+  getProvenanceChangedFiles,
+};

package/src/code/runtime/workspaceLease.js

@@ -0,0 +1,208 @@
+"use strict";
+
+/**
+ * Workspace write lease — up to MAX_CONCURRENT_WRITE_LEASES writing TaskRuns.
+ * Agent write/edit/side-effect bash rejected while any Task holds a write lease.
+ */
+
+const WRITE_TOOLS = new Set(["write", "edit", "bash"]);
+const MAX_CONCURRENT_WRITE_LEASES = 6;
+
+function emptyWorkspaceLease() {
+  return {
+    holders: [], // [{ kind: "task_run", taskRunId, acquiredAt }]
+    mode: "write",
+    // Legacy single-holder field; migrated in ensureWorkspaceLease.
+    holder: null,
+    acquiredAt: "",
+  };
+}
+
+function ensureWorkspaceLease(executionState = null) {
+  const state = executionState && typeof executionState === "object" ? executionState : {};
+  if (!state.workspaceLease || typeof state.workspaceLease !== "object") {
+    state.workspaceLease = emptyWorkspaceLease();
+  }
+  normalizeHolders(state.workspaceLease);
+  return state.workspaceLease;
+}
+
+function normalizeHolders(lease = null) {
+  const next = lease && typeof lease === "object" ? lease : emptyWorkspaceLease();
+  if (!Array.isArray(next.holders)) next.holders = [];
+
+  // Migrate V1 single-holder shape.
+  if (next.holder && typeof next.holder === "object" && next.holder.taskRunId) {
+    const id = String(next.holder.taskRunId || "").trim();
+    if (id && !next.holders.some((h) => h && h.taskRunId === id)) {
+      next.holders.push({
+        kind: "task_run",
+        taskRunId: id,
+        acquiredAt: String(next.acquiredAt || new Date().toISOString()),
+      });
+    }
+    next.holder = null;
+  }
+
+  next.holders = next.holders
+    .filter((h) => h && h.kind === "task_run" && String(h.taskRunId || "").trim())
+    .map((h) => ({
+      kind: "task_run",
+      taskRunId: String(h.taskRunId).trim(),
+      acquiredAt: String(h.acquiredAt || ""),
+    }));
+
+  // Cap defensive (should not happen if acquire gates correctly).
+  if (next.holders.length > MAX_CONCURRENT_WRITE_LEASES) {
+    next.holders = next.holders.slice(0, MAX_CONCURRENT_WRITE_LEASES);
+  }
+  return next.holders;
+}
+
+function listWriteLeaseHolders(executionState = null) {
+  return normalizeHolders(ensureWorkspaceLease(executionState)).slice();
+}
+
+function countWriteLeases(executionState = null) {
+  return listWriteLeaseHolders(executionState).length;
+}
+
+function findWriteLeaseHolder(executionState = null, taskRunId = "") {
+  const id = String(taskRunId || "").trim();
+  if (!id) return null;
+  return listWriteLeaseHolders(executionState).find((h) => h.taskRunId === id) || null;
+}
+
+function canAcquireWriteLease(executionState = null, taskRunId = "") {
+  const id = String(taskRunId || "").trim();
+  if (!id) return { ok: false, code: "MISSING_TASK_RUN_ID" };
+  if (findWriteLeaseHolder(executionState, id)) {
+    return { ok: true, idempotent: true };
+  }
+  const count = countWriteLeases(executionState);
+  if (count >= MAX_CONCURRENT_WRITE_LEASES) {
+    return {
+      ok: false,
+      code: "MAX_CONCURRENT_TASKS",
+      max: MAX_CONCURRENT_WRITE_LEASES,
+      current: count,
+      holders: listWriteLeaseHolders(executionState),
+    };
+  }
+  return { ok: true, current: count, max: MAX_CONCURRENT_WRITE_LEASES };
+}
+
+function acquireTaskWriteLease(executionState = null, taskRunId = "") {
+  const lease = ensureWorkspaceLease(executionState);
+  const holders = normalizeHolders(lease);
+  const id = String(taskRunId || "").trim();
+  if (!id) {
+    return { ok: false, code: "MISSING_TASK_RUN_ID" };
+  }
+
+  const existing = holders.find((h) => h.taskRunId === id);
+  if (existing) {
+    return { ok: true, lease, holder: existing, idempotent: true };
+  }
+
+  if (holders.length >= MAX_CONCURRENT_WRITE_LEASES) {
+    return {
+      ok: false,
+      code: "MAX_CONCURRENT_TASKS",
+      max: MAX_CONCURRENT_WRITE_LEASES,
+      current: holders.length,
+      holders: holders.slice(),
+      message: `At most ${MAX_CONCURRENT_WRITE_LEASES} concurrent writing TaskRuns`,
+    };
+  }
+
+  const holder = {
+    kind: "task_run",
+    taskRunId: id,
+    acquiredAt: new Date().toISOString(),
+  };
+  holders.push(holder);
+  lease.holders = holders;
+  lease.mode = "write";
+  return { ok: true, lease, holder };
+}
+
+function releaseTaskWriteLease(executionState = null, taskRunId = "") {
+  const lease = ensureWorkspaceLease(executionState);
+  const holders = normalizeHolders(lease);
+  const id = String(taskRunId || "").trim();
+  if (!id) return { ok: true, lease };
+  lease.holders = holders.filter((h) => h.taskRunId !== id);
+  if (lease.holders.length === 0) {
+    lease.acquiredAt = "";
+  }
+  return { ok: true, lease };
+}
+
+function clearWorkspaceLease(executionState = null) {
+  const lease = ensureWorkspaceLease(executionState);
+  lease.holders = [];
+  lease.holder = null;
+  lease.acquiredAt = "";
+  return lease;
+}
+
+/**
+ * @param {string} tool
+ * @param {"agent_loop"|"task_loop"} originKind
+ * @param {string} [taskRunId]
+ */
+function checkWriteAllowed(executionState = null, {
+  tool = "",
+  originKind = "agent_loop",
+  taskRunId = "",
+} = {}) {
+  const name = String(tool || "").trim().toLowerCase();
+  if (!WRITE_TOOLS.has(name)) return { ok: true };
+
+  const holders = listWriteLeaseHolders(executionState);
+  if (holders.length === 0) return { ok: true };
+
+  if (originKind === "task_loop") {
+    const id = String(taskRunId || "").trim();
+    if (holders.some((h) => h.taskRunId === id)) {
+      return { ok: true };
+    }
+    return {
+      ok: false,
+      code: "WORKSPACE_WRITE_LEASE_HELD",
+      holders,
+      message: "This TaskRun does not hold a workspace write lease.",
+    };
+  }
+
+  // Agent loop cannot write while any task holds a lease.
+  return {
+    ok: false,
+    code: "WORKSPACE_WRITE_LEASE_HELD",
+    holders,
+    owner: holders[0] || null,
+    message: `${holders.length} active TaskRun(s) hold workspace write lease(s); cancel or wait before writing.`,
+  };
+}
+
+function hasActiveWriteLease(executionState = null) {
+  return countWriteLeases(executionState) > 0;
+}
+
+module.exports = {
+  WRITE_TOOLS,
+  MAX_CONCURRENT_WRITE_LEASES,
+  emptyWorkspaceLease,
+  ensureWorkspaceLease,
+  normalizeHolders,
+  listWriteLeaseHolders,
+  countWriteLeases,
+  findWriteLeaseHolder,
+  canAcquireWriteLease,
+  acquireTaskWriteLease,
+  releaseTaskWriteLease,
+  clearWorkspaceLease,
+  checkWriteAllowed,
+  hasActiveWriteLease,
+};