agent-control-plane 0.1.2 → 0.1.3

package/README.md

@@ -302,6 +302,9 @@ During `setup`, ACP can:
   `openclaw` when ACP knows a safe install command, and otherwise show
   backend-specific next steps, install/auth/verify examples, and a docs URL it
   can open for you on interactive machines
+- defer anchor repo sync automatically when ACP can scaffold the profile but
+  cannot reach the repo remote yet, so setup can still finish with a clear
+  follow-up instead of failing half way through
 - run one final fix-up summary at the end so you can clear whatever is still
   red instead of guessing which step to retry next
 - scaffold the profile, run doctor checks, and optionally start the runtime in
@@ -550,6 +553,9 @@ Use `--purge-paths` only when you want ACP-managed directories removed too.
   `launchd-uninstall`, and `remove`.
 - `gh` cannot access the repo
   Re-run `gh auth login` and confirm the repo slug in the profile is correct.
+- setup deferred anchor repo sync
+  ACP could not reach the repo remote yet. Fix Git access or the remote URL,
+  then rerun `setup` or `init` without `--skip-anchor-sync`.
 - backend auth failures from `codex`, `claude`, or `openclaw`
   Authenticate that backend before starting ACP in the background.
 - `node` is older than `18`

package/npm/bin/agent-control-plane.js

@@ -191,12 +191,14 @@ function runCapture(command, args, options = {}) {
   const result = spawnSync(command, args, {
     encoding: "utf8",
     env: options.env || process.env,
-    cwd: options.cwd || process.cwd()
+    cwd: options.cwd || process.cwd(),
+    timeout: options.timeoutMs || 0
   });
   return {
     status: typeof result.status === "number" ? result.status : (result.error ? 1 : 0),
     stdout: result.stdout || "",
-    stderr: result.stderr || ""
+    stderr: result.stderr || "",
+    error: result.error || null
   };
 }
 
@@ -1044,6 +1046,92 @@ function printPrereqSummary(prereq) {
   console.log(`- backend note: ${backendReadinessHint(prereq.workerCommand)}`);
 }
 
+function probeAnchorSyncReadiness(repoRoot) {
+  if (!repoRoot || !fs.existsSync(repoRoot)) {
+    return {
+      status: "deferred",
+      reason: "source-repo-missing",
+      remoteUrl: "",
+      details: ""
+    };
+  }
+
+  const remoteResult = runCapture("git", ["remote", "get-url", "origin"], {
+    cwd: repoRoot,
+    timeoutMs: 5000
+  });
+  const remoteUrl = remoteResult.stdout.trim();
+  if (remoteResult.status !== 0 || !remoteUrl) {
+    return {
+      status: "deferred",
+      reason: "no-origin-remote",
+      remoteUrl: "",
+      details: `${remoteResult.stdout}${remoteResult.stderr}`.trim()
+    };
+  }
+
+  const probeResult = runCapture("git", ["ls-remote", "--exit-code", "origin", "HEAD"], {
+    cwd: repoRoot,
+    timeoutMs: 15000
+  });
+  if (probeResult.status === 0) {
+    return {
+      status: "ready",
+      reason: "",
+      remoteUrl,
+      details: ""
+    };
+  }
+
+  const details = `${probeResult.stdout}${probeResult.stderr}`.trim();
+  let reason = "git-remote-unreachable";
+  if (probeResult.error && probeResult.error.code === "ETIMEDOUT") {
+    reason = "git-remote-timeout";
+  } else if (/could not read Username|Authentication failed|Permission denied|Repository not found|access denied|not found/i.test(details)) {
+    reason = "git-remote-auth-or-access-error";
+  } else if (/Could not resolve host|Name or service not known|Temporary failure in name resolution/i.test(details)) {
+    reason = "git-remote-dns-error";
+  }
+
+  return {
+    status: "deferred",
+    reason,
+    remoteUrl,
+    details
+  };
+}
+
+function buildAnchorSyncDecision(options, sourceRepoRoot) {
+  if (options.skipAnchorSync) {
+    return {
+      status: "skipped",
+      reason: "disabled",
+      remoteUrl: "",
+      details: "",
+      skipAnchorSync: true
+    };
+  }
+
+  const probe = probeAnchorSyncReadiness(sourceRepoRoot);
+  if (probe.status === "ready") {
+    return {
+      status: "ok",
+      reason: "",
+      remoteUrl: probe.remoteUrl,
+      details: probe.details,
+      skipAnchorSync: false
+    };
+  }
+
+  return {
+    status: "deferred",
+    reason: probe.reason,
+    remoteUrl: probe.remoteUrl,
+    details: probe.details,
+    skipAnchorSync: true
+  };
+}
+
 function profileExists(profileRegistryRoot, profileId) {
   return fs.existsSync(path.join(profileRegistryRoot, profileId, "control-plane.yaml"));
 }
