taskchef 7.29.0 → 8.0.0

package/src/dashboard/react/App.tsx

@@ -109,6 +109,7 @@ export function DashboardApp({
     return () => window.removeEventListener('hashchange', update);
   }, []);
   const [tasks, setTasks] = useState<Task[]>(initialTasks);
+  const [projectIndex, setProjectIndex] = useState<DashboardSnapshot["projectIndex"]>();
   const [connected, setConnected] = useState(false);
   const [message, setMessage] = useState<string | null>(null);
   const [version, setVersion] = useState<string | null>(null);
@@ -138,6 +139,7 @@ export function DashboardApp({
 
   const applySnapshot = useCallback((snapshot: DashboardSnapshot) => {
     setTasks(snapshot.tasks);
+    setProjectIndex(snapshot.projectIndex);
     setNotificationState((current) => {
       const reconciled = reconcileNotifications(current, snapshot.tasks);
       return {
@@ -325,6 +327,20 @@ export function DashboardApp({
 
         <AppShell.Main>
           <Container className="taskchef-main" pb={80} size={1080}>
+            {projectIndex?.status === "unavailable" && (
+              <Alert color="yellow" icon={<IconAlertTriangle size={18} />} mb="md" title="Project index unavailable">
+                Task history is still visible. Verify the index and inspect backups before making project changes.
+              </Alert>
+            )}
+            {projectIndex?.status === "available" && projectIndex.missingProjects.length > 0 && (
+              <Alert color="yellow" icon={<IconAlertTriangle size={18} />} mb="md" title="Historical projects are missing from the current index">
+                {projectIndex.missingProjects.map((item) => (
+                  <Text key={item.path} size="sm">
+                    {item.snapshotNames.join(", ")}: {item.taskCount} task(s). Run <code>taskchef backup list --json</code> and preview any restore; the dashboard never restores automatically.
+                  </Text>
+                ))}
+              </Alert>
+            )}
             {settings ? <Stack gap="md"><Button component="a" href="#" variant="subtle" size="sm" leftSection={<IconArrowLeft size={16} />} style={{ alignSelf: 'flex-start' }}>Back to tasks</Button><ModelSettings /></Stack> : <>
             <Paper className="taskchef-toolbar" p="sm" radius="md" withBorder>
               <Stack gap="sm">

package/src/dashboard/react/types.ts

@@ -106,6 +106,16 @@ export interface NotificationSnapshot {
 export interface DashboardSnapshot {
   healthy?: boolean;
   tasks: Task[];
+  projectIndex?: {
+    status: "available" | "unavailable";
+    projectCount: number | null;
+    missingProjects: Array<{
+      path: string;
+      snapshotNames: string[];
+      taskCount: number;
+    }>;
+    truncated?: boolean;
+  };
 }
 
 export interface ManualTransitionResponse {

package/src/dashboard-manager.js

@@ -246,6 +246,7 @@ export function readDashboardIdentity({
   port = DEFAULT_PORT,
   maximumBytes = DASHBOARD_HEALTH_MAX_BYTES,
   timeoutMs = HEALTH_TIMEOUT_MS,
+  deadlineAt = Date.now() + timeoutMs,
 } = {}) {
   return new Promise((resolve, reject) => {
     let settled = false;
@@ -278,6 +279,21 @@ export function readDashboardIdentity({
         chunks.push(chunk);
       });
       response.on("end", () => {
+        if (response.statusCode === 503 && deadlineAt - Date.now() > 10) {
+          settled = true;
+          clearTimeout(deadline);
+          const remaining = deadlineAt - Date.now();
+          setTimeout(() => {
+            readDashboardIdentity({
+              host,
+              port,
+              maximumBytes,
+              timeoutMs: Math.max(1, remaining),
+              deadlineAt,
+            }).then(resolve, reject);
+          }, 10);
+          return;
+        }
         if (response.statusCode !== 200) {
           finish(new Error(`dashboard health returned HTTP ${response.statusCode}`));
           return;

package/src/dashboard.js

@@ -20,6 +20,7 @@ import {
   canonicalGitRoot,
   manuallyTransitionTask,
   parseTaskLogContent,
+  createWorkspaceBackup,
   readConfig,
   readTask,
 } from "./workspace.js";
@@ -463,7 +464,9 @@ export class DashboardMonitor extends EventEmitter {
       const snapshot = await readBoundedTaskLog(this.tasksFile, this.maxFileBytes);
       return {
         fingerprint: snapshot.fingerprint,
-        tasks: await parseTaskLogContent(this.workspace, snapshot.content),
+        tasks: await parseTaskLogContent(this.workspace, snapshot.content, {
+          validateWorkspace: false,
+        }),
       };
     });
     this.tasks = [];
@@ -472,6 +475,7 @@ export class DashboardMonitor extends EventEmitter {
     this.currentFingerprint = null;
     this.currentTaskFingerprint = null;
     this.unhealthy = false;
+    this.projectIndex = { status: "available", projectCount: 0, missingProjects: [] };
     this.observedUpdateTimes = new Map();
     this.refreshPromise = null;
     this.refreshQueued = false;
@@ -487,6 +491,7 @@ export class DashboardMonitor extends EventEmitter {
       revision: this.revision,
       generatedAt: new Date().toISOString(),
       healthy: !this.unhealthy,
+      projectIndex: this.projectIndex,
       tasks: this.tasks.map((task) => ({
         ...taskListProjection(task),
         meaningfulUpdatedAt: new Date(
@@ -513,7 +518,7 @@ export class DashboardMonitor extends EventEmitter {
     if (!this.started || this.watcher) return;
     try {
       this.watcher = this.watchDirectory(this.workspace, { persistent: false }, (_event, fileName) => {
-        if (fileName !== null && String(fileName) !== TASKS_FILE_NAME) return;
+        if (fileName !== null && !new Set([TASKS_FILE_NAME, "taskchef.json", "config-audit.jsonl"]).has(String(fileName))) return;
         clearTimeout(this.debounceTimer);
         this.debounceTimer = setTimeout(() => this.refresh({ force: true }), this.debounceMs);
         this.debounceTimer.unref?.();
@@ -579,8 +584,34 @@ export class DashboardMonitor extends EventEmitter {
         }
       }
       const tasks = sortTasksByMeaningfulUpdate(snapshot.tasks, this.observedUpdateTimes);
-      const nextTaskFingerprint = taskFingerprint(tasks);
+      let projectIndex;
+      try {
+        const config = await readConfig(this.workspace, { checkPaths: false });
+        const configured = new Set(config.projects.map((project) => project.path));
+        const missing = new Map();
+        for (const task of tasks) {
+          if (configured.has(task.project.path)) continue;
+          const item = missing.get(task.project.path) ?? {
+            path: task.project.path, snapshotNames: new Set(), taskCount: 0,
+          };
+          item.snapshotNames.add(task.project.name);
+          item.taskCount += 1;
+          missing.set(task.project.path, item);
+        }
+        projectIndex = {
+          status: "available",
+          projectCount: config.projects.length,
+          missingProjects: [...missing.values()].slice(0, 50).map((item) => ({
+            ...item, snapshotNames: [...item.snapshotNames].sort(),
+          })),
+          truncated: missing.size > 50,
+        };
+      } catch {
+        projectIndex = { status: "unavailable", projectCount: null, missingProjects: [] };
+      }
+      const nextTaskFingerprint = taskFingerprint({ tasks, projectIndex });
       this.currentFingerprint = after;
+      this.projectIndex = projectIndex;
       if (nextTaskFingerprint === this.currentTaskFingerprint) {
         if (this.unhealthy) {
           this.unhealthy = false;
@@ -833,11 +864,24 @@ export async function createDashboardServer({
         || typeof control?.onHandoff !== "function")))) {
     throw new Error("dashboard control requires a valid TaskChef ownership controller");
   }
+  let requestHandler = (_request, response) => {
+    sendJson(response, 503, { message: "TaskChef dashboard is initializing." });
+  };
+  const server = http.createServer((request, response) => requestHandler(request, response));
+  await new Promise((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(port, host, resolve);
+  });
+  const address = server.address();
+  const boundPort = typeof address === "object" && address ? address.port : port;
+  const allowedAuthority = dashboardAuthority(host, boundPort);
+  const allowedOrigin = `http://${allowedAuthority}`;
   const monitor = new DashboardMonitor(workspace, monitorOptions);
   let taskUsageTracker;
   let taskUsageSummaryMonitor;
   let identity;
   try {
+    await createWorkspaceBackup(workspace, { reason: `dashboard-${launcher}-startup` });
     await monitor.start();
     taskUsageTracker = usageTracker ?? createUsageTracker({ workspace: monitor.workspace });
     taskUsageSummaryMonitor = usageSummaryMonitor
@@ -858,6 +902,7 @@ export async function createDashboardServer({
     taskUsageSummaryMonitor?.close();
     taskUsageTracker?.close?.();
     monitor.close();
+    await new Promise((resolve) => server.close(() => resolve()));
     throw error;
   }
   const clients = new Set();
@@ -865,8 +910,6 @@ export async function createDashboardServer({
   let usageProviderPromise = null;
   let controlHandoff = null;
   let controlHandoffTimer = null;
-  let allowedAuthority;
-  let allowedOrigin;
 
   const broadcast = (event, value) => {
     const payload = ssePayload(event, value);
@@ -1479,28 +1522,12 @@ export async function createDashboardServer({
     response.end(method === "HEAD" ? undefined : body);
   };
 
-  const server = http.createServer((request, response) => {
+  requestHandler = (request, response) => {
     handleRequest(request, response).catch(() => {
       if (response.headersSent) response.destroy();
       else sendJson(response, 500, { message: "Dashboard request failed." });
     });
-  });
-
-  await new Promise((resolve, reject) => {
-    server.once("error", reject);
-    server.listen(port, host, resolve);
-  }).catch((error) => {
-    clearInterval(usagePreloadTimer);
-    monitor.close();
-    taskUsageSummaryMonitor.close();
-    taskUsageTracker.close?.();
-    throw error;
-  });
-
-  const address = server.address();
-  const boundPort = typeof address === "object" && address ? address.port : port;
-  allowedAuthority = dashboardAuthority(host, boundPort);
-  allowedOrigin = `http://${allowedAuthority}`;
+  };
   return {
     host,
     port: boundPort,

package/src/state-store.js

@@ -0,0 +1,81 @@
+import { createHash, randomUUID } from "node:crypto";
+import { link, mkdir, open, rename, unlink } from "node:fs/promises";
+import path from "node:path";
+
+function canonicalize(value) {
+  if (Array.isArray(value)) return value.map(canonicalize);
+  if (value && typeof value === "object") {
+    return Object.fromEntries(Object.keys(value).sort().map((key) => [key, canonicalize(value[key])]));
+  }
+  return value;
+}
+
+export function canonicalJson(value) {
+  return JSON.stringify(canonicalize(value));
+}
+
+export function sha256(value) {
+  return createHash("sha256").update(value).digest("hex");
+}
+
+export function semanticHash(value, domain = "taskchef") {
+  return sha256(`${domain}\n${canonicalJson(value)}\n`);
+}
+
+export function taskChefError(code, message, details = {}) {
+  return Object.assign(new Error(message), { code, details });
+}
+
+export async function writeDurableAtomic(filePath, content, {
+  mode = 0o600,
+  exclusive = false,
+} = {}) {
+  await mkdir(path.dirname(filePath), { recursive: true, mode: 0o700 });
+  const temporaryPath = `${filePath}.${process.pid}.${randomUUID()}.tmp`;
+  const handle = await open(temporaryPath, "wx", mode);
+  try {
+    await handle.writeFile(content, "utf8");
+    await handle.sync();
+  } finally {
+    await handle.close();
+  }
+  let replacementCommitted = false;
+  try {
+    if (exclusive) {
+      await link(temporaryPath, filePath);
+      replacementCommitted = true;
+      await unlink(temporaryPath);
+    } else {
+      await rename(temporaryPath, filePath);
+      replacementCommitted = true;
+    }
+    const directory = await open(path.dirname(filePath), "r");
+    try {
+      await directory.sync();
+    } finally {
+      await directory.close();
+    }
+  } catch (error) {
+    await unlink(temporaryPath).catch(() => {});
+    if (replacementCommitted) error.replacementCommitted = true;
+    throw error;
+  }
+}
+
+export async function removeDurable(filePath) {
+  let removed = false;
+  try {
+    await unlink(filePath);
+    removed = true;
+  } catch (error) {
+    if (error.code !== "ENOENT") throw error;
+  }
+  if (!removed) return false;
+  const directory = await open(path.dirname(filePath), "r");
+  try {
+    await directory.sync();
+  } finally {
+    await directory.close();
+  }
+  return true;
+}