@app-vitals/agent-runtime 0.0.0-stage → 0.1.0

package/setup.unit.test.ts

@@ -0,0 +1,286 @@
+/**
+ * Unit tests for agent/src/runtime/setup.ts — installPlugins local marketplace seam
+ *
+ * Pure logic tests: no I/O, no real binaries, injected exec doubles only.
+ */
+
+import { describe, expect, it } from "bun:test";
+import { discoverBakedMarketplaces, installPlugins } from "./setup.ts";
+
+// Explicit empty extra-marketplace list — every call in this describe block
+// must pass this (or an intentional array) instead of omitting the arg.
+// Omitting it falls through to discoverBakedMarketplaces(BAKED_MARKETPLACES_ROOT),
+// which reads the REAL /opt/shipwright/marketplaces directory on disk and makes
+// these tests depend on ambient sandbox/image state.
+const NO_EXTRA_MARKETPLACES: string[] = [];
+
+describe("installPlugins — local marketplace", () => {
+  it("registers the marketplace before installing plugins", async () => {
+    const calls: Array<{ cmd: string; args: string[] }> = [];
+    const mockExec = async (
+      cmd: string,
+      args: string[],
+      _opts: { cwd: string },
+    ) => {
+      calls.push({ cmd, args });
+      return { stdout: "", exitCode: 0 };
+    };
+
+    await installPlugins(
+      mockExec,
+      "/tmp/cwd",
+      [],
+      "/repo/root",
+      "/tmp/nonexistent-manifest.json",
+      NO_EXTRA_MARKETPLACES,
+    );
+
+    // First call must be marketplace add
+    expect(calls[0].args).toEqual([
+      "plugin",
+      "marketplace",
+      "add",
+      "/repo/root",
+    ]);
+  });
+
+  it("installs and updates shipwright@shipwright using the shipwright marketplace name", async () => {
+    const calls: Array<{ cmd: string; args: string[] }> = [];
+    const mockExec = async (
+      cmd: string,
+      args: string[],
+      _opts: { cwd: string },
+    ) => {
+      calls.push({ cmd, args });
+      return { stdout: "", exitCode: 0 };
+    };
+
+    await installPlugins(
+      mockExec,
+      "/tmp/cwd",
+      [],
+      "/repo/root",
+      "/tmp/nonexistent-manifest.json",
+      NO_EXTRA_MARKETPLACES,
+    );
+
+    // marketplace add + install + update = 3 calls
+    expect(calls).toHaveLength(3);
+    expect(calls[1].args).toEqual([
+      "plugin",
+      "install",
+      "shipwright@shipwright",
+    ]);
+    expect(calls[2].args).toEqual([
+      "plugin",
+      "update",
+      "shipwright@shipwright",
+    ]);
+  });
+
+  it("agent plugins use their own marketplace, not the local one", async () => {
+    const calls: Array<{ cmd: string; args: string[] }> = [];
+    const mockExec = async (
+      cmd: string,
+      args: string[],
+      _opts: { cwd: string },
+    ) => {
+      calls.push({ cmd, args });
+      return { stdout: "", exitCode: 0 };
+    };
+
+    await installPlugins(
+      mockExec,
+      "/tmp/cwd",
+      [{ plugin: "my-plugin", marketplace: "org/my-marketplace" }],
+      "/repo/root",
+      "/tmp/nonexistent-manifest.json",
+      NO_EXTRA_MARKETPLACES,
+    );
+
+    // marketplace add + 2 installs + 2 updates = 5 calls
+    expect(calls).toHaveLength(5);
+    const specs = calls.slice(1).map((c) => c.args[2]);
+    expect(specs).toEqual([
+      "shipwright@shipwright",
+      "my-plugin@org/my-marketplace",
+      "shipwright@shipwright",
+      "my-plugin@org/my-marketplace",
+    ]);
+  });
+
+  it("passes the repoRoot to marketplace add", async () => {
+    const calls: Array<{ cmd: string; args: string[] }> = [];
+    const mockExec = async (
+      cmd: string,
+      args: string[],
+      _opts: { cwd: string },
+    ) => {
+      calls.push({ cmd, args });
+      return { stdout: "", exitCode: 0 };
+    };
+
+    await installPlugins(
+      mockExec,
+      "/tmp/cwd",
+      [],
+      "/custom/repo/root",
+      "/tmp/nonexistent-manifest.json",
+      NO_EXTRA_MARKETPLACES,
+    );
+
+    expect(calls[0].args).toEqual([
+      "plugin",
+      "marketplace",
+      "add",
+      "/custom/repo/root",
+    ]);
+  });
+
+  it("registers extra marketplaces before the /app marketplace", async () => {
+    const calls: Array<{ cmd: string; args: string[] }> = [];
+    const mockExec = async (
+      cmd: string,
+      args: string[],
+      _opts: { cwd: string },
+    ) => {
+      calls.push({ cmd, args });
+      return { stdout: "", exitCode: 0 };
+    };
+
+    // Pass a non-existent root so discoverBakedMarketplaces can't find dirs —
+    // we inject via extraMarketplaceDirs directly instead.
+    await installPlugins(
+      mockExec,
+      "/tmp/cwd",
+      [],
+      "/repo/root",
+      "/tmp/nonexistent-manifest.json",
+      ["/opt/shipwright/marketplaces/my-marketplace"],
+    );
+
+    // Extra marketplace add must come BEFORE the /repo/root marketplace add
+    const addCalls = calls.filter((c) => c.args[1] === "marketplace");
+    expect(addCalls[0].args[3]).toBe(
+      "/opt/shipwright/marketplaces/my-marketplace",
+    );
+    expect(addCalls[1].args[3]).toBe("/repo/root");
+  });
+
+  it("is a no-op when no extra marketplace dirs exist", async () => {
+    const calls: Array<{ cmd: string; args: string[] }> = [];
+    const mockExec = async (
+      cmd: string,
+      args: string[],
+      _opts: { cwd: string },
+    ) => {
+      calls.push({ cmd, args });
+      return { stdout: "", exitCode: 0 };
+    };
+
+    await installPlugins(
+      mockExec,
+      "/tmp/cwd",
+      [],
+      "/repo/root",
+      "/tmp/nonexistent-manifest.json",
+      NO_EXTRA_MARKETPLACES,
+    );
+
+    // Only the /repo/root marketplace add — no extra adds
+    const addCalls = calls.filter((c) => c.args[1] === "marketplace");
+    expect(addCalls).toHaveLength(1);
+    expect(addCalls[0].args[3]).toBe("/repo/root");
+  });
+
+  it("never reads the real BAKED_MARKETPLACES_ROOT when extraMarketplaceDirs is injected (isolation regression)", async () => {
+    // Regression test for T-002: previously, tests that omitted the
+    // extraMarketplaceDirs arg silently fell through to
+    // discoverBakedMarketplaces(BAKED_MARKETPLACES_ROOT), which performs a
+    // real existsSync/readdirSync against /opt/shipwright/marketplaces. On any
+    // image/sandbox that bakes a marketplace there (this sandbox does), that
+    // extra ambient `marketplace add` call would silently appear before the
+    // expected calls and break exact-match assertions below.
+    //
+    // This test asserts the injected empty array wins deterministically,
+    // regardless of what (if anything) actually exists on disk at
+    // /opt/shipwright/marketplaces in the environment running the suite.
+    const calls: Array<{ cmd: string; args: string[] }> = [];
+    const mockExec = async (
+      cmd: string,
+      args: string[],
+      _opts: { cwd: string },
+    ) => {
+      calls.push({ cmd, args });
+      return { stdout: "", exitCode: 0 };
+    };
+
+    await installPlugins(
+      mockExec,
+      "/tmp/cwd",
+      [],
+      "/repo/root",
+      "/tmp/nonexistent-manifest.json",
+      NO_EXTRA_MARKETPLACES,
+    );
+
+    // Exactly one marketplace add (the built-in shipwright one) — no extra
+    // marketplace add sneaks in from real fs discovery, no matter what's
+    // actually present on disk at BAKED_MARKETPLACES_ROOT in this environment.
+    const addCalls = calls.filter((c) => c.args[1] === "marketplace");
+    expect(addCalls).toHaveLength(1);
+    expect(addCalls[0].args[3]).toBe("/repo/root");
+    // Full call count is deterministic: marketplace add + install + update = 3.
+    expect(calls).toHaveLength(3);
+  });
+});
+
+describe("discoverBakedMarketplaces", () => {
+  it("returns dirs that have .claude-plugin/marketplace.json", () => {
+    // Since discoverBakedMarketplaces uses real fs, we test with a known-absent path
+    // The actual fs-based tests live in setup.integration.test.ts.
+    // This unit test verifies the function is exported and handles absent roots.
+    const result = discoverBakedMarketplaces(
+      "/tmp/nonexistent-convention-root-abc123",
+    );
+    expect(Array.isArray(result)).toBe(true);
+    expect(result).toHaveLength(0);
+  });
+
+  it("returns empty array when conventionRoot is absent (empty string)", () => {
+    const result = discoverBakedMarketplaces("");
+    expect(result).toEqual([]);
+  });
+
+  it("returns empty array when conventionRoot does not exist", () => {
+    const result = discoverBakedMarketplaces("/opt/does-not-exist-xyz987");
+    expect(result).toEqual([]);
+  });
+});
+
+describe("resolveTemplatesDir option resolution (AEP-1.2)", () => {
+  it("resolves an absent type to the built-in templates with no env set", async () => {
+    const { resolveTemplatesDir } = await import("./setup.ts");
+    const dir = resolveTemplatesDir(undefined, "/nonexistent", () => {}, {});
+    expect(dir).toMatch(/workspace$/);
+  });
+
+  it("looks up SHIPWRIGHT_DEFAULT_AGENT_TYPE under SHIPWRIGHT_SPECIALTIES_DIR for an absent type", async () => {
+    const { resolveTemplatesDir } = await import("./setup.ts");
+    const warnings: string[] = [];
+    const dir = resolveTemplatesDir(
+      undefined,
+      "/nonexistent",
+      (m) => warnings.push(m),
+      {
+        SHIPWRIGHT_DEFAULT_AGENT_TYPE: "base",
+        SHIPWRIGHT_SPECIALTIES_DIR: "/fixture/types",
+      },
+    );
+    // Missing fixture manifest → warns naming the type, falls back built-in.
+    expect(warnings).toHaveLength(1);
+    expect(warnings[0]).toContain('"base"');
+    expect(warnings[0]).toContain("/fixture/types/base/manifest.yaml");
+    expect(dir).toMatch(/workspace$/);
+  });
+});