@@ -1082,6 +1170,7 @@ function buildSetupDryRunPlan(options, context, config) {
   const dependencyPlan = buildDependencyInstallPlan(prereq.missingRequired);
   const workerInstallPlan = buildWorkerBackendInstallPlan(prereq.workerCommand);
   const workerGuide = backendSetupGuide(prereq.workerCommand);
+  const anchorSync = buildAnchorSyncDecision(options, config.paths.sourceRepoRoot);
 
   let dependencyAction = planStatusWithReason("not-needed");
   if (!prereq.coreToolsOk) {
@@ -1128,6 +1217,8 @@ function buildSetupDryRunPlan(options, context, config) {
       runtimeStartAction = planStatusWithReason("blocked", `missing-tools:${prereq.missingRequired.join(",")}`);
     } else if (!prereq.workerAvailable) {
       runtimeStartAction = planStatusWithReason("blocked", `missing-worker:${prereq.workerCommand}`);
+    } else if (anchorSync.status !== "ok") {
+      runtimeStartAction = planStatusWithReason("blocked", `anchor-sync-${anchorSync.reason}`);
     } else if (!prereq.ghAuthOk) {
       runtimeStartAction = planStatusWithReason("blocked", "gh-auth-not-ready");
     } else {
@@ -1156,6 +1247,7 @@ function buildSetupDryRunPlan(options, context, config) {
     workerInstallPlan,
     workerAction,
     workerGuide,
+    anchorSync,
     githubAuthAction,
     runtimeStartAction,
     launchdAction
@@ -1170,6 +1262,7 @@ function printSetupDryRunPlan(context, config, plan) {
   console.log(`- profile registry root: ${context.profileRegistryRoot}`);
   console.log(`- sync packaged runtime: would-run`);
   console.log(`- scaffold/adopt profile: would-run`);
+  console.log(`- anchor repo sync: ${plan.anchorSync.status === "ok" ? "would-run" : `${plan.anchorSync.status} (${plan.anchorSync.reason})`}`);
   console.log(`- doctor: would-run`);
   console.log(`- dependency install: ${plan.dependencyAction.status}${plan.dependencyAction.reason ? ` (${plan.dependencyAction.reason})` : ""}`);
   if (plan.dependencyAction.status !== "not-needed" && plan.dependencyPlan && plan.dependencyPlan.commands.length > 0) {
@@ -1202,6 +1295,11 @@ function buildSetupResultPayload(params) {
       status: params.coreToolsStatus,
       missingRequiredTools: params.missingRequiredTools
     },
+    anchorSync: {
+      status: params.anchorSyncStatus,
+      reason: params.anchorSyncReason,
+      remoteUrl: params.anchorSyncRemoteUrl
+    },
     workerBackend: {
       command: params.workerBackendCommand,
       status: params.workerBackendStatus,
@@ -1252,6 +1350,9 @@ function emitSetupJsonPayload(payload) {
 
 function collectFinalSetupIssues(config, prereq, doctorKv, runtimeStartStatus) {
   const issues = [];
+  if (config.anchorSync && config.anchorSync.status !== "ok") {
+    issues.push(`anchor repo sync ${config.anchorSync.status}: ${config.anchorSync.reason}`);
+  }
   if (!prereq.coreToolsOk) {
     issues.push(`missing core tools: ${prereq.missingRequired.join(", ")}`);
   }
@@ -1271,7 +1372,11 @@ function collectFinalSetupIssues(config, prereq, doctorKv, runtimeStartStatus) {
 }
 
 async function maybeRunFinalSetupFixups(options, scopedContext, config, currentState) {
-  const issues = collectFinalSetupIssues(config, currentState.prereq, currentState.doctorKv, currentState.runtimeStartStatus);
+  const effectiveConfig = {
+    ...config,
+    anchorSync: currentState.anchorSync || config.anchorSync || null
+  };
+  const issues = collectFinalSetupIssues(effectiveConfig, currentState.prereq, currentState.doctorKv, currentState.runtimeStartStatus);
   if (issues.length === 0) {
     return {
       status: "not-needed",
@@ -1315,6 +1420,7 @@ async function maybeRunFinalSetupFixups(options, scopedContext, config, currentS
   let githubAuthStep = currentState.githubAuthStep;
   let workerSetupStep = currentState.workerSetupStep;
   let doctorKv = currentState.doctorKv;
+  let anchorSync = currentState.anchorSync || effectiveConfig.anchorSync || null;
   let runtimeStartStatus = currentState.runtimeStartStatus;
   let runtimeStartReason = currentState.runtimeStartReason;
   let runtimeStatusKv = currentState.runtimeStatusKv;
@@ -1353,6 +1459,9 @@ async function maybeRunFinalSetupFixups(options, scopedContext, config, currentS
     } else if (!prereq.workerAvailable) {
       runtimeStartStatus = "skipped";
       runtimeStartReason = `missing-worker:${prereq.workerCommand}`;
+    } else if (anchorSync && anchorSync.status !== "ok") {
+      runtimeStartStatus = "skipped";
+      runtimeStartReason = `anchor-sync-${anchorSync.reason}`;
     } else if (!prereq.ghAuthOk) {
       runtimeStartStatus = "skipped";
       runtimeStartReason = "gh-auth-not-ready";
@@ -1376,7 +1485,7 @@ async function maybeRunFinalSetupFixups(options, scopedContext, config, currentS
     launchdInstallReason = "";
   }
 
-  const finalIssues = collectFinalSetupIssues(config, prereq, doctorKv, runtimeStartStatus);
+  const finalIssues = collectFinalSetupIssues({ ...effectiveConfig, anchorSync }, prereq, doctorKv, runtimeStartStatus);
   let status = "ok";
   if (dependencyInstall.status === "failed" || githubAuthStep.status === "failed" || workerSetupStep.installStatus === "failed") {
     status = "failed";
@@ -1387,6 +1496,7 @@ async function maybeRunFinalSetupFixups(options, scopedContext, config, currentS
   return {
     status,
     actions,
+    anchorSync,
     prereq,
     dependencyInstall,
     githubAuthStep,
@@ -1564,6 +1674,9 @@ async function runSetupFlow(forwardedArgs) {
         worktreeRoot: config.paths.worktreeRoot,
         coreToolsStatus: plan.prereq.coreToolsOk ? "ok" : "missing",
         missingRequiredTools: plan.prereq.missingRequired,
+        anchorSyncStatus: plan.anchorSync.status === "ok" ? "would-run" : plan.anchorSync.status,
+        anchorSyncReason: plan.anchorSync.reason || "",
+        anchorSyncRemoteUrl: plan.anchorSync.remoteUrl || "",
         workerBackendCommand: plan.prereq.workerCommand,
         workerBackendStatus: plan.prereq.workerAvailable ? "ok" : "missing",
         workerSetupGuideStatus: "planned",
@@ -1610,6 +1723,13 @@ async function runSetupFlow(forwardedArgs) {
         console.log(`PROFILE_EXISTS=${plan.profileExists ? "yes" : "no"}`);
         console.log(`CORE_TOOLS_STATUS=${plan.prereq.coreToolsOk ? "ok" : "missing"}`);
         console.log(`MISSING_REQUIRED_TOOLS=${plan.prereq.missingRequired.join(",")}`);
+        console.log(`ANCHOR_SYNC_STATUS=${plan.anchorSync.status === "ok" ? "would-run" : plan.anchorSync.status}`);
+        if (plan.anchorSync.reason) {
+          console.log(`ANCHOR_SYNC_REASON=${plan.anchorSync.reason}`);
+        }
+        if (plan.anchorSync.remoteUrl) {
+          console.log(`ANCHOR_SYNC_REMOTE_URL=${plan.anchorSync.remoteUrl}`);
+        }
         console.log(`WORKER_BACKEND_COMMAND=${plan.prereq.workerCommand}`);
         console.log(`WORKER_BACKEND_STATUS=${plan.prereq.workerAvailable ? "ok" : "missing"}`);
         console.log(`GITHUB_AUTH_STATUS=${plan.prereq.ghAuthOk ? "ok" : "not-ready"}`);
@@ -1686,6 +1806,16 @@ async function runSetupFlow(forwardedArgs) {
     prereq = collectPrereqStatus(config.codingWorker);
 
     const scopedContext = buildScopedContext(context, config.profileId);
+    const anchorSync = buildAnchorSyncDecision(options, config.paths.sourceRepoRoot);
+
+    if (anchorSync.status === "deferred") {
+      console.log("\nAnchor repo sync will be deferred for this setup run.");
+      if (anchorSync.remoteUrl) {
+        console.log(`- remote: ${anchorSync.remoteUrl}`);
+      }
+      console.log(`- reason: ${anchorSync.reason}`);
+      console.log("- next step: authenticate Git access or fix the repo remote, then rerun `setup` or `init` without skipping anchor sync.");
+    }
 
     runSetupStep(scopedContext, "Sync packaged runtime into ~/.agent-runtime", "tools/bin/sync-shared-agent-home.sh", []);
 
@@ -1704,7 +1834,7 @@ async function runSetupFlow(forwardedArgs) {
     if (options.force) {
       initArgs.push("--force");
     }
-    if (options.skipAnchorSync) {
+    if (anchorSync.skipAnchorSync) {
       initArgs.push("--skip-anchor-sync");
     }
     if (options.skipWorkspaceSync) {
@@ -1731,6 +1861,9 @@ async function runSetupFlow(forwardedArgs) {
       } else if (!prereq.workerAvailable) {
         runtimeStartReason = `missing-worker:${prereq.workerCommand}`;
         console.log(`runtime start skipped: ${prereq.workerCommand} is not available on PATH`);
+      } else if (anchorSync.status !== "ok") {
+        runtimeStartReason = `anchor-sync-${anchorSync.reason}`;
+        console.log("runtime start skipped: ACP deferred anchor repo sync for this setup run.");
       } else if (!prereq.ghAuthOk) {
         runtimeStartReason = "gh-auth-not-ready";
         console.log("runtime start skipped: GitHub CLI is not authenticated yet. Run `gh auth login` and start the runtime afterwards.");
@@ -1760,6 +1893,7 @@ async function runSetupFlow(forwardedArgs) {
     }
 
     const finalFixup = await maybeRunFinalSetupFixups(options, scopedContext, config, {
+      anchorSync,
       prereq,
       dependencyInstall,
       githubAuthStep,
@@ -1796,6 +1930,9 @@ async function runSetupFlow(forwardedArgs) {
       worktreeRoot: config.paths.worktreeRoot,
       coreToolsStatus: prereq.coreToolsOk ? "ok" : "missing",
       missingRequiredTools: prereq.missingRequired,
+      anchorSyncStatus: anchorSync.status,
+      anchorSyncReason: anchorSync.reason || "",
+      anchorSyncRemoteUrl: anchorSync.remoteUrl || "",
       workerBackendCommand: prereq.workerCommand,
       workerBackendStatus: prereq.workerAvailable ? "ok" : "missing",
       workerSetupGuideStatus: workerSetupStep.status,
@@ -1846,6 +1983,13 @@ async function runSetupFlow(forwardedArgs) {
       console.log(`CODING_WORKER=${config.codingWorker}`);
       console.log(`CORE_TOOLS_STATUS=${prereq.coreToolsOk ? "ok" : "missing"}`);
       console.log(`MISSING_REQUIRED_TOOLS=${prereq.missingRequired.join(",")}`);
+      console.log(`ANCHOR_SYNC_STATUS=${anchorSync.status}`);
+      if (anchorSync.reason) {
+        console.log(`ANCHOR_SYNC_REASON=${anchorSync.reason}`);
+      }
+      if (anchorSync.remoteUrl) {
+        console.log(`ANCHOR_SYNC_REMOTE_URL=${anchorSync.remoteUrl}`);
+      }
       console.log(`WORKER_BACKEND_COMMAND=${prereq.workerCommand}`);
       console.log(`WORKER_BACKEND_STATUS=${prereq.workerAvailable ? "ok" : "missing"}`);
       console.log(`WORKER_SETUP_GUIDE_STATUS=${workerSetupStep.status}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-control-plane",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "description": "Help a repo keep GitHub-driven coding agents running reliably without constant human babysitting",
   "homepage": "https://github.com/ducminhnguyen0319/agent-control-plane",
   "bugs": {
@@ -32,7 +32,6 @@
     "tools/dashboard/server.py",
     "tools/dashboard/styles.css",
     "tools/templates",
-    "tools/tests",
     "tools/vendor/codex-quota/LICENSE",
     "tools/vendor/codex-quota/codex-quota.js",
     "tools/vendor/codex-quota/lib",

package/tools/tests/test-agent-control-plane-npm-cli.sh

@@ -1,280 +0,0 @@
-#!/usr/bin/env bash
-set -euo pipefail
-
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-FLOW_ROOT="$(cd "${SCRIPT_DIR}/../.." && pwd)"
-CLI_SCRIPT="${FLOW_ROOT}/npm/bin/agent-control-plane.js"
-PACKAGE_VERSION="$(node -p "require('${FLOW_ROOT}/package.json').version")"
-
-tmpdir="$(mktemp -d)"
-trap 'rm -rf "${tmpdir}"' EXIT
-
-platform_home="${tmpdir}/platform"
-home_dir="${tmpdir}/home"
-fake_bin="${tmpdir}/fake-bin"
-mkdir -p "${platform_home}" "${home_dir}"
-mkdir -p "${fake_bin}"
-
-cat >"${fake_bin}/gh" <<'EOF'
-#!/usr/bin/env bash
-set -euo pipefail
-
-if [[ "${1:-}" == "auth" && "${2:-}" == "status" ]]; then
-  echo "gh auth ok"
-  exit 0
-fi
-
-if [[ "${1:-}" == "auth" && "${2:-}" == "login" ]]; then
-  echo "gh auth login stub"
-  exit 0
-fi
-
-echo "gh stub: unsupported invocation: $*" >&2
-exit 0
-EOF
-
-cat >"${fake_bin}/jq" <<'EOF'
-#!/usr/bin/env bash
-exit 0
-EOF
-
-cat >"${fake_bin}/codex" <<'EOF'
-#!/usr/bin/env bash
-if [[ "${1:-}" == "--version" ]]; then
-  echo "codex stub 0.0.0"
-  exit 0
-fi
-
-if [[ "${1:-}" == "login" && "${2:-}" == "status" ]]; then
-  echo "codex login ok"
-  exit 0
-fi
-
-echo "codex stub"
-exit 0
-EOF
-
-chmod +x "${fake_bin}/gh" "${fake_bin}/jq" "${fake_bin}/codex"
-
-help_output="$(
-  HOME="${home_dir}" \
-  AGENT_PLATFORM_HOME="${platform_home}" \
-  node "${CLI_SCRIPT}" help
-)"
-
-grep -q '^Usage:$' <<<"${help_output}"
-grep -q '^  setup' <<<"${help_output}"
-grep -q '^  sync' <<<"${help_output}"
-grep -q '^  profile-smoke' <<<"${help_output}"
-grep -q '^  launchd-install' <<<"${help_output}"
-grep -q '^  remove' <<<"${help_output}"
-
-version_output="$(
-  HOME="${home_dir}" \
-  AGENT_PLATFORM_HOME="${platform_home}" \
-  node "${CLI_SCRIPT}" version
-)"
-
-grep -q "^${PACKAGE_VERSION}$" <<<"${version_output}"
-
-HOME="${home_dir}" \
-AGENT_PLATFORM_HOME="${platform_home}" \
-node "${CLI_SCRIPT}" sync >/dev/null
-
-test -f "${platform_home}/runtime-home/skills/openclaw/agent-control-plane/SKILL.md"
-test -f "${platform_home}/runtime-home/tools/bin/flow-runtime-doctor.sh"
-test -f "${platform_home}/runtime-home/skills/openclaw/agent-control-plane/tools/bin/codex-quota"
-test -f "${platform_home}/runtime-home/skills/openclaw/agent-control-plane/tools/vendor/codex-quota-manager/scripts/auto-switch.sh"
-
-doctor_output="$(
-  HOME="${home_dir}" \
-  AGENT_PLATFORM_HOME="${platform_home}" \
-  node "${CLI_SCRIPT}" doctor
-)"
-
-grep -q '^CONTROL_PLANE_NAME=agent-control-plane$' <<<"${doctor_output}"
-grep -q '^SOURCE_READY=yes$' <<<"${doctor_output}"
-
-init_output="$(
-  HOME="${home_dir}" \
-  AGENT_PLATFORM_HOME="${platform_home}" \
-  node "${CLI_SCRIPT}" init \
-    --profile-id alpha \
-    --repo-slug example-owner/alpha \
-    --allow-missing-repo \
-    --skip-anchor-sync \
-    --skip-workspace-sync
-)"
-
-grep -q '^PROJECT_INIT_STATUS=ok$' <<<"${init_output}"
-grep -q '^PROFILE_ID=alpha$' <<<"${init_output}"
-grep -q "^RUNTIME_HOME=${platform_home}/runtime-home$" <<<"${init_output}"
-
-profile_smoke_output="$(
-  HOME="${home_dir}" \
-  AGENT_PLATFORM_HOME="${platform_home}" \
-  node "${CLI_SCRIPT}" profile-smoke --profile-id alpha
-)"
-
-grep -q '^PROFILE_ID=alpha$' <<<"${profile_smoke_output}"
-grep -q '^PROFILE_STATUS=ok$' <<<"${profile_smoke_output}"
-
-runtime_status_output="$(
-  HOME="${home_dir}" \
-  AGENT_PLATFORM_HOME="${platform_home}" \
-  node "${CLI_SCRIPT}" runtime status --profile-id alpha
-)"
-
-grep -q '^PROFILE_ID=alpha$' <<<"${runtime_status_output}"
-grep -q "^CONFIG_YAML=${platform_home}/control-plane/profiles/alpha/control-plane.yaml$" <<<"${runtime_status_output}"
-
-launchd_help="$(
-  HOME="${home_dir}" \
-  AGENT_PLATFORM_HOME="${platform_home}" \
-  node "${CLI_SCRIPT}" launchd-install --help
-)"
-
-grep -q '^Usage:$' <<<"${launchd_help}"
-
-remove_help="$(
-  HOME="${home_dir}" \
-  AGENT_PLATFORM_HOME="${platform_home}" \
-  node "${CLI_SCRIPT}" remove --help
-)"
-
-grep -q '^Usage:$' <<<"${remove_help}"
-
-setup_help="$(
-  HOME="${home_dir}" \
-  AGENT_PLATFORM_HOME="${platform_home}" \
-  node "${CLI_SCRIPT}" setup --help
-)"
-
-grep -q -- '--install-missing-deps' <<<"${setup_help}"
-grep -q -- '--no-install-missing-deps' <<<"${setup_help}"
-grep -q -- '--install-missing-backend' <<<"${setup_help}"
-grep -q -- '--no-install-missing-backend' <<<"${setup_help}"
-grep -q -- '--gh-auth-login' <<<"${setup_help}"
-grep -q -- '--no-gh-auth-login' <<<"${setup_help}"
-grep -q -- '--dry-run' <<<"${setup_help}"
-grep -q -- '--plan' <<<"${setup_help}"
-grep -q -- '--json' <<<"${setup_help}"
-
-setup_repo="${tmpdir}/setup-demo"
-mkdir -p "${setup_repo}"
-git -C "${setup_repo}" init -q -b main
-git -C "${setup_repo}" config user.name "ACP Test"
-git -C "${setup_repo}" config user.email "acp-test@example.com"
-printf '# setup demo\n' >"${setup_repo}/README.md"
-git -C "${setup_repo}" add README.md
-git -C "${setup_repo}" commit -q -m "init"
-git -C "${setup_repo}" remote add origin "https://github.com/example-owner/setup-demo.git"
-
-setup_output="$(
-  HOME="${home_dir}" \
-  AGENT_PLATFORM_HOME="${platform_home}" \
-  PATH="${fake_bin}:${PATH}" \
-  node "${CLI_SCRIPT}" setup \
-    --non-interactive \
-    --repo-root "${setup_repo}" \
-    --no-start-runtime \
-    --skip-anchor-sync \
-    --skip-workspace-sync
-)"
-
-grep -q '^SETUP_STATUS=ok$' <<<"${setup_output}"
-grep -q '^PROFILE_ID=setup-demo$' <<<"${setup_output}"
-grep -q '^REPO_SLUG=example-owner/setup-demo$' <<<"${setup_output}"
-grep -q '^CODING_WORKER=' <<<"${setup_output}"
-grep -q '^CORE_TOOLS_STATUS=ok$' <<<"${setup_output}"
-grep -q '^WORKER_BACKEND_COMMAND=' <<<"${setup_output}"
-grep -q '^WORKER_BACKEND_STATUS=ok$' <<<"${setup_output}"
-grep -q '^WORKER_SETUP_GUIDE_STATUS=' <<<"${setup_output}"
-grep -q '^WORKER_BACKEND_INSTALL_STATUS=' <<<"${setup_output}"
-grep -q '^WORKER_SETUP_DOCS_OPENED=' <<<"${setup_output}"
-grep -q '^WORKER_BACKEND_DOCS_URL=' <<<"${setup_output}"
-grep -q '^WORKER_BACKEND_AUTH_EXAMPLE=' <<<"${setup_output}"
-grep -q '^WORKER_BACKEND_VERIFY_EXAMPLE=' <<<"${setup_output}"
-grep -q '^GITHUB_AUTH_STATUS=' <<<"${setup_output}"
-grep -q '^FINAL_FIXUP_STATUS=' <<<"${setup_output}"
-grep -q '^FINAL_FIXUP_ACTIONS=' <<<"${setup_output}"
-grep -q '^DEPENDENCY_INSTALL_STATUS=' <<<"${setup_output}"
-grep -q '^GITHUB_AUTH_STEP_STATUS=' <<<"${setup_output}"
-grep -q '^PROJECT_INIT_STATUS=ok$' <<<"${setup_output}"
-grep -q '^DOCTOR_STATUS=ok$' <<<"${setup_output}"
-grep -q '^RUNTIME_START_STATUS=skipped$' <<<"${setup_output}"
-grep -q '^RUNTIME_START_REASON=not-requested$' <<<"${setup_output}"
-test -f "${platform_home}/control-plane/profiles/setup-demo/control-plane.yaml"
-
-setup_dry_run_output="$(
-  HOME="${home_dir}" \
-  AGENT_PLATFORM_HOME="${platform_home}" \
-  PATH="${fake_bin}:${PATH}" \
-  node "${CLI_SCRIPT}" setup \
-    --dry-run \
-    --non-interactive \
-    --repo-root "${setup_repo}" \
-    --no-start-runtime \
-    --skip-anchor-sync \
-    --skip-workspace-sync
-)"
-
-grep -q '^SETUP_STATUS=dry-run$' <<<"${setup_dry_run_output}"
-grep -q '^SETUP_MODE=dry-run$' <<<"${setup_dry_run_output}"
-grep -q '^PROJECT_INIT_STATUS=would-run$' <<<"${setup_dry_run_output}"
-grep -q '^DOCTOR_STATUS=would-run$' <<<"${setup_dry_run_output}"
-grep -q '^FINAL_FIXUP_STATUS=planned$' <<<"${setup_dry_run_output}"
-grep -q '^FINAL_FIXUP_ACTIONS=review-plan$' <<<"${setup_dry_run_output}"
-
-setup_json_output="$(
-  HOME="${home_dir}" \
-  AGENT_PLATFORM_HOME="${platform_home}" \
-  PATH="${fake_bin}:${PATH}" \
-  node "${CLI_SCRIPT}" setup \
-    --json \
-    --repo-root "${setup_repo}" \
-    --profile-id setup-json \
-    --no-start-runtime \
-    --skip-anchor-sync \
-    --skip-workspace-sync
-)"
-
-printf '%s' "${setup_json_output}" | node -e '
-  const fs = require("fs");
-  const data = JSON.parse(fs.readFileSync(0, "utf8"));
-  if (data.setupStatus !== "ok") process.exit(1);
-  if (data.setupMode !== "run") process.exit(1);
-  if (data.profileId !== "setup-json") process.exit(1);
-  if (data.projectInitStatus !== "ok") process.exit(1);
-  if (data.doctorStatus !== "ok") process.exit(1);
-  if (!data.workerBackend || !data.githubAuth || !data.finalFixup) process.exit(1);
-'
-
-setup_dry_run_json_output="$(
-  HOME="${home_dir}" \
-  AGENT_PLATFORM_HOME="${platform_home}" \
-  PATH="${fake_bin}:${PATH}" \
-  node "${CLI_SCRIPT}" setup \
-    --json \
-    --dry-run \
-    --repo-root "${setup_repo}" \
-    --profile-id dry-run-json \
-    --no-start-runtime \
-    --skip-anchor-sync \
-    --skip-workspace-sync
-)"
-
-printf '%s' "${setup_dry_run_json_output}" | node -e '
-  const fs = require("fs");
-  const data = JSON.parse(fs.readFileSync(0, "utf8"));
-  if (data.setupStatus !== "dry-run") process.exit(1);
-  if (data.setupMode !== "dry-run") process.exit(1);
-  if (data.profileId !== "dry-run-json") process.exit(1);
-  if (data.projectInitStatus !== "would-run") process.exit(1);
-  if (data.doctorStatus !== "would-run") process.exit(1);
-  if (!data.finalFixup || data.finalFixup.status !== "planned") process.exit(1);
-  if (data.dependencyInstall && data.dependencyInstall.status === "not-needed" && data.dependencyInstall.command !== "") process.exit(1);
-  if (data.workerBackend && data.workerBackend.installStatus === "not-needed" && data.workerBackend.installCommand !== "") process.exit(1);
-'
-
-test ! -e "${platform_home}/control-plane/profiles/dry-run-json/control-plane.yaml"

package/tools/tests/test-agent-github-update-labels-falls-back-to-repository-id.sh

@@ -1,56 +0,0 @@
-#!/usr/bin/env bash
-set -euo pipefail
-
-FLOW_ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/../.." && pwd)"
-SCRIPT_SRC="${FLOW_ROOT}/tools/bin/agent-github-update-labels"
-CONFIG_LIB_SRC="${FLOW_ROOT}/tools/bin/flow-config-lib.sh"
-SHELL_LIB_SRC="${FLOW_ROOT}/tools/bin/flow-shell-lib.sh"
-
-tmpdir="$(mktemp -d)"
-trap 'rm -rf "$tmpdir"' EXIT
-
-bin_dir="$tmpdir/bin"
-payload_file="$tmpdir/payload.json"
-mkdir -p "$bin_dir"
-
-cp "$SCRIPT_SRC" "$bin_dir/agent-github-update-labels"
-cp "$CONFIG_LIB_SRC" "$bin_dir/flow-config-lib.sh"
-cp "$SHELL_LIB_SRC" "$bin_dir/flow-shell-lib.sh"
-
-cat >"$bin_dir/gh" <<'EOF'
-#!/usr/bin/env bash
-set -euo pipefail
-
-if [[ "${1:-}" == "api" ]]; then
-  route="${2:-}"
-  if [[ "$route" == "repos/example/demo/issues/42" ]]; then
-    echo '{"message":"Not Found"}' >&2
-    exit 1
-  fi
-  if [[ "$route" == user/repos\?* ]]; then
-    printf '[[{"id":123,"full_name":"example/demo"}]]\n'
-    exit 0
-  fi
-  if [[ "$route" == "repositories/123/issues/42" ]]; then
-    if [[ " $* " == *" --method PATCH "* ]]; then
-      cat >"${TEST_PAYLOAD_FILE:?}"
-      exit 0
-    fi
-    printf '{"labels":[{"name":"agent-blocked"}]}\n'
-    exit 0
-  fi
-fi
-
-echo "unexpected gh invocation: $*" >&2
-exit 1
-EOF
-chmod +x "$bin_dir/gh" "$bin_dir/agent-github-update-labels"
-
-TEST_PAYLOAD_FILE="$payload_file" \
-PATH="$bin_dir:$PATH" \
-bash "$bin_dir/agent-github-update-labels" --repo-slug example/demo --number 42 --add agent-running --remove agent-blocked
-
-test "$(jq -r '.labels[0]' "$payload_file")" = "agent-running"
-test "$(jq '.labels | length' "$payload_file")" -eq 1
-
-echo "agent github update labels falls back to repository id test passed"