@zaip-ai/cli 1.3.8 → 1.4.1

package/templates/.agents/tools/cloud-runner.test.mjs

@@ -0,0 +1,534 @@
+import assert from "node:assert/strict";
+import { spawnSync } from "node:child_process";
+import { createHash } from "node:crypto";
+import { relative, resolve } from "node:path";
+import test from "node:test";
+import { execute, run } from "./cloud-runner.mjs";
+
+const root = resolve(import.meta.dirname, "../..");
+const path = ".agents/config/autonomous-cloud-contract.json";
+const digest = (value) => createHash("sha256").update(value).digest("hex");
+const operation = (name, extra = {}) => ({
+  contract: path,
+  operation: name,
+  credentialsSource: "root",
+  ...extra,
+});
+const cf = (name) =>
+  operation(name, {
+    provider: "cloudflare",
+    accountId: "cf",
+    zoneId: "zone",
+    dnsRecord: "probe.example.com",
+  });
+const tf = () => operation("terraform:plan", { terraformDirectory: "infra/terraform" });
+
+// Every file is virtual. Tests never touch .env, SSH material, or real saved plans.
+function fixture() {
+  const calls = [],
+    files = new Map();
+  const backend = {
+    type: "s3",
+    config: {
+      bucket: "approved-state",
+      key: "test/terraform.tfstate",
+      region: "us-east-1",
+      encrypt: true,
+      use_lockfile: true,
+    },
+  };
+  const contract = {
+    version: 1,
+    profile: "autonomous-cloud",
+    authorization: { standing: true, reference: "TASK-TEST" },
+    cloudflare: {
+      account_id: "cf",
+      zone_id: "zone",
+      zone_name: "example.com",
+      dns_records: ["api.example.com"],
+      direct_dns_records: {
+        "probe.example.com": {
+          name: "probe.example.com",
+          type: "A",
+          content: "198.51.100.7",
+          proxied: true,
+          ttl: 1,
+        },
+      },
+      allowed_operations: ["cloudflare:dns:read", "cloudflare:dns:create", "cloudflare:dns:edit"],
+    },
+    hostinger: {
+      account_id: "hs",
+      allowed_operations: [
+        "hostinger:vps:read",
+        "hostinger:ssh:read",
+        "hostinger:ssh:test",
+        "hostinger:ssh:configure",
+      ],
+      vps: {
+        edge: {
+          id: "101",
+          ssh_host: "198.51.100.7",
+          host_key_sha256: "SHA256:cJ6AyISHokEeHuTfufIqhhSS0gxHZRUMDHlKvXD4FHw",
+          ssh_user: "zaip",
+          private_key_path: ".local/test-key",
+          known_hosts_path: ".local/test-known",
+        },
+        application: { id: "102", ssh_host: "198.51.100.8" },
+      },
+    },
+    terraform: {
+      binary_path: ".local/test-terraform",
+      binary_sha256: digest("trusted-binary"),
+      working_directory: "infra/terraform",
+      allowed_operations: ["terraform:plan", "terraform:apply", "terraform:import"],
+      import_targets: { "hostinger_vps.edge[0]": "101" },
+      plan: {
+        backend,
+        path: ".local/cloud/plans/test.tfplan",
+        policy_json_path: ".local/cloud/plans/test.json",
+        policy_contract_path: ".agents/config/test-policy.json",
+      },
+    },
+  };
+  const env = {
+    ZAIP_CLOUD_PROFILE: "autonomous-cloud",
+    CLOUDFLARE_API_TOKEN: "cf-token",
+    HOSTINGER_API_TOKEN: "hs-token",
+    TF_VAR_cloudflare_account_id: "cf",
+    TF_VAR_cloudflare_zone_id: "zone",
+    TF_VAR_cloudflare_zone_name: "example.com",
+    ZAIP_HOSTINGER_ACCOUNT_ID: "hs",
+    TF_VAR_edge_vps_id: "101",
+    TF_VAR_application_vps_id: "102",
+    TF_VAR_edge_vps_ipv4: "198.51.100.7",
+    TF_VAR_application_vps_ipv4: "198.51.100.8",
+    ZAIP_EDGE_SSH_HOSTKEY_SHA256: "SHA256:cJ6AyISHokEeHuTfufIqhhSS0gxHZRUMDHlKvXD4FHw",
+    ZAIP_APPLICATION_SSH_HOSTKEY_SHA256: "SHA256:app",
+    ZAIP_CLOUD_SSH_PRIVATE_KEY_PATH: ".local/test-key",
+    AWS_ACCESS_KEY_ID: "state-key",
+    AWS_SECRET_ACCESS_KEY: "state-secret",
+    UNRELATED_SECRET: "never-pass",
+  };
+  const save = () => {
+    files.set(path, JSON.stringify(contract));
+    files.set(
+      ".env",
+      Object.entries(env)
+        .map(([key, value]) => `${key}=${value}`)
+        .join("\n"),
+    );
+  };
+  save();
+  files.set(".agents/config/autonomous-cloud-inputs.json", JSON.stringify(contract));
+  files.set(
+    "infra/terraform/backend.tf.json",
+    JSON.stringify({ terraform: { backend: { s3: backend.config } } }),
+  );
+  files.set("infra/terraform/.terraform.lock.hcl", "reviewed-lock");
+  files.set(".local/test-terraform", "trusted-binary");
+  files.set(
+    contract.terraform.plan.policy_contract_path,
+    JSON.stringify({
+      cloudflare: {
+        account_id: "cf",
+        zone_id: "zone",
+        zone_name: "example.com",
+        edge_ipv4: "198.51.100.7",
+        dns_records: { api: { type: "A", content: "198.51.100.7", proxied: true } },
+      },
+      hostinger: { edge: { id: "101" }, application: { id: "102", ipv4: "198.51.100.8" } },
+    }),
+  );
+  files.set(".local/test-key", "not-a-real-key");
+  files.set(".local/test-known", "not-a-real-host");
+  const state = {
+    values: {
+      root_module: {
+        resources: ["edge", "application"].map((role) => ({
+          address: `hostinger_vps.${role}[0]`,
+          type: "hostinger_vps",
+          mode: "managed",
+          values: {
+            id: contract.hostinger.vps[role].id,
+            ipv4_address: contract.hostinger.vps[role].ssh_host,
+          },
+        })),
+      },
+    },
+  };
+  let records = [],
+    planMade = false,
+    applied = false;
+  const key = (value) => relative(root, value).replaceAll("\\", "/");
+  const get = (value) => {
+    const name = key(value);
+    if (!files.has(name)) throw Object.assign(new Error("missing fixture"), { code: "ENOENT" });
+    return files.get(name);
+  };
+  const response = (body) => ({ ok: true, json: async () => body });
+  const deps = {
+    access: async (value) => {
+      get(value);
+    },
+    mkdir: async () => {},
+    realpath: async (value) => value,
+    readFile: async (value) => get(value),
+    writeFile: async (value, content) => {
+      calls.push({ write: key(value) });
+      files.set(key(value), content);
+    },
+    http: async (url, options) => {
+      calls.push({ url, method: options.method, body: options.body });
+      assert.equal(options.redirect, "error");
+      if (url.endsWith("/zones/zone"))
+        return response({
+          success: true,
+          result: { id: "zone", name: "example.com", account: { id: "cf" } },
+        });
+      const id = /virtual-machines\/(101|102)$/.exec(url)?.[1];
+      if (id)
+        return response({
+          id: Number(id),
+          ipv4: [{ address: id === "101" ? "198.51.100.7" : "198.51.100.8" }],
+        });
+      if (url.includes("dns_records?name=")) return response({ success: true, result: records });
+      if (url.endsWith("/dns_records") && options.method === "POST") {
+        records = [{ id: "dns-id", ...JSON.parse(options.body) }];
+        return response({ success: true, result: records[0] });
+      }
+      throw new Error(`Unexpected fixture HTTP route: ${url}`);
+    },
+    exec: async (file, args, options) => {
+      calls.push({ file, args, options });
+      if (file === "ssh-keygen")
+        return {
+          code: 0,
+          stdout: args.includes("-F")
+            ? "198.51.100.7 ssh-ed25519 AAAA"
+            : "256 SHA256:cJ6AyISHokEeHuTfufIqhhSS0gxHZRUMDHlKvXD4FHw host (ED25519)",
+        };
+      if (file === "ssh") return { code: 0, stdout: "Linux\n" };
+      if (file === process.execPath) {
+        assert.ok(planMade);
+        return { code: 0, stdout: "policy accepted" };
+      }
+      switch (args[0]) {
+        case "init":
+          files.set(
+            "infra/terraform/.terraform/terraform.tfstate",
+            JSON.stringify({ backend: { type: "s3", config: backend.config } }),
+          );
+          break;
+        case "fmt":
+        case "validate":
+          break;
+        case "plan":
+          planMade = true;
+          files.set(contract.terraform.plan.path, Buffer.from("reviewed-plan"));
+          break;
+        case "show":
+          assert.ok(planMade);
+          return {
+            code: 0,
+            stdout:
+              args.length === 2
+                ? (assert.ok(applied), JSON.stringify(state))
+                : JSON.stringify({ resource_changes: [] }),
+          };
+        case "apply":
+          assert.ok(planMade);
+          assert.equal(args.at(-1), resolve(root, contract.terraform.plan.path));
+          applied = true;
+          break;
+        case "import":
+          break;
+        default:
+          throw new Error(`Unexpected fixture command: ${args[0]}`);
+      }
+      return { code: 0, stdout: "" };
+    },
+  };
+  return {
+    deps,
+    contract,
+    env,
+    files,
+    calls,
+    save,
+    setRecords: (value) => {
+      records = value;
+    },
+  };
+}
+
+test("derive observes target identity and writes a complete secret-free contract", async () => {
+  const f = fixture();
+  const result = await run({ operation: "contract:derive", credentialsSource: "root" }, f.deps);
+  assert.equal(result.contract_path, path);
+  assert.equal(JSON.parse(f.files.get(path)).hostinger.vps.edge.id, "101");
+  assert.equal(f.calls.filter((call) => call.url).length, 3);
+  assert.ok(!f.files.get(path).includes("cf-token"));
+});
+
+test("DNS writes use exact names and read-after-write, rejecting ambiguity", async () => {
+  const f = fixture();
+  await run(cf("cloudflare:dns:create"), f.deps);
+  assert.deepEqual(
+    JSON.parse(f.calls.find((call) => call.method === "POST").body),
+    f.contract.cloudflare.direct_dns_records["probe.example.com"],
+  );
+  f.contract.cloudflare.direct_dns_records["probe.example.com"].name = "elsewhere.example.com";
+  f.save();
+  await assert.rejects(run(cf("cloudflare:dns:edit"), f.deps), /target_mismatch/);
+  f.setRecords([
+    { id: "one", name: "probe.example.com" },
+    { id: "two", name: "probe.example.com" },
+  ]);
+  await assert.rejects(run(cf("cloudflare:dns:read"), f.deps), /ambiguous_dns_record/);
+});
+
+test("SSH read needs no provider token and rejects additional unpinned keys", async () => {
+  const f = fixture();
+  delete f.env.HOSTINGER_API_TOKEN;
+  f.save();
+  const args = operation("hostinger:ssh:read", {
+    provider: "hostinger",
+    accountId: "hs",
+    vpsRole: "edge",
+    vpsId: "101",
+    hostKeySha256: "SHA256:cJ6AyISHokEeHuTfufIqhhSS0gxHZRUMDHlKvXD4FHw",
+  });
+  await run(args, f.deps);
+  const ssh = f.calls.find((call) => call.file === "ssh");
+  assert.equal(ssh.args.at(-1), "uname -s");
+  assert.equal(ssh.options.input, undefined);
+  assert.ok(ssh.args.includes("GlobalKnownHostsFile=none"));
+  assert.ok(ssh.args.includes("-F"));
+  const exec = f.deps.exec;
+  f.deps.exec = async (file, args, opts) =>
+    file === "ssh-keygen"
+      ? { code: 0, stdout: "198.51.100.7 ssh-ed25519 AAAA\n198.51.100.7 ssh-ed25519 BBBB" }
+      : exec(file, args, opts);
+  await assert.rejects(run(args, f.deps), /host_key_mismatch/);
+});
+
+test("first SSH connection writes only the key matching the preauthorized fingerprint", async () => {
+  const f = fixture();
+  f.files.delete(".local/test-known");
+  const exec = f.deps.exec;
+  f.deps.exec = async (file, args, opts) =>
+    file === "ssh-keyscan"
+      ? { code: 0, stdout: "198.51.100.7 ssh-ed25519 AAAA\n198.51.100.7 ssh-rsa BBBB" }
+      : exec(file, args, opts);
+  await run(
+    operation("hostinger:ssh:test", {
+      provider: "hostinger",
+      accountId: "hs",
+      vpsRole: "edge",
+      vpsId: "101",
+      hostKeySha256: f.contract.hostinger.vps.edge.host_key_sha256,
+    }),
+    f.deps,
+  );
+  assert.equal(f.files.get(".local/test-known"), "198.51.100.7 ssh-ed25519 AAAA\n");
+});
+
+test("creation rechecks catalog quote and aggregate budget before provisioning", async () => {
+  const f = fixture();
+  f.contract.authorization.max_cost = 50;
+  f.contract.authorization.currency = "USD";
+  const quote = {
+    catalog_item_id: "item",
+    price_id: "sku",
+    currency: "USD",
+    price_cents: 2000,
+    first_period_price_cents: 1800,
+    period: 1,
+    period_unit: "month",
+  };
+  for (const role of ["edge", "application"]) {
+    delete f.env[`TF_VAR_${role}_vps_id`];
+    f.contract.hostinger.vps[role] = { creation: { plan: "sku", quote } };
+  }
+  f.save();
+  f.files.set(".agents/config/autonomous-cloud-inputs.json", JSON.stringify(f.contract));
+  const http = f.deps.http;
+  f.deps.http = async (url, options) =>
+    url.endsWith("/virtual-machines")
+      ? { ok: true, json: async () => [] }
+      : url.includes("/billing/v1/catalog")
+        ? {
+            ok: true,
+            json: async () => [
+              {
+                id: "item",
+                prices: [
+                  {
+                    id: "sku",
+                    currency: "USD",
+                    price: 2000,
+                    first_period_price: 1800,
+                    period: 1,
+                    period_unit: "month",
+                  },
+                ],
+              },
+            ],
+          }
+        : http(url, options);
+  await run({ operation: "contract:derive", credentialsSource: "root" }, f.deps);
+  f.contract.authorization.max_cost = 39;
+  f.files.set(".agents/config/autonomous-cloud-inputs.json", JSON.stringify(f.contract));
+  await assert.rejects(
+    run({ operation: "contract:derive", credentialsSource: "root" }, f.deps),
+    /budget_exceeded/,
+  );
+});
+
+test("Terraform refuses changed binary and missing selected backend credential", async () => {
+  const f = fixture();
+  f.files.set(".local/test-terraform", "changed");
+  await assert.rejects(run(tf(), f.deps), /terraform_binary_mismatch/);
+  delete f.env.AWS_SECRET_ACCESS_KEY;
+  f.save();
+  await assert.rejects(run(tf(), f.deps), /backend_credential_unavailable/);
+  assert.ok(!f.calls.some((call) => call.args?.[0] === "init"));
+});
+
+test("Terraform checks actual backend, minimal env, exact receipt and observed resources", async () => {
+  const f = fixture();
+  const result = await run(tf(), f.deps);
+  assert.equal(result.plan_sha256, digest("reviewed-plan"));
+  const init = f.calls.find((call) => call.args?.[0] === "init");
+  assert.ok(init.args.includes("-lockfile=readonly"));
+  assert.equal(init.options.env.TF_VAR_cloudflare_zone_id, "zone");
+  assert.equal(init.options.env.AWS_SECRET_ACCESS_KEY, "state-secret");
+  assert.equal(init.options.env.UNRELATED_SECRET, undefined);
+  Object.assign(f.contract.terraform.plan, {
+    sha256: result.plan_sha256,
+    policy_result_sha256: result.policy_result_sha256,
+  });
+  f.save();
+  const args = operation("terraform:apply", {
+    planPath: f.contract.terraform.plan.path,
+    planSha256: result.plan_sha256,
+    policyResultSha256: result.policy_result_sha256,
+  });
+  assert.deepEqual((await run(args, f.deps)).targets, ["101", "102"]);
+  const changed = JSON.parse(f.files.get(f.contract.terraform.plan.policy_contract_path));
+  changed.cloudflare.dns_records.api.ttl = 60;
+  f.files.set(f.contract.terraform.plan.policy_contract_path, JSON.stringify(changed));
+  const count = f.calls.filter((call) => call.args?.[0] === "apply").length;
+  await assert.rejects(run(args, f.deps), /terraform_policy_failed/);
+  assert.equal(f.calls.filter((call) => call.args?.[0] === "apply").length, count);
+});
+
+test("a backend declaration cannot disguise initialized local state", async () => {
+  const f = fixture();
+  const exec = f.deps.exec;
+  f.deps.exec = async (file, args, opts) => {
+    const result = await exec(file, args, opts);
+    if (args[0] === "init")
+      f.files.set(
+        "infra/terraform/.terraform/terraform.tfstate",
+        JSON.stringify({ backend: { type: "local", config: {} } }),
+      );
+    return result;
+  };
+  await assert.rejects(run(tf(), f.deps), /backend_mismatch/);
+  assert.ok(!f.calls.some((call) => call.args?.[0] === "plan"));
+});
+
+test("R2 backend is scoped to the approved Cloudflare account and enables lockfiles", async () => {
+  const f = fixture();
+  const config = f.contract.terraform.plan.backend.config;
+  delete config.encrypt;
+  Object.assign(config, {
+    region: "auto",
+    endpoints: { s3: "https://cf.r2.cloudflarestorage.com" },
+    skip_credentials_validation: true,
+    skip_metadata_api_check: true,
+    skip_region_validation: true,
+    skip_requesting_account_id: true,
+    skip_s3_checksum: true,
+    use_path_style: true,
+  });
+  f.files.set(
+    "infra/terraform/backend.tf.json",
+    JSON.stringify({ terraform: { backend: { s3: config } } }),
+  );
+  f.save();
+  assert.ok((await run(tf(), f.deps)).plan_sha256);
+  config.endpoints.s3 = "https://foreign.r2.cloudflarestorage.com";
+  f.save();
+  await assert.rejects(run(tf(), f.deps), /invalid_backend_config/);
+});
+
+test("secondary policy cannot silently approve a different target set", async () => {
+  const f = fixture();
+  const policy = JSON.parse(f.files.get(f.contract.terraform.plan.policy_contract_path));
+  policy.hostinger.edge.id = "foreign";
+  f.files.set(f.contract.terraform.plan.policy_contract_path, JSON.stringify(policy));
+  await assert.rejects(run(tf(), f.deps), /policy_target_mismatch/);
+  assert.ok(!f.calls.some((call) => call.args?.[0] === "init"));
+});
+
+test("provider API logical errors stop before mutations", async () => {
+  const f = fixture();
+  f.deps.http = async () => ({ ok: true, json: async () => ({ success: false }) });
+  await assert.rejects(run(cf("cloudflare:dns:create"), f.deps), /provider_request_failed/);
+  assert.ok(!f.calls.some((call) => call.method === "POST"));
+});
+
+test("a lost DNS mutation response requires observation before a retry", async () => {
+  const f = fixture();
+  const http = f.deps.http;
+  f.deps.http = async (url, options) => {
+    const response = await http(url, options);
+    if (options.method === "POST") throw new Error("connection lost after server applied");
+    return response;
+  };
+  await assert.rejects(
+    run(cf("cloudflare:dns:create"), f.deps),
+    /remote_result_requires_reconciliation/,
+  );
+  assert.ok((await run(cf("cloudflare:dns:read"), f.deps)).targets.includes("dns-id"));
+  assert.equal(f.calls.filter((call) => call.method === "POST").length, 1);
+});
+
+test("real subprocess preserves large JSON and reports overflow and timeout", async () => {
+  const result = await execute(
+    process.execPath,
+    ["-e", "process.stdout.write(JSON.stringify({data:'x'.repeat(50000)}))"],
+    { maxOutput: 60_000 },
+  );
+  assert.equal(result.code, 0);
+  assert.equal(JSON.parse(result.stdout).data.length, 50_000);
+  const overflow = await execute(
+    process.execPath,
+    ["-e", "process.stdout.write('x'.repeat(50000))"],
+    { maxOutput: 100 },
+  );
+  assert.notEqual(overflow.code, 0);
+  assert.equal(overflow.overflow, true);
+  const timeout = await execute(process.execPath, ["-e", "setInterval(()=>{},1000)"], {
+    timeout: 100,
+  });
+  assert.notEqual(timeout.code, 0);
+  assert.equal(timeout.timedOut, true);
+});
+
+test("CLI rejects invalid and duplicate arguments with sanitized errors", () => {
+  for (const args of [
+    ["--operation", "invalid"],
+    ["--operation", "contract:derive", "--operation", "invalid"],
+  ]) {
+    const result = spawnSync(process.execPath, [".agents/tools/cloud-runner.mjs", ...args], {
+      cwd: root,
+      encoding: "utf8",
+    });
+    assert.notEqual(result.status, 0);
+    assert.deepEqual(JSON.parse(result.stderr), { ok: false, code: "invalid_arguments" });
+  }
+});