pi-webdesk 0.1.0

package/dist/apps/daemon/src/task-validation.js

@@ -0,0 +1,352 @@
+// apps/daemon/src/task-validation.ts
+import { realpath } from "node:fs/promises";
+import {
+  captureWorktreeState,
+  isGitServiceError,
+  isValidationRunnerError,
+  startValidationRun
+} from "../../../packages/git/src/index.js";
+import { sanitizeApprovalDisplayText } from "../../../packages/pi-bridge/src/index.js";
+import {
+  PROTOCOL_VERSION,
+  TASK_VALIDATION_MAX_OUTPUT_CHARS,
+  taskValidationSchema
+} from "../../../packages/protocol/src/index.js";
+var TaskValidationOperationError = class extends Error {
+  name = "TaskValidationOperationError";
+  code;
+  status;
+  constructor(code, message, status, options) {
+    super(message, options);
+    this.code = code;
+    this.status = status;
+  }
+};
+var WORKTREE_UNAVAILABLE_CODES = /* @__PURE__ */ new Set([
+  "GIT_PATH_NOT_FOUND",
+  "GIT_PATH_NOT_DIRECTORY",
+  "GIT_NOT_A_REPOSITORY",
+  "GIT_BARE_REPOSITORY",
+  "GIT_NOT_A_WORK_TREE",
+  "GIT_HEAD_UNRESOLVED"
+]);
+var WORKTREE_UNAVAILABLE_MESSAGE = "The task worktree is missing or is no longer a healthy Git worktree. Recover it before running validation.";
+var WORKTREE_MISMATCH_MESSAGE = "The recorded worktree no longer matches the task's repository. Recover it before running validation.";
+function createTaskValidationService(options) {
+  const capture = options.captureWorktreeState ?? captureWorktreeState;
+  const startRun = options.startValidationRun ?? startValidationRun;
+  const now = options.now ?? Date.now;
+  const activeRuns = /* @__PURE__ */ new Map();
+  let disposing = false;
+  async function resolveTask(taskId) {
+    let task;
+    try {
+      task = await options.getTask(taskId);
+    } catch (error) {
+      throw new TaskValidationOperationError(
+        "validation-failed",
+        "The task could not be resolved from the local workspace.",
+        503,
+        { cause: error }
+      );
+    }
+    if (task === null) {
+      throw new TaskValidationOperationError(
+        "task-not-found",
+        "The selected task no longer exists.",
+        404
+      );
+    }
+    if (task.status !== "ready") {
+      throw new TaskValidationOperationError(
+        "task-not-ready",
+        `Only a ready task can be validated; this task is ${task.status}.`,
+        409
+      );
+    }
+    return task;
+  }
+  async function resolveRepository(task) {
+    let repository;
+    try {
+      repository = await options.getRepository(task.repositoryId);
+    } catch (error) {
+      throw new TaskValidationOperationError(
+        "validation-failed",
+        "The task's repository could not be resolved from the local workspace.",
+        503,
+        { cause: error }
+      );
+    }
+    if (repository === null) {
+      throw new TaskValidationOperationError(
+        "task-not-ready",
+        "The task's repository is no longer registered.",
+        409
+      );
+    }
+    return repository;
+  }
+  async function captureVerifiedState(task, repository) {
+    let canonicalWorktree;
+    try {
+      canonicalWorktree = await realpath(task.worktreePath);
+    } catch (error) {
+      throw new TaskValidationOperationError("task-not-ready", WORKTREE_UNAVAILABLE_MESSAGE, 409, {
+        cause: error
+      });
+    }
+    let state;
+    try {
+      state = await capture({ worktreePath: canonicalWorktree });
+    } catch (error) {
+      if (isGitServiceError(error) && WORKTREE_UNAVAILABLE_CODES.has(error.code)) {
+        throw new TaskValidationOperationError(
+          "task-not-ready",
+          WORKTREE_UNAVAILABLE_MESSAGE,
+          409,
+          { cause: error }
+        );
+      }
+      if (isGitServiceError(error, "GIT_STATE_TOO_LARGE") || isGitServiceError(error, "GIT_STATE_UNFINGERPRINTABLE")) {
+        throw new TaskValidationOperationError(
+          "validation-failed",
+          "The worktree has changed content that is too large or cannot be fingerprinted safely yet.",
+          422,
+          { cause: error }
+        );
+      }
+      if (isGitServiceError(error, "GIT_REPOSITORY_CHANGED_DURING_CAPTURE") || isGitServiceError(error, "GIT_STATE_CHANGED_DURING_CAPTURE") || isGitServiceError(error, "GIT_STATE_DEADLINE_EXCEEDED")) {
+        throw new TaskValidationOperationError(
+          "validation-failed",
+          "The worktree state changed or could not be captured in time. Try again.",
+          409,
+          { cause: error }
+        );
+      }
+      throw new TaskValidationOperationError(
+        "validation-failed",
+        "Git could not capture the worktree state for this task. Check the daemon output for details.",
+        502,
+        { cause: error }
+      );
+    }
+    if (state.worktree.root !== canonicalWorktree || state.worktree.commonDir !== repository.commonDir || state.worktree.branch !== task.branch) {
+      throw new TaskValidationOperationError("task-not-ready", WORKTREE_MISMATCH_MESSAGE, 409);
+    }
+    return { canonicalWorktree, state };
+  }
+  function boundedOutput(raw, alreadyOmitted) {
+    const safe = sanitizeApprovalDisplayText(raw);
+    if (safe.length <= TASK_VALIDATION_MAX_OUTPUT_CHARS) {
+      return { text: safe, omitted: alreadyOmitted };
+    }
+    return {
+      text: safe.slice(0, TASK_VALIDATION_MAX_OUTPUT_CHARS),
+      omitted: alreadyOmitted + (safe.length - TASK_VALIDATION_MAX_OUTPUT_CHARS)
+    };
+  }
+  function payload(taskId, result, running, stale) {
+    return taskValidationSchema.parse({
+      protocol: PROTOCOL_VERSION,
+      type: "task-validation",
+      taskId,
+      result,
+      running,
+      stale,
+      capturedAtMs: now()
+    });
+  }
+  async function status(taskId) {
+    const task = await resolveTask(taskId);
+    const repository = await resolveRepository(task);
+    const record = task.status === "ready" ? task.validation ?? null : null;
+    const running = activeRuns.has(taskId);
+    let stale = false;
+    if (record !== null) {
+      stale = true;
+      try {
+        const { state } = await captureVerifiedState(task, repository);
+        stale = state.stateFingerprint !== record.stateFingerprint;
+      } catch {
+        stale = true;
+      }
+    }
+    return payload(task.id, record, running, stale);
+  }
+  async function run(taskId, command) {
+    if (disposing) {
+      throw new TaskValidationOperationError(
+        "validation-failed",
+        "The daemon is shutting down and cannot start a validation run.",
+        503
+      );
+    }
+    if (activeRuns.has(taskId)) {
+      throw new TaskValidationOperationError(
+        "validation-running",
+        "A validation is already running for this task. Wait for it to finish.",
+        409
+      );
+    }
+    const active = { run: null };
+    activeRuns.set(taskId, active);
+    try {
+      let errorResult2 = function(message) {
+        return {
+          command,
+          outcome: "error",
+          exitCode: null,
+          signal: null,
+          output: message,
+          outputTruncated: false,
+          omittedOutputChars: 0,
+          startedAtMs: attemptStartedAtMs,
+          finishedAtMs: Math.max(now(), attemptStartedAtMs),
+          stateFingerprint: preState.stateFingerprint
+        };
+      };
+      var errorResult = errorResult2;
+      if (options.isArchiveActive?.(taskId) === true) {
+        throw new TaskValidationOperationError(
+          "archive-in-progress",
+          "This task is being archived or restored. Wait for that operation to finish.",
+          409
+        );
+      }
+      if (options.isCommitActive?.(taskId) === true) {
+        throw new TaskValidationOperationError(
+          "commit-in-progress",
+          "A commit preflight or execution is active for this task. Wait for it to finish before validating.",
+          409
+        );
+      }
+      if (options.isMergeActive?.(taskId) === true) {
+        throw new TaskValidationOperationError(
+          "merge-in-progress",
+          "A merge preflight or execution is active for this task. Wait for it to finish before validating.",
+          409
+        );
+      }
+      if (options.isAgentWorking !== void 0) {
+        let working;
+        try {
+          working = await options.isAgentWorking(taskId);
+        } catch (error) {
+          throw new TaskValidationOperationError(
+            "validation-failed",
+            "The task's runtime state could not be verified. Check the daemon output for details.",
+            503,
+            { cause: error }
+          );
+        }
+        if (working) {
+          throw new TaskValidationOperationError(
+            "agent-working",
+            "The task's agent is still working. Wait for the turn to settle before validating.",
+            409
+          );
+        }
+      }
+      const task = await resolveTask(taskId);
+      const repository = await resolveRepository(task);
+      const { canonicalWorktree, state: preState } = await captureVerifiedState(task, repository);
+      const attemptStartedAtMs = now();
+      async function recordCompletedResult(result2) {
+        try {
+          await options.recordValidation(taskId, result2);
+        } catch (error) {
+          throw new TaskValidationOperationError(
+            "validation-failed",
+            "The validation finished but its result could not be recorded. Check the daemon output for details.",
+            503,
+            { cause: error }
+          );
+        }
+        let stale = true;
+        try {
+          const post = await capture({ worktreePath: canonicalWorktree });
+          stale = post.stateFingerprint !== preState.stateFingerprint;
+        } catch {
+          stale = true;
+        }
+        return payload(task.id, result2, false, stale);
+      }
+      if (disposing) {
+        throw new TaskValidationOperationError(
+          "validation-failed",
+          "The daemon is shutting down and cannot start a validation run.",
+          503
+        );
+      }
+      let validationRun;
+      try {
+        validationRun = startRun({
+          worktreePath: canonicalWorktree,
+          command,
+          ...options.timeoutMs === void 0 ? {} : { timeoutMs: options.timeoutMs },
+          now
+        });
+      } catch (error) {
+        if (isValidationRunnerError(error, "VALIDATION_COMMAND_INVALID")) {
+          throw new TaskValidationOperationError(
+            "invalid-request",
+            "Provide a non-empty validation command within Webdesk's length bound and without unsafe invisible characters.",
+            400,
+            { cause: error }
+          );
+        }
+        return recordCompletedResult(errorResult2("The validation process could not be started."));
+      }
+      active.run = validationRun;
+      let raw;
+      try {
+        raw = await validationRun.result;
+      } catch (error) {
+        if (isValidationRunnerError(error, "VALIDATION_DISPOSED")) {
+          throw new TaskValidationOperationError(
+            "validation-failed",
+            "The validation run was stopped because the daemon is shutting down.",
+            503,
+            { cause: error }
+          );
+        }
+        return recordCompletedResult(
+          errorResult2("The validation process failed before producing a result.")
+        );
+      }
+      const display = boundedOutput(raw.output, raw.omittedOutputChars);
+      const result = {
+        command,
+        outcome: raw.outcome,
+        exitCode: raw.exitCode,
+        signal: raw.signal,
+        output: display.text,
+        outputTruncated: display.omitted > 0,
+        omittedOutputChars: display.omitted,
+        startedAtMs: raw.startedAtMs,
+        finishedAtMs: raw.finishedAtMs,
+        stateFingerprint: preState.stateFingerprint
+      };
+      return recordCompletedResult(result);
+    } finally {
+      activeRuns.delete(taskId);
+    }
+  }
+  async function disposeAll() {
+    disposing = true;
+    await Promise.all(
+      [...activeRuns.values()].map((active) => active.run?.dispose() ?? Promise.resolve())
+    );
+  }
+  return {
+    status,
+    run,
+    isRunning: (taskId) => activeRuns.has(taskId),
+    disposeAll
+  };
+}
+export {
+  TaskValidationOperationError,
+  createTaskValidationService
+};

