taskchef 8.7.0 → 9.0.0

package/src/config-audit.js

@@ -1,99 +0,0 @@
-import { open, readFile, readdir, rename, stat, unlink } from "node:fs/promises";
-import path from "node:path";
-import { taskChefError } from "./state-store.js";
-
-export async function appendAuditUnlocked(workspace, record) {
-  const filePath = path.join(workspace, "config-audit.jsonl");
-  const size = await stat(filePath).then((details) => details.size).catch((error) => {
-    if (error.code === "ENOENT") return 0;
-    throw error;
-  });
-  if (size >= 10 * 1024 * 1024) {
-    const timestamp = new Date().toISOString().replaceAll(":", "-").replaceAll(".", "-");
-    await rename(filePath, path.join(workspace, `config-audit.${timestamp}.jsonl`));
-    const archives = (await readdir(workspace))
-      .filter((name) => /^config-audit\..+\.jsonl$/.test(name))
-      .sort()
-      .reverse();
-    for (const name of archives.slice(10)) await unlink(path.join(workspace, name));
-  }
-  const handle = await open(filePath, "a", 0o600);
-  try {
-    await handle.writeFile(`${JSON.stringify({ schemaVersion: 1, ...record })}\n`);
-    await handle.sync();
-  } finally {
-    await handle.close();
-  }
-}
-
-async function readLatestAuditRecordsUnlocked(workspace) {
-  const filePath = path.join(workspace, "config-audit.jsonl");
-  const content = await readFile(filePath, "utf8").catch((error) => {
-    if (error.code === "ENOENT") return "";
-    throw error;
-  });
-  const latest = new Map();
-  for (const [index, line] of content.trimEnd().split("\n").entries()) {
-    if (line.length === 0) continue;
-    let record;
-    try {
-      record = JSON.parse(line);
-    } catch {
-      throw taskChefError(
-        "STATE_RECOVERY_REQUIRED",
-        `configuration audit is malformed at line ${index + 1}`,
-      );
-    }
-    if (record.transactionId) latest.set(record.transactionId, record);
-  }
-  return latest;
-}
-
-export async function validateAuditUnlocked(workspace) {
-  await readLatestAuditRecordsUnlocked(workspace);
-}
-
-export async function reconcileAuditUnlocked(workspace, currentHash) {
-  const latest = await readLatestAuditRecordsUnlocked(workspace);
-  for (const record of latest.values()) {
-    if (record.phase !== "prepared" && record.phase !== "recovery-required") continue;
-    if (currentHash === record.beforeHash) {
-      await appendAuditUnlocked(workspace, {
-        ...record,
-        timestamp: new Date().toISOString(),
-        phase: "aborted",
-        reconciliation: "matched-before",
-      });
-    } else if (currentHash === record.afterHash) {
-      await appendAuditUnlocked(workspace, {
-        ...record,
-        timestamp: new Date().toISOString(),
-        phase: "committed",
-        reconciliation: "matched-after",
-      });
-    } else {
-      throw taskChefError(
-        "STATE_RECOVERY_REQUIRED",
-        `configuration does not match either side of transaction ${record.transactionId}`,
-        { transactionId: record.transactionId },
-      );
-    }
-  }
-}
-
-export async function supersedeAuditTransactionsUnlocked(workspace, recoveryTransactionId) {
-  const latest = await readLatestAuditRecordsUnlocked(workspace);
-  const superseded = [];
-  for (const record of latest.values()) {
-    if (record.transactionId === recoveryTransactionId
-        || !new Set(["prepared", "recovery-required"]).has(record.phase)) continue;
-    await appendAuditUnlocked(workspace, {
-      ...record,
-      timestamp: new Date().toISOString(),
-      phase: "superseded",
-      supersededBy: recoveryTransactionId,
-    });
-    superseded.push(record.transactionId);
-  }
-  return superseded;
-}

package/src/config-mutations.js

