@seanyao/roll 4.703.2 → 4.706.1

package/dist/postinstall.mjs

@@ -0,0 +1,731 @@
+#!/usr/bin/env node
+import { createRequire as __rollCreateRequire } from 'node:module';
+import { fileURLToPath as __rollFileURLToPath } from 'node:url';
+import { dirname as __rollDirname } from 'node:path';
+const require = __rollCreateRequire(import.meta.url);
+const __filename = __rollFileURLToPath(import.meta.url);
+const __dirname = __rollDirname(__filename);
+
+// packages/cli/src/lib/roll-capture-install.ts
+import { spawnSync } from "node:child_process";
+import {
+  chmodSync,
+  existsSync,
+  lstatSync,
+  mkdirSync as mkdirSync2,
+  mkdtempSync,
+  readdirSync,
+  readFileSync as readFileSync2,
+  renameSync as renameSync2,
+  rmSync as rmSync2,
+  statSync as statSync2,
+  writeFileSync as writeFileSync2
+} from "node:fs";
+import { homedir } from "node:os";
+import { join as join2 } from "node:path";
+
+// packages/spec/dist/i18n/index.js
+function classifyLocale(raw) {
+  return raw.startsWith("zh") ? "zh" : "en";
+}
+function resolveLang(sources) {
+  for (const v of [
+    sources.rollLang,
+    sources.configLang,
+    sources.lcAll,
+    sources.lang,
+    sources.appleLang
+  ]) {
+    if (v !== void 0 && v !== "")
+      return classifyLocale(v);
+  }
+  return "en";
+}
+
+// packages/spec/dist/types/terminal.js
+var TERMINAL_SCHEMA_EPOCH_SEC = Date.UTC(2026, 5, 10, 17, 30) / 1e3;
+
+// packages/spec/dist/types/truth-registry.js
+var RUNNER = "cycle runner append_run (buildRunRow)";
+var BACKFILL = "merge-evidence backfill (runs-backfill, FIX-243)";
+var REBUILD_BACKFILL = "roll loop run-once post-cycle backfill / backfillMergedRuns";
+var TRUTH_FIELD_REGISTRY = [
+  // ── goal.yaml (US-GOAL-001) ────────────────────────────────────────────────
+  { field: "schema", surface: "goal", anchor: "goal_state", writer: "goal control plane", kind: "authoritative" },
+  { field: "scope", surface: "goal", anchor: "goal_state", writer: "goal control plane", kind: "authoritative" },
+  { field: "review", surface: "goal", anchor: "goal_state", writer: "goal control plane", kind: "authoritative" },
+  { field: "limits", surface: "goal", anchor: "goal_state", writer: "goal control plane", kind: "authoritative" },
+  { field: "status", surface: "goal", anchor: "goal_state", writer: "goal control plane; complete only by adjudication", kind: "authoritative" },
+  { field: "usage", surface: "goal", anchor: "goal_state", writer: "goal control plane from runs ledger", kind: "derived-cache", rebuild: "sum cycles/cost from scoped runs rows" },
+  { field: "createdAt", surface: "goal", anchor: "goal_state", writer: "goal control plane", kind: "authoritative" },
+  { field: "updatedAt", surface: "goal", anchor: "goal_state", writer: "goal control plane", kind: "authoritative" },
+  { field: "lastDecisionReason", surface: "goal", anchor: "goal_state", writer: "goal control plane / adjudicator", kind: "authoritative" },
+  // ── runs.jsonl row (cycle_outcome anchor's primary view) ───────────────────
+  { field: "run_id", surface: "runs", anchor: "cycle_outcome", writer: RUNNER, kind: "authoritative" },
+  { field: "cycle_id", surface: "runs", anchor: "cycle_outcome", writer: RUNNER, kind: "authoritative" },
+  { field: "story_id", surface: "runs", anchor: "cycle_outcome", writer: RUNNER, kind: "authoritative" },
+  { field: "status", surface: "runs", anchor: "cycle_outcome", writer: `${RUNNER}; corrected only by ${BACKFILL}`, kind: "authoritative" },
+  { field: "outcome", surface: "runs", anchor: "cycle_outcome", writer: `${RUNNER}; corrected only by ${BACKFILL}`, kind: "authoritative" },
+  { field: "failure_class", surface: "runs", anchor: "cycle_outcome", writer: RUNNER, kind: "authoritative" },
+  { field: "root_cause_key", surface: "runs", anchor: "cycle_outcome", writer: RUNNER, kind: "authoritative" },
+  { field: "agent", surface: "runs", anchor: "cycle_outcome", writer: RUNNER, kind: "authoritative" },
+  { field: "built", surface: "runs", anchor: "story_delivery", writer: RUNNER, kind: "derived-cache", rebuild: "re-derive from story_id + delivery truth (deriveStoryTruth)" },
+  { field: "tcr_count", surface: "runs", anchor: "tcr_evidence", writer: RUNNER, kind: "derived-cache", rebuild: "recount tcr: commits on the cycle branch" },
+  { field: "ts", surface: "runs", anchor: "cycle_outcome", writer: RUNNER, kind: "authoritative" },
+  { field: "duration_sec", surface: "runs", anchor: "cycle_outcome", writer: RUNNER, kind: "derived-cache", rebuild: "ended_at - started_at from the cycle:terminal twin" },
+  { field: "model", surface: "runs", anchor: "usage_cost", writer: RUNNER, kind: "derived-cache", rebuild: "re-extract from agent usage records (usage-recovery / stream parse)" },
+  { field: "tokens_in", surface: "runs", anchor: "usage_cost", writer: RUNNER, kind: "derived-cache", rebuild: "re-extract from agent usage records" },
+  { field: "tokens_out", surface: "runs", anchor: "usage_cost", writer: RUNNER, kind: "derived-cache", rebuild: "re-extract from agent usage records" },
+  { field: "tokens_cache_read", surface: "runs", anchor: "usage_cost", writer: RUNNER, kind: "derived-cache", rebuild: "re-extract from agent usage records" },
+  { field: "tokens_cache_write", surface: "runs", anchor: "usage_cost", writer: RUNNER, kind: "derived-cache", rebuild: "re-extract from agent usage records" },
+  { field: "cost_usd", surface: "runs", anchor: "usage_cost", writer: RUNNER, kind: "derived-cache", rebuild: "recompute from tokens via the price table (toCycleCost)" },
+  { field: "cost_effective_usd", surface: "runs", anchor: "usage_cost", writer: RUNNER, kind: "derived-cache", rebuild: "estimated \xD7 (reverts + 1) \u2014 toCycleCost" },
+  { field: "cost_currency", surface: "runs", anchor: "usage_cost", writer: RUNNER, kind: "derived-cache", rebuild: "resolve from model's price-table currency (currencyFor / cycleCurrency)" },
+  { field: "pr_number", surface: "runs", anchor: "pr_merge", writer: `${RUNNER}; corrected by ${BACKFILL}`, kind: "authoritative" },
+  { field: "pr_url", surface: "runs", anchor: "pr_merge", writer: `${RUNNER}; corrected by ${BACKFILL}`, kind: "authoritative" },
+  { field: "merged_at", surface: "runs", anchor: "pr_merge", writer: BACKFILL, kind: "derived-cache", rebuild: REBUILD_BACKFILL },
+  { field: "merge_commit", surface: "runs", anchor: "pr_merge", writer: BACKFILL, kind: "derived-cache", rebuild: REBUILD_BACKFILL },
+  // ── cycle:terminal event (US-TRUTH-001) ────────────────────────────────────
+  { field: "type", surface: "event:cycle:terminal", anchor: "cycle_outcome", writer: "buildTerminalEvent", kind: "authoritative" },
+  { field: "schema", surface: "event:cycle:terminal", anchor: "cycle_outcome", writer: "buildTerminalEvent", kind: "authoritative" },
+  { field: "cycleId", surface: "event:cycle:terminal", anchor: "cycle_outcome", writer: "buildTerminalEvent", kind: "authoritative" },
+  { field: "storyId", surface: "event:cycle:terminal", anchor: "cycle_outcome", writer: "buildTerminalEvent", kind: "authoritative" },
+  { field: "agent", surface: "event:cycle:terminal", anchor: "cycle_outcome", writer: "buildTerminalEvent", kind: "authoritative" },
+  // FIX-294: routed model is a dispatch-time fact (like agent) — authoritative,
+  // ALWAYS present even when usage couldn't be parsed; the `usage` fact below
+  // still owns the present-or-reasoned token/cost truth.
+  { field: "model", surface: "event:cycle:terminal", anchor: "cycle_outcome", writer: "buildTerminalEvent", kind: "authoritative" },
+  { field: "startedAt", surface: "event:cycle:terminal", anchor: "cycle_outcome", writer: "buildTerminalEvent", kind: "authoritative" },
+  { field: "endedAt", surface: "event:cycle:terminal", anchor: "cycle_outcome", writer: "buildTerminalEvent", kind: "authoritative" },
+  { field: "outcome", surface: "event:cycle:terminal", anchor: "cycle_outcome", writer: "buildTerminalEvent", kind: "authoritative" },
+  { field: "failure_class", surface: "event:cycle:terminal", anchor: "cycle_outcome", writer: "buildTerminalEvent", kind: "authoritative" },
+  { field: "root_cause_key", surface: "event:cycle:terminal", anchor: "cycle_outcome", writer: "buildTerminalEvent", kind: "authoritative" },
+  { field: "pr", surface: "event:cycle:terminal", anchor: "pr_merge", writer: "buildTerminalEvent", kind: "derived-cache", rebuild: "gh pr view on the cycle branch" },
+  { field: "branch", surface: "event:cycle:terminal", anchor: "cycle_outcome", writer: "buildTerminalEvent", kind: "authoritative" },
+  { field: "commit", surface: "event:cycle:terminal", anchor: "tcr_evidence", writer: "buildTerminalEvent", kind: "derived-cache", rebuild: "git rev-parse on the cycle branch" },
+  { field: "tcr", surface: "event:cycle:terminal", anchor: "tcr_evidence", writer: "buildTerminalEvent", kind: "derived-cache", rebuild: "recount tcr: commits on the cycle branch" },
+  { field: "attest", surface: "event:cycle:terminal", anchor: "attest_evidence", writer: "buildTerminalEvent", kind: "derived-cache", rebuild: "probe the card archive (report + ac-map existence)" },
+  { field: "usage", surface: "event:cycle:terminal", anchor: "usage_cost", writer: "buildTerminalEvent", kind: "derived-cache", rebuild: "re-extract from agent usage records" },
+  { field: "cost", surface: "event:cycle:terminal", anchor: "usage_cost", writer: "buildTerminalEvent", kind: "derived-cache", rebuild: "recompute from tokens via the price table" },
+  { field: "ts", surface: "event:cycle:terminal", anchor: "cycle_outcome", writer: "buildTerminalEvent", kind: "authoritative" },
+  // ── delivery record (US-TRUTH-013) ───────────────────────────────────────
+  { field: "storyId", surface: "delivery", anchor: "story_delivery", writer: "cycle runner buildDeliveryRecord", kind: "authoritative" },
+  { field: "cycleId", surface: "delivery", anchor: "cycle_outcome", writer: "cycle runner buildDeliveryRecord", kind: "authoritative" },
+  { field: "lifecycleState", surface: "delivery", anchor: "story_delivery", writer: "cycle runner buildDeliveryRecord", kind: "authoritative" },
+  { field: "prNumber", surface: "delivery", anchor: "pr_merge", writer: "cycle runner buildDeliveryRecord", kind: "authoritative" },
+  { field: "prUrl", surface: "delivery", anchor: "pr_merge", writer: "cycle runner buildDeliveryRecord", kind: "authoritative" },
+  { field: "mergedAt", surface: "delivery", anchor: "pr_merge", writer: "cycle runner buildDeliveryRecord", kind: "authoritative" },
+  { field: "mergeCommit", surface: "delivery", anchor: "pr_merge", writer: "cycle runner buildDeliveryRecord", kind: "authoritative" },
+  { field: "recordedAt", surface: "delivery", anchor: "story_delivery", writer: "cycle runner buildDeliveryRecord", kind: "authoritative" },
+  // ── release records (US-TRUTH-005) ────────────────────────────────────────
+  { field: "type", surface: "event:release:gate", anchor: "release_verdict", writer: "release ship recordGate", kind: "authoritative" },
+  { field: "tag", surface: "event:release:gate", anchor: "release_verdict", writer: "release ship recordGate", kind: "authoritative" },
+  { field: "verdict", surface: "event:release:gate", anchor: "release_verdict", writer: "release ship recordGate", kind: "authoritative" },
+  { field: "failCount", surface: "event:release:gate", anchor: "release_verdict", writer: "release ship recordGate", kind: "authoritative" },
+  { field: "waivedRules", surface: "event:release:gate", anchor: "release_waiver", writer: "release ship recordGate", kind: "derived-cache", rebuild: "re-join gate findings with live waivers (decideReleaseGate)" },
+  { field: "ts", surface: "event:release:gate", anchor: "release_verdict", writer: "release ship recordGate", kind: "authoritative" },
+  { field: "type", surface: "event:release:waiver", anchor: "release_waiver", writer: "(retired US-REL-007 \u2014 historical release:waiver events only; no writer remains)", kind: "authoritative" },
+  { field: "reason", surface: "event:release:waiver", anchor: "release_waiver", writer: "(retired US-REL-007 \u2014 historical release:waiver events only; no writer remains)", kind: "authoritative" },
+  { field: "scope", surface: "event:release:waiver", anchor: "release_waiver", writer: "(retired US-REL-007 \u2014 historical release:waiver events only; no writer remains)", kind: "authoritative" },
+  { field: "expiresSec", surface: "event:release:waiver", anchor: "release_waiver", writer: "(retired US-REL-007 \u2014 historical release:waiver events only; no writer remains)", kind: "authoritative" },
+  { field: "operator", surface: "event:release:waiver", anchor: "release_waiver", writer: "(retired US-REL-007 \u2014 historical release:waiver events only; no writer remains)", kind: "authoritative" },
+  { field: "ts", surface: "event:release:waiver", anchor: "release_waiver", writer: "(retired US-REL-007 \u2014 historical release:waiver events only; no writer remains)", kind: "authoritative" }
+];
+
+// packages/spec/dist/types/story.js
+var STATUS_MARKER = {
+  todo: "\u{1F4CB} Todo",
+  in_progress: "\u{1F528} In Progress",
+  done: "\u2705 Done",
+  hold: "\u{1F6AB} Hold",
+  cut: "\u{1F5D1}\uFE0F Cut"
+};
+var AWAITING_REVIEW_STATUS_MARKER = "\u23F3 \u5F85\u590D\u8BC4";
+var LEGACY_STATUS_MARKERS = [
+  { marker: "\u2714\uFE0F Done", status: "done" },
+  { marker: "\u{1F6A7} WIP", status: "in_progress" },
+  { marker: "\u{1F504} In Progress", status: "in_progress" },
+  { marker: "\u23F3 Hold", status: "hold" },
+  { marker: "\u{1F512} Blocked", status: "hold" },
+  { marker: "\u23F8 Deferred", status: "hold" }
+];
+var STATUS_MARKER_ALTERNATIVES = [
+  // Canonical first (these are what writers emit), then legacy aliases.
+  { marker: STATUS_MARKER.done, status: "done" },
+  { marker: STATUS_MARKER.in_progress, status: "in_progress" },
+  { marker: STATUS_MARKER.hold, status: "hold" },
+  { marker: STATUS_MARKER.cut, status: "cut" },
+  { marker: STATUS_MARKER.todo, status: "todo" },
+  { marker: AWAITING_REVIEW_STATUS_MARKER, status: "todo" },
+  ...LEGACY_STATUS_MARKERS
+];
+function markerToPattern(marker) {
+  return marker.split(/\s+/).map((part) => part.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join(" *");
+}
+var STATUS_MARKER_RE_SOURCE = `(${STATUS_MARKER_ALTERNATIVES.map((a) => markerToPattern(a.marker)).join("|")})`;
+function statusMarkerRe(global = false) {
+  return new RegExp(STATUS_MARKER_RE_SOURCE, global ? "g" : void 0);
+}
+var STATUS_MARKER_RE = statusMarkerRe(false);
+
+// packages/spec/dist/types/capture.js
+var ROLL_CAPTURE_PROTOCOL_V1 = "roll.capture.v1";
+var ROLL_CAPTURE_PROVIDER = "roll-capture";
+var ROLL_CAPTURE_PLATFORM = "darwin";
+var ROLL_CAPTURE_HOST_APP_NAME = "Roll Capture.app";
+var ROLL_CAPTURE_HOST_BUNDLE_ID = "com.seanyao.roll.capture";
+var stringSchema = { type: "string" };
+var nonEmptyStringSchema = { type: "string", minLength: 1 };
+var integerSchema = { type: "integer" };
+var booleanSchema = { type: "boolean" };
+var numberSchema = { type: "number" };
+function objectSchema(properties, required = []) {
+  return { type: "object", properties, required, additionalProperties: false };
+}
+var captureKindSchema = { type: "string", enum: ["web", "terminal", "physical_terminal", "region", "display"] };
+var captureStatusSchema = { type: "string", enum: ["taken", "skipped", "failed"] };
+var captureTargetSchema = {
+  oneOf: [
+    objectSchema({ type: { const: "window" }, appName: nonEmptyStringSchema, windowTitle: stringSchema }, ["type", "appName"]),
+    objectSchema({ type: { const: "region" }, x: integerSchema, y: integerSchema, width: integerSchema, height: integerSchema }, ["type", "x", "y", "width", "height"]),
+    objectSchema({ type: { const: "display" }, displayId: stringSchema }, ["type"])
+  ]
+};
+var captureHostSchema = objectSchema({
+  appName: { const: ROLL_CAPTURE_HOST_APP_NAME },
+  bundleId: { const: ROLL_CAPTURE_HOST_BUNDLE_ID },
+  version: nonEmptyStringSchema
+}, ["appName", "bundleId", "version"]);
+var rollCaptureRequestV1Schema = objectSchema({
+  protocol: { const: ROLL_CAPTURE_PROTOCOL_V1 },
+  requestId: nonEmptyStringSchema,
+  storyId: stringSchema,
+  runId: stringSchema,
+  kind: captureKindSchema,
+  target: captureTargetSchema,
+  out: nonEmptyStringSchema,
+  timeoutMs: integerSchema,
+  createdAt: nonEmptyStringSchema
+}, ["protocol", "requestId", "kind", "target", "out", "timeoutMs", "createdAt"]);
+var captureResponseProperties = {
+  protocol: { const: ROLL_CAPTURE_PROTOCOL_V1 },
+  requestId: nonEmptyStringSchema,
+  screenshotPath: stringSchema,
+  responsePath: nonEmptyStringSchema,
+  reason: stringSchema,
+  imageWidth: integerSchema,
+  imageHeight: integerSchema,
+  host: captureHostSchema,
+  startedAt: nonEmptyStringSchema,
+  finishedAt: nonEmptyStringSchema
+};
+var captureResponseRequired = ["protocol", "requestId", "status", "responsePath", "host", "startedAt", "finishedAt"];
+var rollCaptureResponseV1Schema = {
+  oneOf: [
+    objectSchema({ ...captureResponseProperties, status: { const: "taken" } }, [...captureResponseRequired, "screenshotPath"]),
+    objectSchema({ ...captureResponseProperties, status: { const: "skipped" } }, [...captureResponseRequired, "reason"]),
+    objectSchema({ ...captureResponseProperties, status: { const: "failed" } }, [...captureResponseRequired, "reason"])
+  ]
+};
+var captureLedgerEntrySchema = objectSchema({
+  requestId: nonEmptyStringSchema,
+  storyId: stringSchema,
+  runId: stringSchema,
+  kind: captureKindSchema,
+  status: captureStatusSchema,
+  screenshotPath: stringSchema,
+  responsePath: nonEmptyStringSchema,
+  reportPath: stringSchema,
+  attachedToReport: booleanSchema,
+  reason: stringSchema,
+  startedAt: nonEmptyStringSchema,
+  finishedAt: nonEmptyStringSchema
+}, ["requestId", "status", "responsePath", "attachedToReport", "startedAt", "finishedAt"]);
+var rollCaptureToolOutputSchema = toolResultSchema(objectSchema({
+  status: { type: "string", enum: ["taken", "skipped", "failed", "timeout"] },
+  path: stringSchema,
+  reason: stringSchema,
+  response: rollCaptureResponseV1Schema
+}, ["status"]));
+var physicalScreenshotToolInputSchema = {
+  title: "Roll Capture request",
+  oneOf: [rollCaptureRequestV1Schema]
+};
+var PHYSICAL_SCREENSHOT_TOOL_CONTRACT = {
+  id: "physical.screenshot",
+  kind: "physical",
+  title: "Physical Screenshot",
+  description: "Request real physical screen pixels through Roll Capture.app.",
+  provider: ROLL_CAPTURE_PROVIDER,
+  protocol: ROLL_CAPTURE_PROTOCOL_V1,
+  platform: ROLL_CAPTURE_PLATFORM,
+  defaults: {
+    enabled: true,
+    timeoutMs: 6e4,
+    sandbox: { maxOutputBytes: 2 * 1024 * 1024 }
+  },
+  requirements: [{ kind: "service", name: "roll-capture-app", optional: false }],
+  inputSchema: physicalScreenshotToolInputSchema,
+  outputSchema: rollCaptureToolOutputSchema
+};
+function toolResultSchema(output) {
+  const meta = objectSchema({
+    invocationId: stringSchema,
+    toolId: stringSchema,
+    caller: { type: "object", additionalProperties: true },
+    startedAt: numberSchema,
+    endedAt: numberSchema,
+    durationMs: numberSchema,
+    attempt: integerSchema
+  }, ["invocationId", "toolId", "caller", "startedAt", "endedAt", "durationMs"]);
+  const error = objectSchema({
+    code: { type: "string", enum: ["not_found", "init_failed", "policy_denied", "budget_exhausted", "sandbox_denied", "timeout", "adapter_error", "invalid_input", "unknown"] },
+    message: stringSchema,
+    retryable: booleanSchema,
+    detail: true
+  }, ["code", "message", "retryable"]);
+  return {
+    oneOf: [
+      objectSchema({ ok: { const: true }, output, meta, warnings: { type: "array", items: stringSchema } }, ["ok", "output", "meta"]),
+      objectSchema({ ok: { const: false }, error, meta, warnings: { type: "array", items: stringSchema } }, ["ok", "error", "meta"])
+    ]
+  };
+}
+
+// packages/cli/src/lib/roll-capture-readiness.ts
+import { mkdirSync, readFileSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+var APP_NAME = "Roll Capture.app";
+var ROLL_CAPTURE_POSITIVE_READINESS_TTL_MS = 30 * 60 * 1e3;
+var ROLL_CAPTURE_NEGATIVE_READINESS_TTL_MS = 60 * 1e3;
+function detectCanonicalRollCaptureInstall(deps) {
+  for (const candidate of [join(deps.home, "Applications", APP_NAME), join("/Applications", APP_NAME)]) {
+    if (deps.exists(candidate)) return { status: "installed", path: candidate };
+  }
+  return { status: "missing" };
+}
+function rollCaptureReadinessCachePath(deps) {
+  const rollHome = (deps.env["ROLL_HOME"] ?? "").trim() || join(deps.home, ".roll");
+  return join(rollHome, "cache", "roll-capture-readiness.json");
+}
+function invalidateRollCaptureReadinessCache(deps) {
+  rmSync(rollCaptureReadinessCachePath(deps), { force: true });
+}
+
+// packages/cli/src/lib/roll-capture-install.ts
+var RELEASE_API = "https://api.github.com/repos/seanyao/roll-capture/releases/latest";
+var ASSET_NAME = "Roll-Capture.app.zip";
+var APP_NAME2 = "Roll Capture.app";
+var DOWNLOAD_TIMEOUT_MS = 6e4;
+var UPDATE_HINT_TIMEOUT_MS = 1500;
+var GH_AUTH_TOKEN_TIMEOUT_MS = 5e3;
+var ROOT_INSTALL_SKIP_REASON = "run roll setup as a regular user to install Roll Capture.app";
+function defaultRollCaptureInstallDeps() {
+  const platform = externalPlatformOverride(process.env["_ROLL_EXTERNAL_TOOLS_PLATFORM"]) ?? process.platform;
+  const execFile = (cmd, args, opts) => {
+    const r = spawnSync(cmd, [...args], {
+      cwd: opts?.cwd,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "pipe"],
+      timeout: opts?.timeoutMs ?? 15e3
+    });
+    return { code: r.status ?? 1, stdout: r.stdout ?? "", stderr: r.stderr ?? "" };
+  };
+  return {
+    platform,
+    env: process.env,
+    home: homedir(),
+    uid: typeof process.getuid === "function" ? process.getuid() : void 0,
+    ...platform === "darwin" && !isCi(process.env) && process.env["ROLL_SKIP_CAPTURE_INSTALL"] !== "1" ? { hasAquaGUI: macosHasAquaGUI(execFile) } : {},
+    exists: existsSync,
+    renamePath: renameSync2,
+    execFile,
+    fetchLatestRelease: (timeoutMs) => defaultFetchLatestRelease(timeoutMs, process.env, execFile),
+    downloadAsset: (asset, timeoutMs) => defaultDownloadAsset(asset, timeoutMs, process.env, execFile),
+    extractZip: async (zipPath, destination, timeoutMs) => extractZip(zipPath, destination, execFile, timeoutMs)
+  };
+}
+async function installRollCapture(deps = defaultRollCaptureInstallDeps()) {
+  const gate = installGate(deps);
+  if (gate !== null) return gate;
+  const installed = detectCanonicalRollCaptureInstall(deps);
+  if (installed.status === "installed") {
+    const appPath = installed.path;
+    invalidateRollCaptureReadinessCache(deps);
+    const installedVersion = appPath === void 0 ? void 0 : readInstalledVersion(appPath, deps);
+    const update = await latestReleaseHint(deps, installedVersion);
+    return {
+      status: "already-installed",
+      reason: "installed",
+      ...appPath !== void 0 ? { appPath } : {},
+      ...installedVersion !== void 0 ? { installedVersion } : {},
+      ...update.releaseTag !== void 0 ? { releaseTag: update.releaseTag } : {},
+      updateAvailable: update.updateAvailable
+    };
+  }
+  const deadlineMs = Date.now() + DOWNLOAD_TIMEOUT_MS;
+  const remainingMs = () => Math.max(1, deadlineMs - Date.now());
+  let release;
+  try {
+    release = await deps.fetchLatestRelease(remainingMs());
+  } catch (error) {
+    return manual(`release lookup failed: ${errorMessage(error)}`);
+  }
+  const asset = release.assets.find((candidate) => candidate.name === ASSET_NAME);
+  if (asset === void 0) return manual(`latest release has no ${ASSET_NAME} asset`);
+  let bytes;
+  try {
+    bytes = await deps.downloadAsset(asset, remainingMs());
+  } catch (error) {
+    return manual(`download failed: ${errorMessage(error)}`, release.tagName);
+  }
+  if (bytes.byteLength !== asset.size) {
+    return manual(`download size mismatch: expected ${asset.size} bytes, got ${bytes.byteLength}`, release.tagName);
+  }
+  const applicationsDir = join2(deps.home, "Applications");
+  const targetApp = join2(applicationsDir, APP_NAME2);
+  mkdirSync2(applicationsDir, { recursive: true });
+  const workDir = mkdtempSync(join2(applicationsDir, ".roll-capture-install-"));
+  const zipPath = join2(workDir, ASSET_NAME);
+  const extractDir = join2(workDir, "extract");
+  try {
+    mkdirSync2(extractDir, { recursive: true });
+    writeFileSync2(zipPath, bytes);
+    const extracted = await deps.extractZip(zipPath, extractDir, remainingMs());
+    if (!extracted.ok) return manual(extracted.detail, release.tagName);
+    const app = findExtractedApp(extractDir);
+    if (app === null) return manual("zip did not contain Roll Capture.app", release.tagName);
+    const executable = findBundleExecutable(app);
+    if (executable === null) return manual("Roll Capture.app has no executable in Contents/MacOS", release.tagName);
+    chmodSync(executable, statSync2(executable).mode | 73);
+    replaceAppAtomically(app, targetApp, deps);
+    invalidateRollCaptureReadinessCache(deps);
+    return { status: "installed", reason: "installed", appPath: targetApp, releaseTag: release.tagName };
+  } catch (error) {
+    return manual(`install failed: ${errorMessage(error)}`, release.tagName);
+  } finally {
+    rmSync2(workDir, { recursive: true, force: true });
+  }
+}
+function renderRollCaptureInstallResult(result, lang) {
+  if (lang === "zh") return renderZh(result);
+  return renderEn(result);
+}
+async function runRollCapturePostinstall(opts) {
+  const writeLine = opts?.writeLine ?? ((line) => process.stdout.write(`${line}
+`));
+  const lang = opts?.lang ?? resolveLang({ rollLang: process.env["ROLL_LANG"], lcAll: process.env["LC_ALL"], lang: process.env["LANG"] });
+  try {
+    const result = await installRollCapture(opts?.deps);
+    writeLine(renderRollCaptureInstallResult(result, lang));
+  } catch (error) {
+    writeLine(lang === "zh" ? `Roll Capture.app \u5B89\u88C5\u8DF3\u8FC7\uFF1A${errorMessage(error)}` : `Roll Capture.app install skipped: ${errorMessage(error)}`);
+  }
+  return 0;
+}
+async function defaultFetchLatestRelease(timeoutMs, env, execFile, fetchImpl = fetch, createProxyDispatcher = defaultProxyDispatcher) {
+  const response = await fetchImpl(
+    RELEASE_API,
+    await withProxyDispatcher(
+      {
+        headers: { Accept: "application/vnd.github+json", "User-Agent": "@seanyao/roll" },
+        signal: AbortSignal.timeout(timeoutMs)
+      },
+      env,
+      createProxyDispatcher
+    )
+  );
+  if (response.ok) return parseRelease(await response.json());
+  if (!isAuthRetryableStatus(response.status)) throw new Error(`GitHub release API returned ${response.status}`);
+  for (const credential of credentialFallbacks(env, execFile)) {
+    const authed = await fetchImpl(
+      RELEASE_API,
+      await withProxyDispatcher(
+        {
+          headers: { Accept: "application/vnd.github+json", Authorization: `Bearer ${credential.token}`, "User-Agent": "@seanyao/roll" },
+          signal: AbortSignal.timeout(timeoutMs)
+        },
+        env,
+        createProxyDispatcher
+      )
+    );
+    if (authed.ok) return parseRelease(await authed.json());
+    if (!isAuthRetryableStatus(authed.status)) throw new Error(`GitHub release API returned ${authed.status}`);
+  }
+  throw new Error(`GitHub release API returned ${response.status}`);
+}
+async function defaultDownloadAsset(asset, timeoutMs, env, execFile, fetchImpl = fetch, createProxyDispatcher = defaultProxyDispatcher) {
+  const response = await fetchImpl(
+    asset.browserDownloadUrl,
+    await withProxyDispatcher(
+      {
+        headers: { "User-Agent": "@seanyao/roll" },
+        redirect: "follow",
+        signal: AbortSignal.timeout(timeoutMs)
+      },
+      env,
+      createProxyDispatcher
+    )
+  );
+  if (response.ok) return new Uint8Array(await response.arrayBuffer());
+  if (!isAuthRetryableStatus(response.status)) throw new Error(`asset download returned ${response.status}`);
+  if (asset.apiUrl === void 0 || asset.apiUrl === "") throw new Error("asset API URL missing for authenticated download");
+  for (const credential of credentialFallbacks(env, execFile)) {
+    const authed = await fetchImpl(
+      asset.apiUrl,
+      await withProxyDispatcher(
+        {
+          headers: { Accept: "application/octet-stream", Authorization: `Bearer ${credential.token}`, "User-Agent": "@seanyao/roll" },
+          redirect: "follow",
+          signal: AbortSignal.timeout(timeoutMs)
+        },
+        env,
+        createProxyDispatcher
+      )
+    );
+    if (authed.ok) return new Uint8Array(await authed.arrayBuffer());
+    if (!isAuthRetryableStatus(authed.status)) throw new Error(`asset download returned ${authed.status}`);
+  }
+  throw new Error(`asset download returned ${response.status}`);
+}
+function parseRelease(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) throw new Error("release JSON is not an object");
+  const row = value;
+  const tagName = typeof row["tag_name"] === "string" ? row["tag_name"] : "";
+  const rawAssets = Array.isArray(row["assets"]) ? row["assets"] : [];
+  const assets = rawAssets.flatMap((raw) => {
+    if (typeof raw !== "object" || raw === null || Array.isArray(raw)) return [];
+    const asset = raw;
+    const name = typeof asset["name"] === "string" ? asset["name"] : "";
+    const apiUrl = typeof asset["url"] === "string" ? asset["url"] : "";
+    const browserDownloadUrl = typeof asset["browser_download_url"] === "string" ? asset["browser_download_url"] : "";
+    const size = typeof asset["size"] === "number" ? asset["size"] : Number.NaN;
+    return name !== "" && browserDownloadUrl !== "" && Number.isFinite(size) ? [{ name, browserDownloadUrl, size, ...apiUrl !== "" ? { apiUrl } : {} }] : [];
+  });
+  return { tagName, assets };
+}
+function isAuthRetryableStatus(status) {
+  return status === 401 || status === 404;
+}
+function* credentialFallbacks(env, execFile) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const key of ["GITHUB_TOKEN", "GH_TOKEN"]) {
+    const token = (env[key] ?? "").trim();
+    if (token !== "" && !seen.has(token)) {
+      seen.add(token);
+      yield { token };
+    }
+  }
+  const gh = ghAuthToken(execFile);
+  if (gh !== null && !seen.has(gh)) yield { token: gh };
+}
+function ghAuthToken(execFile) {
+  try {
+    const result = execFile("gh", ["auth", "token"], { timeoutMs: GH_AUTH_TOKEN_TIMEOUT_MS });
+    const token = result.code === 0 ? result.stdout.trim() : "";
+    return isUsableGhAuthToken(token) ? token : null;
+  } catch {
+    return null;
+  }
+}
+function isUsableGhAuthToken(token) {
+  return token.length >= 20 && token.length <= 512 && !/\s/.test(token);
+}
+async function extractZip(zipPath, destination, execFile, timeoutMs) {
+  const ditto = execFile("ditto", ["-x", "-k", zipPath, destination], { timeoutMs });
+  if (ditto.code === 0) return { ok: true };
+  const unzip = execFile("unzip", ["-q", zipPath, "-d", destination], { timeoutMs });
+  if (unzip.code === 0) return { ok: true };
+  const detail = [ditto.stderr.trim(), unzip.stderr.trim()].filter((line) => line !== "").join("; ");
+  return { ok: false, detail: detail === "" ? "zip extraction failed" : detail };
+}
+function installGate(deps) {
+  if (deps.platform !== "darwin") return { status: "skipped", reason: "non-darwin" };
+  if (skipInstallEnv(deps.env)) return { status: "skipped", reason: "disabled" };
+  if (deps.uid === 0 || (deps.env["SUDO_USER"] ?? "").trim() !== "") {
+    return { status: "skipped", reason: ROOT_INSTALL_SKIP_REASON };
+  }
+  if (isCi(deps.env)) return { status: "skipped", reason: "ci" };
+  if (deps.hasAquaGUI === false) return { status: "skipped", reason: "headless" };
+  return null;
+}
+function skipInstallEnv(env) {
+  return env["ROLL_SKIP_CAPTURE_INSTALL"] === "1" || env["npm_config_roll_skip_capture_install"] === "1" || env["ROLL_NO_SCREENCAP"] === "1";
+}
+function isCi(env) {
+  return (env["CI"] ?? "").trim() !== "" || (env["GITHUB_ACTIONS"] ?? "").trim() !== "" || (env["GITLAB_CI"] ?? "").trim() !== "" || (env["JENKINS_HOME"] ?? "").trim() !== "";
+}
+function macosHasAquaGUI(execFile) {
+  const r = execFile("launchctl", ["managername"]);
+  return r.code === 0 && r.stdout.includes("Aqua");
+}
+function findExtractedApp(dir) {
+  try {
+    for (const name of readdirSync(dir)) {
+      const candidate = join2(dir, name);
+      const st = lstatSync(candidate);
+      if (st.isSymbolicLink()) continue;
+      if (st.isDirectory() && name === APP_NAME2) return candidate;
+      if (st.isDirectory()) {
+        const nested = findExtractedApp(candidate);
+        if (nested !== null) return nested;
+      }
+    }
+  } catch {
+    return null;
+  }
+  return null;
+}
+function findBundleExecutable(appPath) {
+  const macosDir = join2(appPath, "Contents", "MacOS");
+  try {
+    for (const name of readdirSync(macosDir)) {
+      const candidate = join2(macosDir, name);
+      const st = lstatSync(candidate);
+      if (st.isSymbolicLink()) continue;
+      if (st.isFile()) return candidate;
+    }
+  } catch {
+    return null;
+  }
+  return null;
+}
+function replaceAppAtomically(app, targetApp, deps) {
+  const renamePath = deps.renamePath ?? renameSync2;
+  const backupApp = `${targetApp}.bak`;
+  const hadExisting = lstatExists(targetApp);
+  rmSync2(backupApp, { recursive: true, force: true });
+  if (!hadExisting) {
+    renamePath(app, targetApp);
+    return;
+  }
+  let backupCreated = false;
+  let targetReplaced = false;
+  try {
+    renamePath(targetApp, backupApp);
+    backupCreated = true;
+    renamePath(app, targetApp);
+    targetReplaced = true;
+    rmSync2(backupApp, { recursive: true, force: true });
+  } catch (error) {
+    if (targetReplaced) rmSync2(targetApp, { recursive: true, force: true });
+    if (backupCreated) {
+      try {
+        renamePath(backupApp, targetApp);
+      } catch {
+      }
+    }
+    throw error;
+  }
+}
+function lstatExists(path) {
+  try {
+    lstatSync(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function withProxyDispatcher(init, env, createProxyDispatcher) {
+  if (!hasProxyEnv(env)) return init;
+  const dispatcher = await createProxyDispatcher(env);
+  return dispatcher === void 0 || dispatcher === null ? init : { ...init, dispatcher };
+}
+function hasProxyEnv(env) {
+  return ["HTTP_PROXY", "HTTPS_PROXY", "ALL_PROXY", "http_proxy", "https_proxy", "all_proxy"].some((key) => (env[key] ?? "").trim() !== "");
+}
+async function defaultProxyDispatcher(_env) {
+  try {
+    const imported = await optionalImport("undici");
+    if (typeof imported.EnvHttpProxyAgent === "function") return new imported.EnvHttpProxyAgent();
+    enableNodeGlobalProxyFromEnv(_env);
+    return void 0;
+  } catch {
+    enableNodeGlobalProxyFromEnv(_env);
+    return void 0;
+  }
+}
+var optionalImport = new Function("specifier", "return import(specifier)");
+function enableNodeGlobalProxyFromEnv(env) {
+  const getBuiltinModule = process.getBuiltinModule;
+  const http = getBuiltinModule?.("node:http") ?? getBuiltinModule?.("http");
+  const setGlobalProxyFromEnv = isRecord(http) ? http["setGlobalProxyFromEnv"] : void 0;
+  if (typeof setGlobalProxyFromEnv !== "function") return;
+  try {
+    setGlobalProxyFromEnv(env);
+  } catch {
+  }
+}
+function readInstalledVersion(appPath, deps) {
+  const plistPath = join2(appPath, "Contents", "Info.plist");
+  const plutil = deps.execFile("plutil", ["-extract", "CFBundleShortVersionString", "raw", "-o", "-", plistPath]);
+  const raw = plutil.code === 0 ? plutil.stdout.trim() : "";
+  if (raw !== "") return raw;
+  try {
+    const text = readFileSync2(plistPath, "utf8");
+    const match = /<key>CFBundleShortVersionString<\/key>\s*<string>([^<]+)<\/string>/.exec(text);
+    return match?.[1];
+  } catch {
+    return void 0;
+  }
+}
+async function latestReleaseHint(deps, installedVersion) {
+  try {
+    const release = await deps.fetchLatestRelease(UPDATE_HINT_TIMEOUT_MS);
+    const latest = normalizeVersion(release.tagName);
+    const installed = normalizeVersion(installedVersion ?? "");
+    return {
+      releaseTag: release.tagName,
+      updateAvailable: latest !== "" && installed !== "" && latest !== installed
+    };
+  } catch {
+    return {};
+  }
+}
+function normalizeVersion(value) {
+  return value.trim().replace(/^v/i, "");
+}
+function manual(reason, releaseTag) {
+  return { status: "manual", reason, ...releaseTag !== void 0 ? { releaseTag } : {} };
+}
+function renderEn(result) {
+  if (result.status === "installed") {
+    return `Roll Capture.app installed at ${result.appPath ?? join2("~", "Applications", APP_NAME2)}; open it once and grant Screen Recording permission.`;
+  }
+  if (result.status === "already-installed") {
+    const update = result.updateAvailable === true && result.releaseTag !== void 0 ? `; newer release ${result.releaseTag} is available` : "";
+    return `Roll Capture.app already installed at ${result.appPath ?? "(detected)"}${update}.`;
+  }
+  if (result.status === "skipped") return `Roll Capture.app install skipped (${result.reason}).`;
+  return `Roll Capture.app automatic install failed (${result.reason}); install it manually, then open it once and grant Screen Recording permission.`;
+}
+function renderZh(result) {
+  if (result.status === "installed") {
+    return `Roll Capture.app \u5DF2\u5B89\u88C5\u5230 ${result.appPath ?? join2("~", "Applications", APP_NAME2)}\uFF1B\u8BF7\u6253\u5F00\u4E00\u6B21\u5E76\u6388\u4E88\u5C4F\u5E55\u5F55\u5236\u6743\u9650\u3002`;
+  }
+  if (result.status === "already-installed") {
+    const update = result.updateAvailable === true && result.releaseTag !== void 0 ? `\uFF1B\u6709\u65B0\u7248 ${result.releaseTag} \u53EF\u7528` : "";
+    return `Roll Capture.app \u5DF2\u5B89\u88C5\uFF1A${result.appPath ?? "\u5DF2\u68C0\u6D4B\u5230"}${update}\u3002`;
+  }
+  if (result.status === "skipped") return `Roll Capture.app \u5B89\u88C5\u5DF2\u8DF3\u8FC7\uFF08${renderZhReason(result.reason)}\uFF09\u3002`;
+  return `Roll Capture.app \u81EA\u52A8\u5B89\u88C5\u5931\u8D25\uFF08${result.reason}\uFF09\uFF1B\u8BF7\u624B\u52A8\u5B89\u88C5\uFF0C\u6253\u5F00\u4E00\u6B21\u5E76\u6388\u4E88\u5C4F\u5E55\u5F55\u5236\u6743\u9650\u3002`;
+}
+function renderZhReason(reason) {
+  if (reason === ROOT_INSTALL_SKIP_REASON) return "\u8BF7\u4EE5\u666E\u901A\u7528\u6237\u8FD0\u884C roll setup \u5B89\u88C5";
+  return reason;
+}
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function externalPlatformOverride(raw) {
+  if (raw === "aix" || raw === "android" || raw === "darwin" || raw === "freebsd" || raw === "haiku" || raw === "linux" || raw === "openbsd" || raw === "sunos" || raw === "win32" || raw === "cygwin" || raw === "netbsd") {
+    return raw;
+  }
+  return void 0;
+}
+
+// packages/cli/bin/postinstall.js
+await runRollCapturePostinstall();