pi-webdesk 0.1.0

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

@@ -0,0 +1,503 @@
+// apps/daemon/src/task-commit.ts
+import { randomUUID } from "node:crypto";
+import { realpath } from "node:fs/promises";
+import {
+  captureWorktreeState,
+  commitPreparedTree,
+  isGitServiceError,
+  prepareCommitTree
+} from "../../../packages/git/src/index.js";
+import { sanitizeApprovalDisplayText } from "../../../packages/pi-bridge/src/index.js";
+import {
+  PROTOCOL_VERSION,
+  TASK_COMMIT_MAX_FILE_DIFF_CHARS,
+  TASK_COMMIT_MAX_TOTAL_DIFF_CHARS,
+  taskCommitPreflightSchema,
+  taskCommitResultSchema
+} from "../../../packages/protocol/src/index.js";
+var COMMIT_PREFLIGHT_TTL_MS = 10 * 60 * 1e3;
+var TaskCommitOperationError = class extends Error {
+  name = "TaskCommitOperationError";
+  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 committing.";
+var WORKTREE_MISMATCH_MESSAGE = "The recorded worktree no longer matches the task's repository. Recover it before committing.";
+var MAX_PATH_DISPLAY_CHARS = 4096;
+function boundedDisplay(text, maxChars) {
+  const clippedInput = text.length > maxChars;
+  const safe = sanitizeApprovalDisplayText(text.slice(0, maxChars));
+  if (safe.length <= maxChars) return { text: safe, clipped: clippedInput };
+  return { text: safe.slice(0, maxChars), clipped: true };
+}
+function boundedPathDisplay(text) {
+  const bounded = boundedDisplay(text, MAX_PATH_DISPLAY_CHARS);
+  if (!bounded.clipped) return bounded.text;
+  return `${bounded.text.slice(0, MAX_PATH_DISPLAY_CHARS - 1)}\u2026`;
+}
+function createTaskCommitService(options) {
+  const capture = options.captureWorktreeState ?? captureWorktreeState;
+  const prepare = options.prepareCommitTree ?? prepareCommitTree;
+  const publish = options.commitPreparedTree ?? commitPreparedTree;
+  const preflightTtlMs = options.preflightTtlMs ?? COMMIT_PREFLIGHT_TTL_MS;
+  const now = options.now ?? Date.now;
+  const createId = options.createId ?? randomUUID;
+  const activePhases = /* @__PURE__ */ new Map();
+  const pendingPreflights = /* @__PURE__ */ new Map();
+  async function resolveTask(taskId) {
+    let task;
+    try {
+      task = await options.getTask(taskId);
+    } catch (error) {
+      throw new TaskCommitOperationError(
+        "commit-failed",
+        "The task could not be resolved from the local workspace.",
+        503,
+        { cause: error }
+      );
+    }
+    if (task === null) {
+      throw new TaskCommitOperationError(
+        "task-not-found",
+        "The selected task no longer exists.",
+        404
+      );
+    }
+    if (task.status !== "ready") {
+      throw new TaskCommitOperationError(
+        "task-not-ready",
+        `Only a ready task can be committed; 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 TaskCommitOperationError(
+        "commit-failed",
+        "The task's repository could not be resolved from the local workspace.",
+        503,
+        { cause: error }
+      );
+    }
+    if (repository === null) {
+      throw new TaskCommitOperationError(
+        "task-not-ready",
+        "The task's repository is no longer registered.",
+        409
+      );
+    }
+    return repository;
+  }
+  function claimPhase(taskId, phase) {
+    if (activePhases.has(taskId)) {
+      throw new TaskCommitOperationError(
+        "commit-in-progress",
+        "A commit preflight or execution is already in progress for this task.",
+        409
+      );
+    }
+    activePhases.set(taskId, phase);
+  }
+  function refuseRunningValidation(taskId) {
+    if (options.isValidationRunning(taskId)) {
+      throw new TaskCommitOperationError(
+        "validation-running",
+        "A validation is running for this task. Wait for it to finish before committing.",
+        409
+      );
+    }
+  }
+  function refuseActiveMerge(taskId) {
+    if (options.isMergeActive?.(taskId) === true) {
+      throw new TaskCommitOperationError(
+        "merge-in-progress",
+        "A merge preflight or execution is active for this task. Wait for it to finish before committing.",
+        409
+      );
+    }
+  }
+  async function refuseWorkingAgent(taskId) {
+    let working;
+    try {
+      working = await options.isAgentWorking(taskId);
+    } catch (error) {
+      throw new TaskCommitOperationError(
+        "commit-failed",
+        "The task's runtime state could not be verified. Check the daemon output for details.",
+        503,
+        { cause: error }
+      );
+    }
+    if (working) {
+      throw new TaskCommitOperationError(
+        "agent-working",
+        "The task's agent is still working. Wait for the turn to settle before committing.",
+        409
+      );
+    }
+  }
+  async function captureVerifiedState(task, repository, phase) {
+    let canonicalWorktree;
+    try {
+      canonicalWorktree = await realpath(task.worktreePath);
+    } catch (error) {
+      throw new TaskCommitOperationError("task-not-ready", WORKTREE_UNAVAILABLE_MESSAGE, 409, {
+        cause: error
+      });
+    }
+    let state;
+    try {
+      state = await capture({ worktreePath: canonicalWorktree });
+    } catch (error) {
+      throw mapGitError(error, phase);
+    }
+    if (state.worktree.root !== canonicalWorktree || state.worktree.commonDir !== repository.commonDir || state.worktree.branch !== task.branch) {
+      throw new TaskCommitOperationError("task-not-ready", WORKTREE_MISMATCH_MESSAGE, 409);
+    }
+    return { canonicalWorktree, state };
+  }
+  function mapGitError(error, phase) {
+    if (isGitServiceError(error)) {
+      if (WORKTREE_UNAVAILABLE_CODES.has(error.code)) {
+        return new TaskCommitOperationError("task-not-ready", WORKTREE_UNAVAILABLE_MESSAGE, 409, {
+          cause: error
+        });
+      }
+      switch (error.code) {
+        case "GIT_COMMIT_CONFLICTED":
+          return new TaskCommitOperationError(
+            "commit-conflicted",
+            "The worktree has unresolved merge conflicts. Resolve them before committing.",
+            409,
+            { cause: error }
+          );
+        case "GIT_COMMIT_NOTHING_TO_COMMIT":
+          return new TaskCommitOperationError(
+            "nothing-to-commit",
+            "There are no changes to commit for this task.",
+            409,
+            { cause: error }
+          );
+        case "GIT_COMMIT_IDENTITY_MISSING":
+          return new TaskCommitOperationError(
+            "identity-missing",
+            "Git identity is not configured for this worktree. Set user.name and user.email, then try again.",
+            409,
+            { cause: error }
+          );
+        case "GIT_COMMIT_DETACHED_HEAD":
+        case "GIT_COMMIT_BRANCH_MISMATCH":
+          return new TaskCommitOperationError("task-not-ready", WORKTREE_MISMATCH_MESSAGE, 409, {
+            cause: error
+          });
+        case "GIT_COMMIT_STATE_UNSUPPORTED":
+        case "GIT_STATE_UNFINGERPRINTABLE":
+        case "GIT_STATE_TOO_LARGE":
+          return new TaskCommitOperationError(
+            "state-unsupported",
+            "The worktree has changes that are too large or cannot be committed safely by Webdesk yet.",
+            422,
+            { cause: error }
+          );
+        case "GIT_COMMIT_PARENT_MOVED":
+        case "GIT_COMMIT_REF_CAS_FAILED":
+          return new TaskCommitOperationError(
+            "branch-moved",
+            "The branch moved since the approved preflight. Review the current state and preflight again.",
+            409,
+            { cause: error }
+          );
+        case "GIT_COMMIT_PUBLICATION_UNKNOWN": {
+          const commit = typeof error.details.commit === "string" ? error.details.commit.slice(0, 12) : "unknown";
+          return new TaskCommitOperationError(
+            "commit-failed",
+            `Git may have published commit ${commit}, but Webdesk could not verify the branch. Inspect the repository before retrying.`,
+            502,
+            { cause: error }
+          );
+        }
+        case "GIT_COMMIT_SIGNING_FAILED":
+          return new TaskCommitOperationError(
+            "signing-failed",
+            "Commit signing failed or timed out; no commit was published. Check your signing setup.",
+            502,
+            { cause: error }
+          );
+        case "GIT_REPOSITORY_CHANGED_DURING_CAPTURE":
+        case "GIT_STATE_CHANGED_DURING_CAPTURE":
+        case "GIT_STATE_DEADLINE_EXCEEDED":
+          return new TaskCommitOperationError(
+            "commit-failed",
+            phase === "preflight" ? "The worktree state changed or could not be captured in time. Try again." : "The worktree state changed or could not be re-verified in time. Preflight again.",
+            409,
+            { cause: error }
+          );
+        default:
+          break;
+      }
+    }
+    return new TaskCommitOperationError(
+      "commit-failed",
+      "Git could not complete the commit operation. Check the daemon output for details.",
+      502,
+      { cause: error }
+    );
+  }
+  function validationVerdict(task, stateFingerprint) {
+    const result = task.validation;
+    if (result === void 0) return "none";
+    if (result.stateFingerprint !== stateFingerprint) return "stale";
+    return result.outcome === "passed" ? "current-passed" : "current-failed";
+  }
+  function preflightPayload(taskId, pending, prepared, verdict, createdAtMs) {
+    let remainingChars = TASK_COMMIT_MAX_TOTAL_DIFF_CHARS;
+    let totalDiffTruncated = prepared.totalDiffTruncated;
+    const files = prepared.files.map((file) => {
+      let diff = null;
+      let diffTruncated = file.diffTruncated;
+      let diffOmittedReason = file.diffOmittedReason;
+      if (file.diff !== null) {
+        if (remainingChars <= 0) {
+          diffOmittedReason = "total-budget";
+          diffTruncated = false;
+          totalDiffTruncated = true;
+        } else {
+          const perFileLimit = Math.min(TASK_COMMIT_MAX_FILE_DIFF_CHARS, remainingChars);
+          const bounded = boundedDisplay(file.diff, perFileLimit);
+          diff = bounded.text;
+          if (bounded.clipped) {
+            diffTruncated = true;
+            if (perFileLimit < TASK_COMMIT_MAX_FILE_DIFF_CHARS) totalDiffTruncated = true;
+          }
+          remainingChars -= diff.length;
+        }
+      }
+      return {
+        entryId: file.entryId,
+        path: boundedPathDisplay(file.path),
+        previousPath: file.previousPath === null ? null : boundedPathDisplay(file.previousPath),
+        kind: file.kind,
+        binary: file.binary,
+        diff,
+        diffTruncated,
+        diffOmittedReason
+      };
+    });
+    return taskCommitPreflightSchema.parse({
+      protocol: PROTOCOL_VERSION,
+      type: "task-commit-preflight",
+      taskId,
+      preflightId: pending.preflightId,
+      branch: pending.branch,
+      parentCommit: pending.parentCommit,
+      treeOid: pending.treeOid,
+      message: pending.message,
+      files,
+      totalFiles: prepared.totalFiles,
+      omittedFiles: prepared.omittedFiles,
+      totalDiffTruncated,
+      stagedDivergence: prepared.stagedDivergence,
+      validationVerdict: verdict,
+      acknowledgementRequired: pending.acknowledgementRequired,
+      hooksBypassed: true,
+      createdAtMs,
+      expiresAtMs: pending.expiresAtMs
+    });
+  }
+  async function preflight(taskId, message) {
+    claimPhase(taskId, "preflight");
+    pendingPreflights.delete(taskId);
+    try {
+      if (options.isArchiveActive?.(taskId) === true) {
+        throw new TaskCommitOperationError(
+          "archive-in-progress",
+          "This task is being archived or restored. Wait for that operation to finish.",
+          409
+        );
+      }
+      refuseRunningValidation(taskId);
+      refuseActiveMerge(taskId);
+      const task = await resolveTask(taskId);
+      const repository = await resolveRepository(task);
+      await refuseWorkingAgent(taskId);
+      const { canonicalWorktree, state: before } = await captureVerifiedState(
+        task,
+        repository,
+        "preflight"
+      );
+      let prepared;
+      try {
+        prepared = await prepare({
+          worktreePath: canonicalWorktree,
+          expectedBranch: task.branch
+        });
+      } catch (error) {
+        throw mapGitError(error, "preflight");
+      }
+      if (prepared.parentCommit !== before.worktree.headCommit) {
+        throw new TaskCommitOperationError(
+          "commit-failed",
+          "The worktree state changed while the commit was being prepared. Try again.",
+          409
+        );
+      }
+      const { state: after } = await captureVerifiedState(task, repository, "preflight");
+      if (after.stateFingerprint !== before.stateFingerprint) {
+        throw new TaskCommitOperationError(
+          "commit-failed",
+          "The worktree changed while the commit was being prepared. Review the new state and try again.",
+          409
+        );
+      }
+      const verdict = validationVerdict(task, before.stateFingerprint);
+      const createdAtMs = now();
+      const pending = {
+        preflightId: createId(),
+        message,
+        branch: prepared.branch,
+        parentCommit: prepared.parentCommit,
+        treeOid: prepared.treeOid,
+        stagedPaths: prepared.stagedPaths,
+        stateFingerprint: before.stateFingerprint,
+        validationVerdict: verdict,
+        acknowledgementRequired: verdict !== "current-passed",
+        expiresAtMs: createdAtMs + preflightTtlMs
+      };
+      const payload = preflightPayload(taskId, pending, prepared, verdict, createdAtMs);
+      pendingPreflights.set(taskId, pending);
+      return payload;
+    } finally {
+      activePhases.delete(taskId);
+    }
+  }
+  async function execute(taskId, request) {
+    claimPhase(taskId, "execute");
+    try {
+      if (options.isArchiveActive?.(taskId) === true) {
+        throw new TaskCommitOperationError(
+          "archive-in-progress",
+          "This task is being archived or restored. Wait for that operation to finish.",
+          409
+        );
+      }
+      refuseRunningValidation(taskId);
+      refuseActiveMerge(taskId);
+      const task = await resolveTask(taskId);
+      const repository = await resolveRepository(task);
+      await refuseWorkingAgent(taskId);
+      const pending = pendingPreflights.get(taskId);
+      if (pending === void 0 || pending.preflightId !== request.preflightId) {
+        throw new TaskCommitOperationError(
+          "preflight-not-found",
+          "This commit preflight is no longer valid. Review the current changes and preflight again.",
+          409
+        );
+      }
+      if (now() >= pending.expiresAtMs) {
+        pendingPreflights.delete(taskId);
+        throw new TaskCommitOperationError(
+          "preflight-not-found",
+          "This commit preflight expired. Review the current changes and preflight again.",
+          409
+        );
+      }
+      const currentVerdict = validationVerdict(task, pending.stateFingerprint);
+      if (currentVerdict !== pending.validationVerdict) {
+        pendingPreflights.delete(taskId);
+        throw new TaskCommitOperationError(
+          "preflight-outdated",
+          "The validation verdict changed after this preflight. Review the current result and preflight again.",
+          409
+        );
+      }
+      if (pending.acknowledgementRequired && request.acknowledgeValidation !== true) {
+        throw new TaskCommitOperationError(
+          "acknowledgement-required",
+          "Acknowledge the validation verdict explicitly before committing this snapshot.",
+          409
+        );
+      }
+      let canonicalWorktree;
+      let current;
+      try {
+        ({ canonicalWorktree, state: current } = await captureVerifiedState(
+          task,
+          repository,
+          "execute"
+        ));
+      } catch (error) {
+        pendingPreflights.delete(taskId);
+        throw error;
+      }
+      if (current.stateFingerprint !== pending.stateFingerprint) {
+        pendingPreflights.delete(taskId);
+        throw new TaskCommitOperationError(
+          "preflight-outdated",
+          "The worktree changed after this preflight was approved. Review the new state and preflight again.",
+          409
+        );
+      }
+      pendingPreflights.delete(taskId);
+      let publication;
+      try {
+        publication = await publish({
+          worktreePath: canonicalWorktree,
+          branch: pending.branch,
+          parentCommit: pending.parentCommit,
+          treeOid: pending.treeOid,
+          message: pending.message,
+          stagedPaths: pending.stagedPaths,
+          reflogReason: `pita-commit: task ${taskId} preflight ${pending.preflightId}`
+        });
+      } catch (error) {
+        throw mapGitError(error, "execute");
+      }
+      return taskCommitResultSchema.parse({
+        protocol: PROTOCOL_VERSION,
+        type: "task-commit-result",
+        taskId,
+        branch: publication.branch,
+        commit: publication.commit,
+        treeOid: publication.treeOid,
+        parentCommit: publication.parentCommit,
+        signed: publication.signed,
+        indexSynced: publication.indexSynced,
+        headVerified: publication.headVerified,
+        capturedAtMs: now()
+      });
+    } finally {
+      activePhases.delete(taskId);
+    }
+  }
+  return {
+    preflight,
+    execute,
+    isBusy: (taskId) => activePhases.has(taskId),
+    invalidate(taskId) {
+      pendingPreflights.delete(taskId);
+    }
+  };
+}
+export {
+  COMMIT_PREFLIGHT_TTL_MS,
+  TaskCommitOperationError,
+  createTaskCommitService
+};