package/shipwright-config-client.ts

@@ -0,0 +1,36 @@
+/**
+ * agent/src/runtime/shipwright-config-client.ts
+ *
+ * - ShipwrightConfigClient — interface for DI (used by entrypoint and tests)
+ * - RecordedShipwrightConfigClient — cassette-backed double for tests
+ *
+ * The HTTP implementation was consolidated into HttpShipwrightRuntimeClient
+ * (shipwright-runtime-client.ts). Wire that via getAgentConfigBundle() as the
+ * configClient adapter in entrypoint-main.ts.
+ */
+
+import type { AgentConfigResponse } from "@app-vitals/agent-admin";
+
+// ─── Interface ────────────────────────────────────────────────────────────────
+
+export interface ShipwrightConfigClient {
+  getConfig(agentId: string): Promise<AgentConfigResponse>;
+}
+
+// ─── RecordedShipwrightConfigClient ───────────────────────────────────────────
+
+/**
+ * Cassette-backed client for tests.
+ * Returns a fixed AgentConfigResponse on every call — no network required.
+ */
+export class RecordedShipwrightConfigClient implements ShipwrightConfigClient {
+  private readonly cassette: AgentConfigResponse;
+
+  constructor(cassette: AgentConfigResponse) {
+    this.cassette = cassette;
+  }
+
+  async getConfig(_agentId: string): Promise<AgentConfigResponse> {
+    return this.cassette;
+  }
+}