@@ -1,106 +0,0 @@
-import { semanticHash, taskChefError } from "./state-store.js";
-
-function fieldsChanged(before, after) {
-  const fields = {};
-  for (const key of ["name", "description", "isGitRepository", "githubRepos"]) {
-    if (JSON.stringify(before[key]) !== JSON.stringify(after[key])) {
-      fields[key] = { before: before[key] ?? null, after: after[key] ?? null };
-    }
-  }
-  return fields;
-}
-
-export function projectSetHash(projects) {
-  return semanticHash({ schemaVersion: 1, projects }, "taskchef-project-set-v1");
-}
-
-export function configHash(config) {
-  return semanticHash(config, "taskchef-config-v1");
-}
-
-export function projectDiff(beforeProjects, afterProjects) {
-  const before = new Map(beforeProjects.map((project) => [project.path, project]));
-  const after = new Map(afterProjects.map((project) => [project.path, project]));
-  const added = [];
-  const changed = [];
-  const removed = [];
-  for (const project of afterProjects) {
-    const prior = before.get(project.path);
-    if (!prior) added.push(project);
-    else {
-      const fields = fieldsChanged(prior, project);
-      if (Object.keys(fields).length) changed.push({ path: project.path, before: prior, after: project, fields });
-    }
-  }
-  for (const project of beforeProjects) {
-    if (!after.has(project.path)) removed.push(project);
-  }
-  return { added, changed, removed };
-}
-
-export function mutationPreview(workspace, operation, beforeConfig, afterConfig) {
-  const diff = projectDiff(beforeConfig.projects, afterConfig.projects);
-  const emptyIndex = { bindings: [], exclusions: [], routingHints: [] };
-  const beforeProjectIndex = beforeConfig.projectIndex ?? emptyIndex;
-  const afterProjectIndex = afterConfig.projectIndex ?? emptyIndex;
-  const projectIndexDiff = JSON.stringify(beforeProjectIndex) === JSON.stringify(afterProjectIndex)
-    ? null
-    : { before: beforeProjectIndex, after: afterProjectIndex };
-  const preview = {
-    schemaVersion: 1,
-    operation,
-    beforeConfigHash: configHash(beforeConfig),
-    afterConfigHash: configHash(afterConfig),
-    beforeProjectSetHash: projectSetHash(beforeConfig.projects),
-    afterProjectSetHash: projectSetHash(afterConfig.projects),
-    beforeCount: beforeConfig.projects.length,
-    afterCount: afterConfig.projects.length,
-    diff,
-    projectIndexDiff,
-    projects: afterConfig.projects,
-  };
-  return {
-    ...preview,
-    planHash: semanticHash({
-      schemaVersion: 1,
-      workspace,
-      operation,
-      beforeConfigHash: preview.beforeConfigHash,
-      afterConfigHash: preview.afterConfigHash,
-      diff,
-      projectIndexDiff,
-    }, "taskchef-mutation-plan-v1"),
-  };
-}
-
-function exactStringSet(actual, expected) {
-  if (!Array.isArray(actual) || new Set(actual).size !== actual.length) return false;
-  return actual.length === expected.length
-    && [...actual].sort().every((value, index) => value === [...expected].sort()[index]);
-}
-
-export function assertMutationAuthorization(preview, authorization = {}, {
-  destructive = preview.diff.removed.length > 0,
-  replacement = false,
-} = {}) {
-  if (authorization.expectConfigHash !== preview.beforeConfigHash) {
-    throw taskChefError("STALE_PREVIEW", "configuration changed or --expect-config-hash is missing", preview);
-  }
-  if (!destructive && !replacement) return;
-  const removedNames = preview.diff.removed.map((project) => project.name);
-  if (authorization.expectProjectCount !== preview.beforeCount
-    || authorization.expectAfterCount !== preview.afterCount
-    || authorization.confirmPlan !== preview.planHash
-    || !exactStringSet(authorization.confirmRemoved, removedNames)) {
-    throw taskChefError(
-      "CONFIRMATION_REQUIRED",
-      "destructive project mutation requires exact preview-bound count, hash, plan, and removed-name confirmation",
-      preview,
-    );
-  }
-  const collapses = preview.beforeCount > 0
-    && (preview.afterCount === 0 || preview.afterCount / preview.beforeCount <= 0.5);
-  if (collapses && authorization.confirmCountCollapse !== `${preview.beforeCount}:${preview.afterCount}`) {
-    throw taskChefError("CONFIRMATION_REQUIRED", "project-count collapse requires exact before:after confirmation", preview);
-  }
-}

package/src/dashboard/actions.js

