@botbuddy/cli 1.4.2 → 1.5.0

package/src/stack.test.mjs

@@ -15,6 +15,8 @@ import {
   EXIT, STACK_HELP, STACK_SCHEMA_VERSION, DEFAULT_RECEIPT_MAX_BYTES,
   deriveSlot, parseStackArgs, buildReceipt, truncateReceipt,
   parseSupabaseStatus, eventStreamBase, resolveLocalSupabaseUrl, resolveStackPath,
+  runLocalExecPreflight, dockerEnvForSelector, dockerTargetFromPreflight, connectionWithDockerTarget,
+  proveLegacyLocalExecTarget, localTeardown, cmdUp, cmdDone,
   runStackLifecycle, materializeLeasedTestConfig, waitForLease,
 } from "./stack.mjs";
 
@@ -57,7 +59,7 @@ test("deriveSlot: throws when undeterminable", () => {
 test("parseStackArgs: up options", () => {
   const { command, opts, errors } = parseStackArgs([
     "up", "--slot", "56322", "--host", "mac", "--repo", "botbuddy-web",
-    "--ticket", "BOT-1220", "--stack-path", "infra/local", "--idle-ttl", "600", "--timeout", "120", "--no-wait", "--local-exec",
+    "--ticket", "BOT-1220", "--stack-path", "infra/local", "--idle-ttl", "600", "--timeout", "120", "--no-wait", "--local-exec", "--docker-context", "orbstack",
   ]);
   assert.equal(errors.length, 0);
   assert.equal(command, "up");
@@ -68,6 +70,326 @@ test("parseStackArgs: up options", () => {
   assert.equal(opts.timeout, 120);
   assert.equal(opts.noWait, true);
   assert.equal(opts.localExec, true);
+  assert.equal(opts.dockerContext, "orbstack");
+});
+test("parseStackArgs: local-exec up requires exactly one explicit Docker selector", () => {
+  assert.match(parseStackArgs(["up", "--slot", "x", "--local-exec"]).errors.join(" "), /docker-context.*docker-endpoint/i);
+  assert.match(parseStackArgs([
+    "up", "--slot", "x", "--local-exec", "--docker-context", "orbstack", "--docker-endpoint", "unix:///tmp/docker.sock",
+  ]).errors.join(" "), /exactly one/i);
+  assert.deepEqual(parseStackArgs([
+    "up", "--slot", "x", "--local-exec", "--docker-endpoint", "unix:///Users/test/.orbstack/run/docker.sock",
+  ]).errors, []);
+});
+
+test("parseStackArgs: local-exec done requires exactly one explicit Docker selector", () => {
+  assert.match(parseStackArgs(["done", "lease-1", "--local-exec"]).errors.join(" "), /docker-context.*docker-endpoint/i);
+  assert.equal(parseStackArgs([
+    "done", "lease-1", "--local-exec", "--docker-context", "orbstack",
+  ]).errors.length, 0);
+  assert.ok(parseStackArgs([
+    "done", "lease-1", "--local-exec", "--docker-context", "orbstack", "--docker-endpoint", "unix:///tmp/docker.sock",
+  ]).errors.length > 0);
+});
+test("parseStackArgs: a missing Docker selector value preserves the following flag", () => {
+  const parsed = parseStackArgs(["up", "--slot", "x", "--local-exec", "--docker-context", "--json"]);
+  assert.equal(parsed.opts.json, true);
+  assert.match(parsed.errors.join(" "), /--docker-context needs a value/i);
+});
+
+test("runLocalExecPreflight delegates the explicit selector and preserves refusal", () => {
+  const calls = [];
+  const expected = { exitCode: 2, receipt: { outcome: "refused", pressure: { status: "fail" } }, json: true };
+  const actual = runLocalExecPreflight({ dockerContext: "orbstack", dockerEndpoint: null }, (args) => {
+    calls.push(args);
+    return expected;
+  });
+  assert.deepEqual(calls, [["preflight", "--context", "orbstack", "--json"]]);
+  assert.equal(actual, expected);
+});
+
+test("dockerEnvForSelector replaces ambient Docker routing with the preflight target", () => {
+  assert.deepEqual(dockerEnvForSelector(
+    { dockerContext: "orbstack", dockerEndpoint: null },
+    { PATH: "/bin", DOCKER_CONTEXT: "desktop-linux", DOCKER_HOST: "tcp://wrong" },
+  ), { PATH: "/bin", DOCKER_CONTEXT: "orbstack" });
+  assert.deepEqual(dockerEnvForSelector(
+    { dockerContext: null, dockerEndpoint: "unix:///Users/test/.orbstack/run/docker.sock" },
+    { PATH: "/bin", DOCKER_CONTEXT: "desktop-linux" },
+  ), { PATH: "/bin", DOCKER_HOST: "unix:///Users/test/.orbstack/run/docker.sock" });
+});
+
+test("localTeardown passes the explicit Docker selector to supabase stop", () => {
+  let invocation;
+  const ok = localTeardown(
+    { dockerContext: "orbstack", dockerEndpoint: null },
+    { validation: "orbstack", resolved_endpoint: "unix:///Users/test/.orbstack/run/docker.sock", server_id: "daemon-1" },
+    (command, args, options) => {
+      invocation = { command, args, env: options.env };
+      return { status: 0, stdout: "", stderr: "" };
+    },
+    { PATH: "/bin", DOCKER_CONTEXT: "desktop-linux", DOCKER_HOST: "tcp://wrong" },
+  );
+  assert.equal(ok, true);
+  assert.deepEqual(invocation, {
+    command: "supabase",
+    args: ["stop", "--workdir", process.cwd()],
+    env: { PATH: "/bin", DOCKER_HOST: "unix:///Users/test/.orbstack/run/docker.sock" },
+  });
+});
+
+const targetReceipt = (serverId, endpoint = "unix:///Users/test/.orbstack/run/docker.sock") => ({
+  context: {
+    validation: "orbstack",
+    resolved_endpoint: endpoint,
+    server: { id: serverId, name: "orbstack", operating_system: "OrbStack" },
+  },
+  pressure: { status: "ok" },
+});
+
+test("dockerTargetFromPreflight requires a resolved OrbStack server identity", () => {
+  assert.deepEqual(dockerTargetFromPreflight(targetReceipt("daemon-1")), {
+    validation: "orbstack",
+    resolved_endpoint: "unix:///Users/test/.orbstack/run/docker.sock",
+    server_id: "daemon-1",
+  });
+  assert.equal(dockerTargetFromPreflight(targetReceipt(null)), null);
+});
+
+test("connectionWithDockerTarget persists the validated target in the lease connection", () => {
+  const target = dockerTargetFromPreflight(targetReceipt("daemon-1"));
+  assert.deepEqual(connectionWithDockerTarget({ api_url: "http://127.0.0.1:56321" }, target), {
+    api_url: "http://127.0.0.1:56321",
+    botbuddy_docker_target: target,
+  });
+});
+
+test("cmdDone refuses before release when teardown targets a different Docker daemon", async () => {
+  const tools = [];
+  let emitted;
+  const code = await cmdDone("lease-1", {
+    localExec: true, dockerContext: "orbstack", dockerEndpoint: null,
+    disposition: "destroy", receiptMaxBytes: DEFAULT_RECEIPT_MAX_BYTES,
+  }, {
+    callTool: async (name) => {
+      tools.push(name);
+      return { ok: true, data: { success: true, state: "active", connection: {
+        botbuddy_docker_target: dockerTargetFromPreflight(targetReceipt("daemon-1")),
+      } } };
+    },
+    runPreflight: () => ({ exitCode: 0, receipt: targetReceipt("daemon-2") }),
+    localTeardownFn: () => { throw new Error("must not stop"); },
+    emitResult: (receipt, _opts, exitCode) => { emitted = receipt; return exitCode; },
+  });
+  assert.equal(code, EXIT.LEASE_FAILED);
+  assert.deepEqual(tools, ["get_stack_lease"]);
+  assert.equal(emitted.outcome, "refused");
+});
+
+test("proveLegacyLocalExecTarget accepts only an exact owning-worktree and live connection match", () => {
+  const target = dockerTargetFromPreflight(targetReceipt("daemon-1"));
+  const worktreeRoot = realpathSync(process.cwd());
+  const lease = {
+    worktree_root: worktreeRoot,
+    stack_path: ".",
+    connection: {
+      api_url: "http://127.0.0.1:56321",
+      db_url: "postgresql://postgres:postgres@127.0.0.1:56322/postgres",
+    },
+  };
+  const spawned = [];
+  const proof = proveLegacyLocalExecTarget(lease, target, { stackPath: "." }, (command, args, options) => {
+    spawned.push({ command, args, env: options.env });
+    return { status: 0, stdout: JSON.stringify({
+      API_URL: lease.connection.api_url,
+      DB_URL: lease.connection.db_url,
+    }), stderr: "" };
+  });
+
+  assert.equal(proof.ok, true);
+  assert.equal(proof.evidence.method, "legacy_worktree_connection_match");
+  assert.equal(spawned[0].env.DOCKER_HOST, target.resolved_endpoint);
+  assert.deepEqual(spawned[0].args, ["status", "-o", "json", "--workdir", worktreeRoot]);
+
+  const mismatch = proveLegacyLocalExecTarget(lease, target, { stackPath: "." }, () => ({
+    status: 0,
+    stdout: JSON.stringify({ API_URL: "http://127.0.0.1:64321", DB_URL: lease.connection.db_url }),
+    stderr: "",
+  }));
+  assert.equal(mismatch.ok, false);
+  assert.match(mismatch.error, /connection.*does not match/i);
+});
+
+test("cmdDone safely tears down a pre-1.5.0 lease after the legacy compatibility proof", async () => {
+  const tools = [];
+  let emitted;
+  const target = dockerTargetFromPreflight(targetReceipt("daemon-1"));
+  const code = await cmdDone("lease-legacy", {
+    localExec: true, dockerContext: "orbstack", dockerEndpoint: null, stackPath: ".",
+    disposition: "destroy", receiptMaxBytes: DEFAULT_RECEIPT_MAX_BYTES,
+  }, {
+    callTool: async (name) => {
+      tools.push(name);
+      if (name === "get_stack_lease") return { ok: true, data: {
+        success: true, state: "active", worktree_root: process.cwd(), stack_path: ".",
+        connection: { api_url: "http://127.0.0.1:56321", db_url: "postgresql://127.0.0.1:56322/postgres" },
+      } };
+      if (name === "release_stack_lease") return { ok: true, data: { success: true, state: "reaping" } };
+      if (name === "finalize_stack_lease") return { ok: true, data: { success: true, state: "reaped" } };
+      throw new Error(`unexpected tool ${name}`);
+    },
+    runPreflight: () => ({ exitCode: 0, receipt: targetReceipt("daemon-1") }),
+    proveLegacyTarget: () => ({ ok: true, evidence: { method: "legacy_worktree_connection_match" } }),
+    localTeardownFn: () => true,
+    emitResult: (receipt, _opts, exitCode) => { emitted = receipt; return exitCode; },
+  });
+
+  assert.equal(code, EXIT.OK);
+  assert.deepEqual(tools, ["get_stack_lease", "release_stack_lease", "finalize_stack_lease"]);
+  assert.deepEqual(emitted.legacy_target_proof, { method: "legacy_worktree_connection_match" });
+});
+
+test("cmdDone refuses a legacy lease before release when compatibility proof is absent", async () => {
+  const tools = [];
+  let emitted;
+  const code = await cmdDone("lease-legacy", {
+    localExec: true, dockerContext: "orbstack", dockerEndpoint: null, stackPath: ".",
+    disposition: "destroy", receiptMaxBytes: DEFAULT_RECEIPT_MAX_BYTES,
+  }, {
+    callTool: async (name) => {
+      tools.push(name);
+      return { ok: true, data: { success: true, state: "active", connection: { api_url: "http://127.0.0.1:56321" } } };
+    },
+    runPreflight: () => ({ exitCode: 0, receipt: targetReceipt("daemon-1") }),
+    proveLegacyTarget: () => ({ ok: false, error: "legacy worktree metadata is missing" }),
+    localTeardownFn: () => { throw new Error("must not stop"); },
+    emitResult: (receipt, _opts, exitCode) => { emitted = receipt; return exitCode; },
+  });
+
+  assert.equal(code, EXIT.LEASE_FAILED);
+  assert.deepEqual(tools, ["get_stack_lease"]);
+  assert.match(emitted.error, /legacy worktree metadata is missing/i);
+});
+
+test("cmdDone stops and finalizes only after the fresh Docker identity matches the lease", async () => {
+  const tools = [];
+  let teardownTarget;
+  const target = dockerTargetFromPreflight(targetReceipt("daemon-1"));
+  const code = await cmdDone("lease-1", {
+    localExec: true, dockerContext: "orbstack", dockerEndpoint: null,
+    disposition: "destroy", receiptMaxBytes: DEFAULT_RECEIPT_MAX_BYTES,
+  }, {
+    callTool: async (name) => {
+      tools.push(name);
+      if (name === "get_stack_lease") return { ok: true, data: { success: true, state: "active", connection: { botbuddy_docker_target: target } } };
+      if (name === "release_stack_lease") return { ok: true, data: { success: true, state: "reaping" } };
+      if (name === "finalize_stack_lease") return { ok: true, data: { success: true, state: "reaped" } };
+      throw new Error(`unexpected tool ${name}`);
+    },
+    runPreflight: () => ({ exitCode: 0, receipt: targetReceipt("daemon-1") }),
+    localTeardownFn: (_opts, actual) => { teardownTarget = actual; return true; },
+    emitResult: (_receipt, _opts, exitCode) => exitCode,
+  });
+  assert.equal(code, EXIT.OK);
+  assert.deepEqual(tools, ["get_stack_lease", "release_stack_lease", "finalize_stack_lease"]);
+  assert.deepEqual(teardownTarget, target);
+});
+
+test("cmdUp refuses pressure before lease request or local provisioning", async () => {
+  const events = [];
+  let emitted;
+  const code = await cmdUp({
+    slot: "botbuddy-web-bot-1405", repo: "botbuddy-web", ticket: "BOT-1405",
+    stackPath: ".", localExec: true, dockerContext: "orbstack", dockerEndpoint: null,
+  }, {
+    runPreflight: () => ({
+      exitCode: 2,
+      receipt: {
+        outcome: "refused", context: { selector: "orbstack" },
+        pressure: { status: "fail", projected_pressure_units: 224 },
+        warnings: [], errors: ["interface pressure refusal"], recommendation: "run hygiene",
+      },
+      json: true,
+    }),
+    callTool: async (...args) => { events.push(["tool", ...args]); throw new Error("must not request a lease"); },
+    localProvisionFn: () => { events.push(["provision"]); throw new Error("must not start Supabase"); },
+    emitResult: (receipt, _opts, exitCode) => { emitted = receipt; return exitCode; },
+  });
+
+  assert.equal(code, EXIT.LEASE_FAILED);
+  assert.equal(emitted.outcome, "refused");
+  assert.equal(emitted.preflight.pressure.status, "fail");
+  assert.deepEqual(events, []);
+});
+
+test("cmdUp atomically cancels an unclaimed lease when the just-in-time preflight refuses", async () => {
+  const tools = [];
+  let preflights = 0;
+  let emitted;
+  const okReceipt = {
+    ...targetReceipt("daemon-1"), outcome: "ok", pressure: { status: "ok" },
+    warnings: [], errors: [], recommendation: "none",
+  };
+  const refusedReceipt = {
+    ...targetReceipt("daemon-1"), outcome: "refused", pressure: { status: "fail" },
+    warnings: [], errors: ["interface pressure refusal"], recommendation: "run hygiene",
+  };
+  const code = await cmdUp({
+    slot: "botbuddy-web-bot-1405", host: "test-mac", repo: "botbuddy-web", ticket: "BOT-1405",
+    stackPath: ".", localExec: true, dockerContext: "orbstack", dockerEndpoint: null,
+    timeout: 60, noWait: false, json: false,
+  }, {
+    authProvider: () => ({ Authorization: "test" }),
+    runPreflight: () => ({
+      exitCode: preflights++ === 0 ? 0 : 2,
+      receipt: preflights === 1 ? okReceipt : refusedReceipt,
+      json: true,
+    }),
+    callTool: async (tool, args) => {
+      tools.push([tool, args]);
+      if (tool === "request_stack_lease") return { ok: true, data: { success: true, lease_id: "lease-1", state: "provisioning" } };
+      if (tool === "cancel_unclaimed_stack_lease") return { ok: true, data: { success: true, state: "reaped", provision_job_cancelled: true } };
+      throw new Error(`unexpected tool ${tool}`);
+    },
+    localProvisionFn: () => { throw new Error("must not start Supabase"); },
+    emitResult: (receipt, _opts, exitCode) => { emitted = receipt; return exitCode; },
+  });
+
+  assert.equal(code, EXIT.LEASE_FAILED);
+  assert.deepEqual(tools.map(([tool]) => tool), ["request_stack_lease", "cancel_unclaimed_stack_lease"]);
+  assert.equal(emitted.outcome, "refused");
+  assert.deepEqual(emitted.lease_cancellation, { success: true, state: "reaped", provision_job_cancelled: true });
+});
+
+test("cmdUp persists the validated Docker identity used by local provisioning", async () => {
+  const target = dockerTargetFromPreflight(targetReceipt("daemon-1"));
+  let provisionTarget;
+  let activatedConnection;
+  const code = await cmdUp({
+    slot: "botbuddy-web-bot-1405", host: "test-mac", repo: "botbuddy-web", ticket: "BOT-1405",
+    stackPath: ".", localExec: true, dockerContext: "orbstack", dockerEndpoint: null,
+    timeout: 60, noWait: false, json: false,
+  }, {
+    authProvider: () => ({ Authorization: "test" }),
+    runPreflight: () => ({ exitCode: 0, receipt: { ...targetReceipt("daemon-1"), outcome: "ok", warnings: [], errors: [] } }),
+    localProvisionFn: (_opts, actualTarget) => {
+      provisionTarget = actualTarget;
+      return { api_url: "http://127.0.0.1:56321" };
+    },
+    callTool: async (name, args) => {
+      if (name === "request_stack_lease") return { ok: true, data: { success: true, lease_id: "lease-1", state: "provisioning" } };
+      if (name === "activate_stack_lease") {
+        activatedConnection = args.connection;
+        return { ok: true, data: { success: true, state: "active" } };
+      }
+      if (name === "get_stack_lease") return { ok: true, data: { success: true, state: "active", slot: "botbuddy-web-bot-1405", connection: activatedConnection } };
+      throw new Error(`unexpected tool ${name}`);
+    },
+    emitResult: (_receipt, _opts, exitCode) => exitCode,
+  });
+  assert.equal(code, EXIT.OK);
+  assert.deepEqual(provisionTarget, target);
+  assert.deepEqual(activatedConnection.botbuddy_docker_target, target);
 });
 test("parseStackArgs: rejects absolute and escaping stack paths", () => {
   assert.ok(parseStackArgs(["up", "--stack-path", "/tmp/stack"]).errors.length > 0);
@@ -393,7 +715,7 @@ test("resolveLocalSupabaseUrl: ignores a NON-local exported origin (refuses →
 
 // ── --help snapshot (AC-4) ───────────────────────────────────────────────────
 test("STACK_HELP documents the four subcommands and every exit code", () => {
-  for (const s of ["stack up", "stack status", "stack touch", "stack done", "--local-exec", "--no-wait"]) {
+  for (const s of ["stack up", "stack status", "stack touch", "stack done", "--local-exec", "--docker-context", "--no-wait"]) {
     assert.ok(STACK_HELP.includes(s), `help missing ${s}`);
   }
   for (const s of ["0 ok", "2 park timed out", "3 not authenticated", "4 invalid", "5 backend", "6 lease failed", "7 internal"]) {