package/shipwright-runtime-client.integration.test.ts

@@ -0,0 +1,336 @@
+/**
+ * agent/src/runtime/shipwright-runtime-client.integration.test.ts
+ *
+ * Integration tests for HttpShipwrightRuntimeClient.
+ * Uses injected fake fetch doubles — no global.fetch override, no mock.module().
+ */
+
+import { describe, expect, it } from "bun:test";
+import type {
+  AgentConfigResponse,
+  AgentCronJob,
+} from "@app-vitals/agent-admin";
+import {
+  HttpShipwrightRuntimeClient,
+  ShipwrightClientError,
+} from "./shipwright-runtime-client.ts";
+
+// ─── Test fixtures ─────────────────────────────────────────────────────────────
+
+const API_URL = "https://api.test.shipwright.dev";
+const API_KEY = "test-bearer-key";
+const AGENT_ID = "agent-abc-123";
+
+const SAMPLE_CONFIG: AgentConfigResponse = {
+  env: { ANTHROPIC_MODEL: "claude-sonnet-4-6" },
+  allowedTools: ["Read", "Bash"],
+  plugins: [{ marketplace: "shipwright", plugin: "my-plugin" }],
+  repos: [],
+  reviewAuthorAllowlist: [],
+  patchAuthorAllowlist: [],
+  restrictSlackToMembers: false,
+  memberEmails: [],
+  autoPostReviews: true,
+  allowSelfReview: false,
+  minConfidence: 75,
+  maxFindings: 5,
+  cleanupMergedWorktrees: true,
+  cleanupAfterDays: 14,
+};
+
+const SAMPLE_CRONS: AgentCronJob[] = [
+  {
+    id: "cron-1",
+    agentId: AGENT_ID,
+    name: "daily-brief",
+    schedule: "0 6 * * *",
+    prompt: "Run the morning brief",
+    channel: "C012345",
+    user: null,
+    silent: false,
+    enabled: true,
+    preCheck: null,
+    system: false,
+    parentCronId: null,
+    lockdownDisabledAt: null,
+    createdAt: new Date("2025-01-01T00:00:00Z"),
+    updatedAt: new Date("2025-01-01T00:00:00Z"),
+  },
+];
+
+// ─── Fake fetch helpers ────────────────────────────────────────────────────────
+
+type FetchFn = (
+  url: RequestInfo | URL,
+  init?: RequestInit,
+) => Promise<Response>;
+type CapturedCall = { url: string; method: string; headers: Headers };
+
+function fakeFetch(statusCode: number, body: unknown): FetchFn {
+  return async (_url, _init) => {
+    return new Response(JSON.stringify(body), {
+      status: statusCode,
+      headers: { "Content-Type": "application/json" },
+    });
+  };
+}
+
+function capturingFetch(
+  statusCode: number,
+  body: unknown,
+): { fn: FetchFn; calls: CapturedCall[] } {
+  const calls: CapturedCall[] = [];
+  return {
+    fn: async (urlOrReq, init) => {
+      // openapi-fetch v0.13 passes a Request object as the first argument
+      const req =
+        urlOrReq instanceof Request
+          ? urlOrReq
+          : new Request(urlOrReq as string, init);
+      calls.push({ url: req.url, method: req.method, headers: req.headers });
+      return new Response(JSON.stringify(body), {
+        status: statusCode,
+        headers: { "Content-Type": "application/json" },
+      });
+    },
+    calls,
+  };
+}
+
+// ─── getAgentConfigBundle ──────────────────────────────────────────────────────
+
+describe("HttpShipwrightRuntimeClient.getAgentConfigBundle", () => {
+  it("returns parsed AgentConfigResponse on 200", async () => {
+    const client = new HttpShipwrightRuntimeClient({
+      apiUrl: API_URL,
+      apiKey: API_KEY,
+      fetchFn: fakeFetch(200, SAMPLE_CONFIG),
+    });
+
+    const result = await client.getAgentConfigBundle(AGENT_ID);
+
+    expect(result).toEqual(SAMPLE_CONFIG);
+  });
+
+  it("throws ShipwrightClientError with statusCode 404 on 404", async () => {
+    const client = new HttpShipwrightRuntimeClient({
+      apiUrl: API_URL,
+      apiKey: API_KEY,
+      fetchFn: fakeFetch(404, { error: "Not found" }),
+    });
+
+    const err = await client.getAgentConfigBundle(AGENT_ID).catch((e) => e);
+
+    expect(err).toBeInstanceOf(ShipwrightClientError);
+    expect(err.statusCode).toBe(404);
+  });
+
+  it("throws ShipwrightClientError with statusCode 401 on 401", async () => {
+    const client = new HttpShipwrightRuntimeClient({
+      apiUrl: API_URL,
+      apiKey: API_KEY,
+      fetchFn: fakeFetch(401, { error: "Unauthorized" }),
+    });
+
+    const err = await client.getAgentConfigBundle(AGENT_ID).catch((e) => e);
+
+    expect(err).toBeInstanceOf(ShipwrightClientError);
+    expect(err.statusCode).toBe(401);
+  });
+
+  it("sends Authorization: Bearer header", async () => {
+    const { fn, calls } = capturingFetch(200, SAMPLE_CONFIG);
+    const client = new HttpShipwrightRuntimeClient({
+      apiUrl: API_URL,
+      apiKey: API_KEY,
+      fetchFn: fn,
+    });
+
+    await client.getAgentConfigBundle(AGENT_ID);
+
+    expect(calls.length).toBe(1);
+    expect(calls[0].headers.get("Authorization")).toBe(`Bearer ${API_KEY}`);
+  });
+
+  it("calls the correct URL", async () => {
+    const { fn, calls } = capturingFetch(200, SAMPLE_CONFIG);
+    const client = new HttpShipwrightRuntimeClient({
+      apiUrl: API_URL,
+      apiKey: API_KEY,
+      fetchFn: fn,
+    });
+
+    await client.getAgentConfigBundle(AGENT_ID);
+
+    expect(calls[0].url).toBe(`${API_URL}/agents/${AGENT_ID}/config`);
+  });
+});
+
+// ─── listAgentCronJobs ─────────────────────────────────────────────────────────
+
+describe("HttpShipwrightRuntimeClient.listAgentCronJobs", () => {
+  it("returns parsed AgentCronJob[] on 200", async () => {
+    const client = new HttpShipwrightRuntimeClient({
+      apiUrl: API_URL,
+      apiKey: API_KEY,
+      fetchFn: fakeFetch(200, SAMPLE_CRONS),
+    });
+
+    const result = await client.listAgentCronJobs(AGENT_ID);
+
+    expect(result.length).toBe(1);
+    expect(result[0].id).toBe("cron-1");
+  });
+
+  it("throws ShipwrightClientError with statusCode 404 on 404", async () => {
+    const client = new HttpShipwrightRuntimeClient({
+      apiUrl: API_URL,
+      apiKey: API_KEY,
+      fetchFn: fakeFetch(404, { error: "Not found" }),
+    });
+
+    const err = await client.listAgentCronJobs(AGENT_ID).catch((e) => e);
+
+    expect(err).toBeInstanceOf(ShipwrightClientError);
+    expect(err.statusCode).toBe(404);
+  });
+
+  it("throws ShipwrightClientError with statusCode 401 on 401", async () => {
+    const client = new HttpShipwrightRuntimeClient({
+      apiUrl: API_URL,
+      apiKey: API_KEY,
+      fetchFn: fakeFetch(401, { error: "Unauthorized" }),
+    });
+
+    const err = await client.listAgentCronJobs(AGENT_ID).catch((e) => e);
+
+    expect(err).toBeInstanceOf(ShipwrightClientError);
+    expect(err.statusCode).toBe(401);
+  });
+
+  it("sends Authorization: Bearer header", async () => {
+    const { fn, calls } = capturingFetch(200, SAMPLE_CRONS);
+    const client = new HttpShipwrightRuntimeClient({
+      apiUrl: API_URL,
+      apiKey: API_KEY,
+      fetchFn: fn,
+    });
+
+    await client.listAgentCronJobs(AGENT_ID);
+
+    expect(calls.length).toBe(1);
+    expect(calls[0].headers.get("Authorization")).toBe(`Bearer ${API_KEY}`);
+  });
+
+  it("calls the correct URL", async () => {
+    const { fn, calls } = capturingFetch(200, SAMPLE_CRONS);
+    const client = new HttpShipwrightRuntimeClient({
+      apiUrl: API_URL,
+      apiKey: API_KEY,
+      fetchFn: fn,
+    });
+
+    await client.listAgentCronJobs(AGENT_ID);
+
+    expect(calls[0].url).toBe(`${API_URL}/agents/${AGENT_ID}/crons`);
+  });
+});
+
+// ─── reconcileSystemCrons ──────────────────────────────────────────────────────
+
+describe("HttpShipwrightRuntimeClient.reconcileSystemCrons", () => {
+  it("resolves without error on 200", async () => {
+    const client = new HttpShipwrightRuntimeClient({
+      apiUrl: API_URL,
+      apiKey: API_KEY,
+      fetchFn: fakeFetch(200, { created: 1, updated: 0, deleted: 0 }),
+    });
+
+    await expect(
+      client.reconcileSystemCrons(AGENT_ID),
+    ).resolves.toBeUndefined();
+  });
+
+  it("throws ShipwrightClientError with statusCode 404 on 404", async () => {
+    const client = new HttpShipwrightRuntimeClient({
+      apiUrl: API_URL,
+      apiKey: API_KEY,
+      fetchFn: fakeFetch(404, { error: "Not found" }),
+    });
+
+    const err = await client.reconcileSystemCrons(AGENT_ID).catch((e) => e);
+
+    expect(err).toBeInstanceOf(ShipwrightClientError);
+    expect(err.statusCode).toBe(404);
+  });
+
+  it("throws ShipwrightClientError with statusCode 401 on 401", async () => {
+    const client = new HttpShipwrightRuntimeClient({
+      apiUrl: API_URL,
+      apiKey: API_KEY,
+      fetchFn: fakeFetch(401, { error: "Unauthorized" }),
+    });
+
+    const err = await client.reconcileSystemCrons(AGENT_ID).catch((e) => e);
+
+    expect(err).toBeInstanceOf(ShipwrightClientError);
+    expect(err.statusCode).toBe(401);
+  });
+
+  it("sends Authorization: Bearer header", async () => {
+    const { fn, calls } = capturingFetch(200, {
+      created: 0,
+      updated: 0,
+      deleted: 0,
+    });
+    const client = new HttpShipwrightRuntimeClient({
+      apiUrl: API_URL,
+      apiKey: API_KEY,
+      fetchFn: fn,
+    });
+
+    await client.reconcileSystemCrons(AGENT_ID);
+
+    expect(calls.length).toBe(1);
+    expect(calls[0].headers.get("Authorization")).toBe(`Bearer ${API_KEY}`);
+  });
+
+  it("calls the correct URL with POST method", async () => {
+    const { fn, calls } = capturingFetch(200, {
+      created: 0,
+      updated: 0,
+      deleted: 0,
+    });
+    const client = new HttpShipwrightRuntimeClient({
+      apiUrl: API_URL,
+      apiKey: API_KEY,
+      fetchFn: fn,
+    });
+
+    await client.reconcileSystemCrons(AGENT_ID);
+
+    expect(calls[0].url).toBe(`${API_URL}/agents/${AGENT_ID}/crons/reconcile`);
+    expect(calls[0].method).toBe("POST");
+  });
+
+  it("uses adminApiUrl for reconcile when provided separately", async () => {
+    const ADMIN_URL = "https://admin.test.shipwright.dev";
+    const { fn, calls } = capturingFetch(200, {
+      created: 0,
+      updated: 0,
+      deleted: 0,
+    });
+    const client = new HttpShipwrightRuntimeClient({
+      apiUrl: API_URL,
+      adminApiUrl: ADMIN_URL,
+      apiKey: API_KEY,
+      fetchFn: fn,
+    });
+
+    await client.reconcileSystemCrons(AGENT_ID);
+
+    expect(calls[0].url).toBe(
+      `${ADMIN_URL}/agents/${AGENT_ID}/crons/reconcile`,
+    );
+  });
+});