@@ -1,136 +0,0 @@
-export async function openTaskFromControl(event, taskId, {
-  fetchAction = globalThis.fetch,
-  showMessage,
-} = {}) {
-  event.stopPropagation();
-  const control = event.currentTarget;
-  control.disabled = true;
-  try {
-    const response = await fetchAction(`/api/tasks/${encodeURIComponent(taskId)}/open-codex`, {
-      method: "POST",
-    });
-    const result = await response.json();
-    if (result.message) showMessage(result.message);
-  } finally {
-    control.disabled = false;
-  }
-}
-
-export async function archiveTaskFromControl(event, task, {
-  confirmAction = globalThis.confirm,
-  fetchAction = globalThis.fetch,
-  onArchived = () => {},
-  showUpdate,
-} = {}) {
-  event.stopPropagation();
-  const accepted = confirmAction(
-    `Archive “${task.title}” in Codex?\n\n`
-    + "The chat will leave active Codex lists, and spawned descendant chats may also be archived. "
-    + "TaskChef history will remain available.",
-  );
-  if (!accepted) return false;
-  const control = event.currentTarget;
-  let archived = false;
-  control.disabled = true;
-  try {
-    const response = await fetchAction(
-      `/api/tasks/${encodeURIComponent(task.id)}/archive-codex`,
-      { method: "POST" },
-    );
-    const result = await response.json();
-    if (!response.ok) {
-      showUpdate(result.message ?? "Codex could not archive this chat.", { failed: true });
-      return false;
-    }
-    onArchived(task.threadId);
-    archived = true;
-    showUpdate(result.message ?? "Archived the Codex chat. TaskChef history remains available.");
-    return true;
-  } catch {
-    showUpdate("Codex chat archiving is temporarily unavailable. Try again.", { failed: true });
-    return false;
-  } finally {
-    if (!archived) control.disabled = false;
-  }
-}
-
-export async function manuallyTransitionTaskFromControl(event, task, targetStatus, actionId, {
-  clearTimer = globalThis.clearTimeout,
-  fetchAction = globalThis.fetch,
-  setTimer = globalThis.setTimeout,
-  timeoutMs = 10_000,
-} = {}) {
-  event?.stopPropagation?.();
-  const controller = new AbortController();
-  const timeout = setTimer(() => controller.abort(), timeoutMs);
-  try {
-    const response = await fetchAction(
-      `/api/tasks/${encodeURIComponent(task.id)}/manual-transition`,
-      {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({
-          schemaVersion: 1,
-          actionId,
-          expected: {
-            status: task.status,
-            turnRef: task.turnRef,
-            threadId: task.threadId,
-            updatedAt: task.updatedAt,
-          },
-          targetStatus,
-        }),
-          signal: controller.signal,
-        },
-    );
-    const result = await response.json();
-    return response.ok
-      ? { ok: true, ...result }
-      : {
-        ok: false,
-        code: result.code ?? "dashboard_error",
-        message: result.message ?? "Task state could not be changed.",
-        task: result.task ?? null,
-      };
-  } catch {
-    return {
-      ok: false,
-      code: controller.signal.aborted ? "request_timeout" : "network_error",
-      message: controller.signal.aborted
-        ? "Task state change timed out. Try again."
-        : "Task state changes are temporarily unavailable. Try again.",
-      task: null,
-    };
-  } finally {
-    clearTimer(timeout);
-  }
-}
-
-export function handleManualTransitionEscape(event, {
-  active,
-  pending,
-  cancel,
-}) {
-  if (event.key !== "Escape" || !active) return false;
-  event.preventDefault();
-  event.stopPropagation();
-  if (!pending) cancel();
-  return true;
-}
-
-export function focusManualTransitionStatus(panel) {
-  const status = panel.querySelector('[data-manual-focus="pending"]');
-  status?.focus();
-  return status !== null;
-}
-
-export function restoreTaskActionMenuFocus(panel, activeElement, fallback) {
-  if (!activeElement || !panel.contains(activeElement)) return null;
-  if (!activeElement.hidden && !activeElement.disabled) return activeElement;
-  const copyTaskId = panel.querySelector('[data-manual-focus="copy"]');
-  const destination = copyTaskId && !copyTaskId.hidden && !copyTaskId.disabled
-    ? copyTaskId
-    : fallback;
-  destination?.focus();
-  return destination ?? null;
-}