package/dist/apps/daemon/src/workspace-store.js

@@ -0,0 +1,140 @@
+// apps/daemon/src/workspace-store.ts
+import { randomUUID } from "node:crypto";
+import { mkdir, open, readFile, readdir, rename, unlink } from "node:fs/promises";
+import path from "node:path";
+import {
+  WORKSPACE_SCHEMA_VERSION,
+  workspaceStateV1Schema,
+  workspaceStateV2Schema,
+  workspaceStateV3Schema,
+  workspaceStateV4Schema,
+  workspaceStateSchema
+} from "../../../packages/protocol/src/index.js";
+var WORKSPACE_STATE_FILE = "workspace-v1.json";
+var STALE_TEMP_FILE = /^\.workspace-v1\.json\.\d+\.[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\.tmp$/i;
+var WorkspaceStateError = class extends Error {
+  name = "WorkspaceStateError";
+};
+function emptyState() {
+  return {
+    schemaVersion: WORKSPACE_SCHEMA_VERSION,
+    repositories: [],
+    tasks: []
+  };
+}
+function errorCode(error) {
+  return error !== null && typeof error === "object" && "code" in error ? String(error.code) : void 0;
+}
+function createWorkspaceStore(options) {
+  const stateDir = path.resolve(options.stateDir);
+  const filePath = path.join(stateDir, WORKSPACE_STATE_FILE);
+  let state = null;
+  let initialization = null;
+  let mutationQueue = Promise.resolve();
+  async function persist(next) {
+    await mkdir(stateDir, { recursive: true, mode: 448 });
+    const tempPath = path.join(
+      stateDir,
+      `.${WORKSPACE_STATE_FILE}.${process.pid}.${randomUUID()}.tmp`
+    );
+    let handle = null;
+    try {
+      handle = await open(tempPath, "wx", 384);
+      await handle.writeFile(`${JSON.stringify(next, null, 2)}
+`, "utf8");
+      await handle.sync();
+      await handle.close();
+      handle = null;
+      await rename(tempPath, filePath);
+      let directory = null;
+      try {
+        directory = await open(stateDir, "r");
+        await directory.sync();
+      } catch {
+      } finally {
+        await directory?.close().catch(() => void 0);
+      }
+    } catch (error) {
+      await handle?.close().catch(() => void 0);
+      await unlink(tempPath).catch(() => void 0);
+      throw new WorkspaceStateError(
+        `Could not atomically write Webdesk workspace metadata at ${filePath}: ${errorCode(error) ?? "write failed"}`
+      );
+    }
+  }
+  async function load() {
+    await mkdir(stateDir, { recursive: true, mode: 448 });
+    for (const name of await readdir(stateDir)) {
+      if (STALE_TEMP_FILE.test(name)) {
+        await unlink(path.join(stateDir, name)).catch(() => void 0);
+      }
+    }
+    let raw;
+    try {
+      raw = await readFile(filePath, "utf8");
+    } catch (error) {
+      if (errorCode(error) === "ENOENT") {
+        const initial = emptyState();
+        await persist(initial);
+        state = initial;
+        return;
+      }
+      throw new WorkspaceStateError(
+        `Could not read Webdesk workspace metadata at ${filePath}: ${errorCode(error) ?? "read failed"}`
+      );
+    }
+    try {
+      const decoded = JSON.parse(raw);
+      const current = workspaceStateSchema.safeParse(decoded);
+      if (current.success) {
+        state = current.data;
+        return;
+      }
+      const v4 = workspaceStateV4Schema.safeParse(decoded);
+      const v3 = v4.success ? v4 : workspaceStateV3Schema.safeParse(decoded);
+      const v2 = v3.success ? v3 : workspaceStateV2Schema.safeParse(decoded);
+      const legacy = v2.success ? v2 : workspaceStateV1Schema.safeParse(decoded);
+      if (!legacy.success) throw new Error("unsupported workspace schema");
+      const migrated = workspaceStateSchema.parse({
+        ...legacy.data,
+        schemaVersion: WORKSPACE_SCHEMA_VERSION
+      });
+      await persist(migrated);
+      state = migrated;
+    } catch (error) {
+      if (error instanceof WorkspaceStateError) throw error;
+      throw new WorkspaceStateError(
+        `Webdesk workspace metadata at ${filePath} is invalid. The file was preserved for recovery.`
+      );
+    }
+  }
+  function initialize() {
+    initialization ??= load();
+    return initialization;
+  }
+  async function read() {
+    await initialize();
+    return workspaceStateSchema.parse(state);
+  }
+  async function update(mutate) {
+    const operation = mutationQueue.then(async () => {
+      await initialize();
+      const current = workspaceStateSchema.parse(state);
+      const next = workspaceStateSchema.parse(await mutate(current));
+      await persist(next);
+      state = next;
+      return workspaceStateSchema.parse(next);
+    });
+    mutationQueue = operation.then(
+      () => void 0,
+      () => void 0
+    );
+    return operation;
+  }
+  return { filePath, initialize, read, update };
+}
+export {
+  WORKSPACE_STATE_FILE,
+  WorkspaceStateError,
+  createWorkspaceStore
+};