opencode-ship 1.1.5 → 1.1.8

package/dist/core.js

@@ -1,4 +1,4 @@
-// opencode-ship/core v1.1.5
+// opencode-ship/core v1.1.8
 
 // src/adapter.js
 import { readFile, writeFile, mkdir, rename } from "node:fs/promises";
@@ -851,7 +851,7 @@ function validateGhArgv(argv) {
 
 // src/drivers/gh-cli.js
 function defaultRunner(cwd, env) {
-  return (args) => new Promise((resolve9, reject) => {
+  return (args) => new Promise((resolve11, reject) => {
     const proc = spawn2("gh", args, {
       cwd,
       env,
@@ -863,7 +863,7 @@ function defaultRunner(cwd, env) {
     proc.stdout.on("data", (d) => stdout += d.toString());
     proc.stderr.on("data", (d) => stderr += d.toString());
     proc.on("error", reject);
-    proc.on("close", (status) => resolve9({ status: status ?? -1, stdout, stderr }));
+    proc.on("close", (status) => resolve11({ status: status ?? -1, stdout, stderr }));
   });
 }
 function viewFields() {
@@ -1532,6 +1532,9 @@ function createWorktreeTool(deps) {
         expectedRoot: resolve7(deps.repoRoot, worktreeRoot)
       };
     }
+    if (m.schemaVersion >= 2 && !m.workflowId) {
+      return { kind: "missing-workflow-link", taskId: m.taskId };
+    }
     const remote = deps.remote ?? "origin";
     const hasRemote = remoteExists(remote, deps.repoRoot);
     if (hasRemote) {
@@ -2527,6 +2530,42 @@ function createMergeTool(deps) {
     } else if (m.schemaVersion >= 2) {
       return { kind: "missing-workflow-link", taskId: m.taskId };
     }
+    if (pr.headSha !== (m.lastPrHeadSha ?? pr.headSha)) {
+      return {
+        kind: "head-changed",
+        headSha: pr.headSha,
+        manifestSha: m.lastPrHeadSha ?? ""
+      };
+    }
+    async function recordMerged(merged2, reason) {
+      const t = transition(
+        { ...m, lastPrHeadSha: merged2.headSha },
+        "merged",
+        { reason }
+      );
+      if (!t.ok) return { kind: "lifecycle", reason: t.reason };
+      const next = {
+        ...m,
+        lastPrHeadSha: merged2.headSha,
+        state: t.to,
+        transitionLog: [
+          ...m.transitionLog,
+          { from: t.from, to: t.to, at: t.at, reason: t.reason }
+        ],
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      const path = await writeManifest(deps.repoRoot, next);
+      if (finalEvidence && m.workflowId) {
+        await appendRunEvent(deps.repoRoot, m.workflowId, finalEvidence.runState, {
+          kind: RUN_EVENT_KINDS.MERGE,
+          data: { mergeSha: merged2.mergeSha ?? merged2.mergeCommitSha ?? merged2.headSha }
+        });
+      }
+      return { kind: "merge", contractVersion: 1, manifestPath: path, pr: m.prNumber, taskId: m.taskId };
+    }
+    if (pr.merged) {
+      return recordMerged(pr, `reconciled external merge as ${input.subject}`);
+    }
     if (freshGates) {
       const required = deps.adapter?.ready?.requires ?? [
         "review",
@@ -2553,13 +2592,6 @@ function createMergeTool(deps) {
       });
       if (!result.ok) return gateFailureEnvelope(result);
     }
-    if (pr.headSha !== (m.lastPrHeadSha ?? pr.headSha)) {
-      return {
-        kind: "head-changed",
-        headSha: pr.headSha,
-        manifestSha: m.lastPrHeadSha ?? ""
-      };
-    }
     if (pr.draft) return { kind: "not-mergeable", reason: "PR is still draft" };
     if (pr.mergeable !== "MERGEABLE") {
       return { kind: "not-mergeable", reason: `mergeable=${pr.mergeable}` };
@@ -2569,30 +2601,7 @@ function createMergeTool(deps) {
       number: m.prNumber,
       subject: input.subject
     });
-    const t = transition(
-      { ...m, lastPrHeadSha: merged.headSha },
-      "merged",
-      { reason: `squash merged as ${input.subject}` }
-    );
-    if (!t.ok) return { kind: "lifecycle", reason: t.reason };
-    const next = {
-      ...m,
-      lastPrHeadSha: merged.headSha,
-      state: t.to,
-      transitionLog: [
-        ...m.transitionLog,
-        { from: t.from, to: t.to, at: t.at, reason: t.reason }
-      ],
-      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-    };
-    const path = await writeManifest(deps.repoRoot, next);
-    if (finalEvidence && m.workflowId) {
-      await appendRunEvent(deps.repoRoot, m.workflowId, finalEvidence.runState, {
-        kind: RUN_EVENT_KINDS.MERGE,
-        data: { mergeSha: merged.mergeSha ?? merged.mergeCommitSha ?? merged.headSha }
-      });
-    }
-    return { kind: "merge", contractVersion: 1, manifestPath: path, pr: m.prNumber, taskId: m.taskId };
+    return recordMerged(merged, `squash merged as ${input.subject}`);
   };
 }
 
@@ -2769,8 +2778,433 @@ function createCleanupTool(deps) {
   };
 }
 
-// src/index.js
-var PACKAGE_VERSION = "0.1.3";
+// src/tools/delivery-abandon.js
+import { join as join10 } from "node:path";
+import { spawnSync as spawnSync4 } from "node:child_process";
+import { existsSync as existsSync8 } from "node:fs";
+
+// src/state/abandon-store.js
+import { readFile as readFile7 } from "node:fs/promises";
+import { join as join8 } from "node:path";
+import { createHash as createHash7 } from "node:crypto";
+var SAFE_ID_RE2 = /^[A-Za-z0-9._-]{1,128}$/;
+var HASH_RE2 = /^[0-9a-f]{64}$/;
+function abandonDir(commonDir, taskId) {
+  return join8(commonDir, "opencode-ship", "delivery", "abandoned", taskId);
+}
+function intentPathFor(commonDir, taskId) {
+  return join8(abandonDir(commonDir, taskId), "intent.json");
+}
+function completionPathFor(commonDir, taskId) {
+  return join8(abandonDir(commonDir, taskId), "completion.json");
+}
+async function readJsonOrNull2(path) {
+  try {
+    return JSON.parse(await readFile7(path, "utf8"));
+  } catch (err) {
+    if (err?.code === "ENOENT") return null;
+    throw err;
+  }
+}
+function withoutIntentHash(record) {
+  const copy = { ...record ?? {} };
+  delete copy.intentHash;
+  return copy;
+}
+function hashAbandonIntent(record) {
+  return createHash7("sha256").update(canonicalJson(withoutIntentHash(record)), "utf8").digest("hex");
+}
+async function readAbandon(repoRoot, taskId) {
+  const commonDir = await resolveGitCommonDir(repoRoot);
+  if (!SAFE_ID_RE2.test(String(taskId ?? ""))) {
+    return { intent: null, completion: null };
+  }
+  return {
+    intent: await readJsonOrNull2(intentPathFor(commonDir, taskId)),
+    completion: await readJsonOrNull2(completionPathFor(commonDir, taskId))
+  };
+}
+async function publishOrReuse(path, record) {
+  try {
+    await publishImmutableJson(path, record);
+    return { ok: true, record, idempotent: false };
+  } catch (err) {
+    const message = String(err?.message ?? err);
+    if (!message.includes("already exists")) throw err;
+    const existing = await readJsonOrNull2(path);
+    if (existing && canonicalJson(existing) === canonicalJson(record)) {
+      return { ok: true, record: existing, idempotent: true };
+    }
+    return { ok: false, kind: "abandon-conflict" };
+  }
+}
+async function publishAbandonIntent(repoRoot, record) {
+  const taskId = String(record?.taskId ?? "");
+  if (!SAFE_ID_RE2.test(taskId)) {
+    return { ok: false, kind: "invalid-task-id" };
+  }
+  const sealed = { ...withoutIntentHash(record), intentHash: hashAbandonIntent(record) };
+  const commonDir = await resolveGitCommonDir(repoRoot);
+  return publishOrReuse(intentPathFor(commonDir, taskId), sealed);
+}
+async function publishAbandonCompletion(repoRoot, record) {
+  const taskId = String(record?.taskId ?? "");
+  const intentHash = String(record?.intentHash ?? "");
+  if (!SAFE_ID_RE2.test(taskId)) {
+    return { ok: false, kind: "invalid-task-id" };
+  }
+  if (!HASH_RE2.test(intentHash)) {
+    return { ok: false, kind: "invalid-intent-hash" };
+  }
+  const commonDir = await resolveGitCommonDir(repoRoot);
+  return publishOrReuse(completionPathFor(commonDir, taskId), record);
+}
+
+// src/skills/worktree.js
+import { execFile } from "node:child_process";
+import { promises as fs, existsSync as existsSync7 } from "node:fs";
+import { resolve as resolve9, dirname as dirname3, sep, isAbsolute, join as join9 } from "node:path";
+function listRegisteredWorktrees(mainRepo) {
+  return new Promise((resolveP, rejectP) => {
+    execFile(
+      "git",
+      ["-C", mainRepo, "worktree", "list", "--porcelain", "-z"],
+      { shell: false, maxBuffer: 1024 * 1024 },
+      (err, stdout) => {
+        if (err) return rejectP(err);
+        const records = parsePorcelain(stdout);
+        const mainRecord = records.shift();
+        const mainPath = mainRecord?.worktree ? resolve9(mainRecord.worktree) : null;
+        const linked = [];
+        for (const r of records) {
+          if (!r.worktree) continue;
+          const p = resolve9(r.worktree);
+          if (mainPath && p === mainPath) continue;
+          linked.push({ path: p, branch: r.HEAD ?? null });
+        }
+        resolveP(linked);
+      }
+    );
+  });
+}
+function parsePorcelain(text) {
+  const tokens = text.split("\0");
+  const out = [];
+  let current = {};
+  for (const tok of tokens) {
+    if (tok.length === 0) {
+      if (Object.keys(current).length > 0) {
+        out.push(current);
+        current = {};
+      }
+      continue;
+    }
+    const idx = tok.indexOf(" ");
+    const key = idx === -1 ? tok : tok.slice(0, idx);
+    const value = idx === -1 ? "" : tok.slice(idx + 1);
+    if (key === "branch") {
+      current.HEAD = value.startsWith("refs/heads/") ? value : `refs/heads/${value}`;
+    } else {
+      current[key] = value;
+    }
+  }
+  if (Object.keys(current).length > 0) out.push(current);
+  return out;
+}
+async function validateLinkedWorktree(mainRepo, worktreePath, options = {}) {
+  const main = resolve9(mainRepo);
+  if (!existsSync7(main)) {
+    return { ok: false, kind: "missing", message: `main repository ${main} does not exist` };
+  }
+  if (!worktreePath) {
+    return { ok: false, kind: "unlinked", message: "worktreePath is required" };
+  }
+  const wt = resolve9(worktreePath);
+  if (!existsSync7(wt)) {
+    return { ok: false, kind: "missing", message: `worktree ${wt} does not exist` };
+  }
+  const isCurrent = wt === main;
+  if (isCurrent) {
+    const gitEntry = options.allowCurrentLinked ? await fs.lstat(join9(main, ".git")).catch(() => null) : null;
+    if (!gitEntry?.isFile()) {
+      return { ok: false, kind: "main", message: "installs into the main worktree are forbidden" };
+    }
+  }
+  let cursor = wt;
+  while (cursor !== dirname3(cursor)) {
+    const stat2 = await fs.lstat(cursor).catch(() => null);
+    if (stat2?.isSymbolicLink()) {
+      return {
+        ok: false,
+        kind: "ancestor-symlink",
+        message: `worktree path contains a symlink at ${cursor}`
+      };
+    }
+    cursor = dirname3(cursor);
+  }
+  const real = await fs.realpath(wt).catch(() => null);
+  if (real && real !== wt) {
+    return {
+      ok: false,
+      kind: "symlink",
+      message: `worktree ${wt} resolves through a symlink to ${real}`
+    };
+  }
+  const linked = await listRegisteredWorktrees(main);
+  const matched = linked.find((entry) => entry.path === wt);
+  if (!matched) {
+    return {
+      ok: false,
+      kind: "unlinked",
+      message: `worktree ${wt} is not registered (git worktree list)`
+    };
+  }
+  return { ok: true, path: wt, registered: !!matched };
+}
+
+// src/tools/envelope.js
+import { randomBytes as randomBytes2 } from "node:crypto";
+var CONTRACT_VERSION = 2;
+function operationId(prefix = "op") {
+  return `${prefix}-${Date.now().toString(36)}-${randomBytes2(4).toString("hex")}`;
+}
+function success(kind, data, options = {}) {
+  if (typeof kind !== "string" || kind.length === 0) {
+    throw new Error("envelope.success: kind must be a non-empty string");
+  }
+  return {
+    contractVersion: CONTRACT_VERSION,
+    ok: true,
+    kind,
+    operationId: options.operationId ?? operationId(kind),
+    idempotent: options.idempotent !== false,
+    data
+  };
+}
+function failure(kind, message, options = {}) {
+  if (typeof kind !== "string" || kind.length === 0) {
+    throw new Error("envelope.failure: kind must be a non-empty string");
+  }
+  if (typeof message !== "string" || message.length === 0) {
+    throw new Error("envelope.failure: message must be a non-empty string");
+  }
+  const details = options.details ?? {};
+  return {
+    contractVersion: CONTRACT_VERSION,
+    ok: false,
+    kind,
+    operationId: options.operationId ?? operationId(`${kind}-err`),
+    retryable: options.retryable === true,
+    message,
+    details
+  };
+}
+
+// src/tools/delivery-abandon.js
+import { readFile as readFile8 } from "node:fs/promises";
+function runGit2(args, cwd) {
+  return spawnSync4("git", args, {
+    cwd,
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "pipe"],
+    env: process.env
+  });
+}
+function defaultRemoveWorktree(repoRoot, path) {
+  return runGit2(["worktree", "remove", path], repoRoot);
+}
+function defaultDeleteBranch(repoRoot, branch, expectedSha) {
+  const args = ["update-ref", "-d", `refs/heads/${branch}`];
+  if (expectedSha && /^[0-9a-f]{7,}$/i.test(expectedSha)) args.push(expectedSha);
+  return runGit2(args, repoRoot);
+}
+function branchExists(repoRoot, branch) {
+  return runGit2(["show-ref", "--verify", "--quiet", `refs/heads/${branch}`], repoRoot).status === 0;
+}
+function remoteBranchHead(repoRoot, remote, branch) {
+  const r = runGit2(["ls-remote", "--heads", remote, branch], repoRoot);
+  if (r.status !== 0) return { ok: false, sha: null, present: false };
+  const line = r.stdout.split("\n").find((row) => row.includes(`refs/heads/${branch}`));
+  if (!line) return { ok: true, sha: null, present: false };
+  return { ok: true, sha: line.split(/\s+/)[0], present: true };
+}
+function unpublishedAhead(repoRoot, remote, branch) {
+  const r = runGit2(["rev-list", "--count", `${remote}/${branch}..${branch}`], repoRoot);
+  if (r.status !== 0) return null;
+  const n = parseInt(r.stdout.trim(), 10);
+  return Number.isFinite(n) ? n : null;
+}
+function refuse(opId, kind, extras = {}) {
+  return failure("abandon", kind, {
+    operationId: opId,
+    retryable: false,
+    details: { kind, ...extras }
+  });
+}
+async function readRunSnapshot(repoRoot, workflowId) {
+  try {
+    const common = await resolveGitCommonDir(repoRoot);
+    const path = join10(opencodeShipStateDir(common), "runs", workflowId, "run.json");
+    if (!existsSync8(path)) return null;
+    return JSON.parse(await readFile8(path, "utf8"));
+  } catch {
+    return null;
+  }
+}
+async function validateLiveAttempt({ deps, manifest, subject, opId }) {
+  if (!manifest.prNumber) return refuse(opId, "missing-pr");
+  if (!manifest.worktreePath) return refuse(opId, "missing-worktree-path");
+  const pr = await deps.driver.readPullRequest({
+    repo: deps.repoSlug,
+    number: manifest.prNumber
+  });
+  if (pr.merged || pr.state === "MERGED") return refuse(opId, "pr-merged");
+  if (pr.state !== "CLOSED") return refuse(opId, "pr-open");
+  if (pr.headRefName && pr.headRefName !== manifest.branch) {
+    return refuse(opId, "branch-mismatch", { expected: manifest.branch, received: pr.headRefName });
+  }
+  if (pr.baseRefName && pr.baseRefName !== manifest.baseBranch) {
+    return refuse(opId, "base-mismatch", { expected: manifest.baseBranch, received: pr.baseRefName });
+  }
+  const linked = await validateLinkedWorktree(deps.repoRoot, manifest.worktreePath);
+  if (!linked.ok) {
+    return refuse(opId, "invalid-worktree", { reason: linked.kind, message: linked.message });
+  }
+  if (!isWorktreeClean(linked.path)) return refuse(opId, "dirty-worktree");
+  if (isRebaseInProgress(linked.path)) return refuse(opId, "rebase-in-progress");
+  const head = currentHead(linked.path);
+  if (!head || head !== manifest.lastPrHeadSha || head !== pr.headSha) {
+    return refuse(opId, "head-mismatch", {
+      local: head ?? "",
+      manifest: manifest.lastPrHeadSha ?? "",
+      pr: pr.headSha ?? ""
+    });
+  }
+  const remote = deps.remote ?? "origin";
+  const remoteHead = remoteBranchHead(linked.path, remote, manifest.branch);
+  if (remoteHead.ok && remoteHead.present && remoteHead.sha !== head) {
+    return refuse(opId, "remote-diverged", { local: head, remote: remoteHead.sha });
+  }
+  const ahead = unpublishedAhead(linked.path, remote, manifest.branch);
+  if (ahead !== null && ahead > 0) {
+    return refuse(opId, "has-unpublished-commits", { ahead, branch: manifest.branch, remote });
+  }
+  if (manifest.workflowId) {
+    const snapshot = await readRunSnapshot(deps.repoRoot, manifest.workflowId);
+    if (snapshot?.state === "ready") return refuse(opId, "workflow-ready");
+    if (snapshot?.state === "merged") return refuse(opId, "workflow-merged");
+  }
+  return {
+    ok: true,
+    intent: {
+      schemaVersion: 1,
+      taskId: manifest.taskId,
+      issueNumber: manifest.issueNumber,
+      prNumber: manifest.prNumber,
+      branch: manifest.branch,
+      worktreePath: linked.path,
+      headSha: head,
+      workflowId: manifest.workflowId ?? null,
+      subject,
+      requestedAt: (/* @__PURE__ */ new Date()).toISOString()
+    }
+  };
+}
+async function resumeCleanup({ deps, intent, opId }) {
+  const removeWorktree = deps.removeWorktree ?? defaultRemoveWorktree;
+  const deleteBranch = deps.deleteBranch ?? defaultDeleteBranch;
+  const removeManifest = deps.deleteManifest ?? deleteManifest;
+  let removedWorktree = !existsSync8(intent.worktreePath);
+  if (!removedWorktree) {
+    let removed;
+    try {
+      removed = await Promise.resolve(removeWorktree(deps.repoRoot, intent.worktreePath));
+    } catch (err) {
+      return refuse(opId, "remove-failed", { stderr: String(err?.message ?? err) });
+    }
+    if (removed?.status !== 0 && existsSync8(intent.worktreePath)) {
+      return refuse(opId, "remove-failed", { stderr: removed?.stderr ?? "" });
+    }
+    removedWorktree = !existsSync8(intent.worktreePath);
+  }
+  let deletedBranch = !branchExists(deps.repoRoot, intent.branch);
+  if (!deletedBranch) {
+    let deleted;
+    try {
+      deleted = await Promise.resolve(deleteBranch(deps.repoRoot, intent.branch, intent.headSha));
+    } catch (err) {
+      return refuse(opId, "branch-delete-failed", { stderr: String(err?.message ?? err) });
+    }
+    if (deleted?.status !== 0 && branchExists(deps.repoRoot, intent.branch)) {
+      return refuse(opId, "branch-delete-failed", { stderr: deleted?.stderr ?? "" });
+    }
+    deletedBranch = !branchExists(deps.repoRoot, intent.branch);
+  }
+  try {
+    await Promise.resolve(removeManifest(deps.repoRoot, intent.taskId));
+  } catch (err) {
+    return refuse(opId, "manifest-delete-failed", { stderr: String(err?.message ?? err) });
+  }
+  const remaining = await readManifest(deps.repoRoot, intent.taskId);
+  const deletedManifest = remaining === null;
+  const completion = {
+    schemaVersion: 1,
+    taskId: intent.taskId,
+    intentHash: intent.intentHash,
+    removedWorktree,
+    deletedBranch,
+    deletedManifest,
+    completedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  const published = await publishAbandonCompletion(deps.repoRoot, completion);
+  if (!published.ok) return refuse(opId, published.kind);
+  return success("abandon", {
+    taskId: intent.taskId,
+    intentHash: intent.intentHash,
+    removedWorktree,
+    deletedBranch,
+    deletedManifest
+  }, { operationId: opId, idempotent: published.idempotent === true });
+}
+function createAbandonTool(deps) {
+  return async function abandon(input) {
+    const opId = input.operationId ?? `abandon-${Date.now().toString(36)}`;
+    const taskId = String(input.taskId ?? "");
+    const subject = String(input.subject ?? "").trim();
+    if (!taskId) return refuse(opId, "missing-input", { field: "taskId" });
+    if (!subject) return refuse(opId, "missing-input", { field: "subject" });
+    const existing = await readAbandon(deps.repoRoot, taskId);
+    if (existing.completion) {
+      return success("abandon", {
+        taskId,
+        intentHash: existing.completion.intentHash,
+        removedWorktree: existing.completion.removedWorktree,
+        deletedBranch: existing.completion.deletedBranch,
+        deletedManifest: existing.completion.deletedManifest
+      }, { operationId: opId, idempotent: true });
+    }
+    if (existing.intent) {
+      if (existing.intent.subject !== subject || existing.intent.taskId !== taskId) {
+        return refuse(opId, "abandon-conflict");
+      }
+      return resumeCleanup({ deps, intent: existing.intent, opId });
+    }
+    const manifest = await readManifest(deps.repoRoot, taskId);
+    if (!manifest) return refuse(opId, "missing-manifest", { taskId });
+    const validated = await validateLiveAttempt({ deps, manifest, subject, opId });
+    if (!validated.ok) return validated;
+    const publishedIntent = await publishAbandonIntent(deps.repoRoot, validated.intent);
+    if (!publishedIntent.ok) return refuse(opId, publishedIntent.kind);
+    return resumeCleanup({ deps, intent: publishedIntent.record, opId });
+  };
+}
+
+// src/version.js
+import { readFileSync, existsSync as existsSync9 } from "node:fs";
+import { dirname as dirname4, resolve as resolve10 } from "node:path";
+import { fileURLToPath } from "node:url";
+var PACKAGE_VERSION = "1.1.8";
+var TEMPLATE_SET = `v${PACKAGE_VERSION}`;
 export {
   ADAPTER_CONTRACT_VERSION,
   ADAPTER_FILENAME,
@@ -2783,6 +3217,7 @@ export {
   bucketFor,
   canTransition,
   checkGates,
+  createAbandonTool,
   createCleanupTool,
   createGhDriver,
   createGhStub,