@app-vitals/agent-runtime 0.0.1 → 0.1.0

package/shipwright-runtime-client.ts

@@ -0,0 +1,118 @@
+/**
+ * agent/src/runtime/shipwright-runtime-client.ts
+ *
+ * Unified runtime client for the three agent-facing Shipwright API methods.
+ *
+ * - ShipwrightClientError — typed error with statusCode
+ * - ShipwrightRuntimeClient — interface for DI
+ * - HttpShipwrightRuntimeClient — typed HTTP implementation via openapi-fetch
+ */
+
+import type {
+  AgentConfigResponse,
+  AgentCronJob,
+} from "@app-vitals/agent-admin";
+import type { paths } from "@app-vitals/agent-lib/admin-types";
+import createClient from "openapi-fetch";
+
+type FetchFn = (
+  url: RequestInfo | URL,
+  init?: RequestInit,
+) => Promise<Response>;
+
+// ─── Error ────────────────────────────────────────────────────────────────────
+
+export class ShipwrightClientError extends Error {
+  constructor(
+    public readonly statusCode: number,
+    message: string,
+  ) {
+    super(message);
+    this.name = "ShipwrightClientError";
+  }
+}
+
+// ─── Interface ────────────────────────────────────────────────────────────────
+
+interface ShipwrightRuntimeClient {
+  getAgentConfigBundle(agentId: string): Promise<AgentConfigResponse>;
+  listAgentCronJobs(agentId: string): Promise<AgentCronJob[]>;
+  reconcileSystemCrons(agentId: string): Promise<void>;
+}
+
+// ─── HttpShipwrightRuntimeClient ──────────────────────────────────────────────
+
+export class HttpShipwrightRuntimeClient implements ShipwrightRuntimeClient {
+  private readonly client: ReturnType<typeof createClient<paths>>;
+  private readonly adminClient: ReturnType<typeof createClient<paths>>;
+
+  constructor(opts: {
+    apiUrl: string;
+    /** Base URL for admin-tier endpoints (e.g. /agents/:id/...). Defaults to apiUrl when the unified admin service serves both namespaces. */
+    adminApiUrl?: string;
+    apiKey: string;
+    fetchFn?: FetchFn;
+  }) {
+    const commonOpts = {
+      headers: {
+        Authorization: `Bearer ${opts.apiKey}`,
+        "Content-Type": "application/json",
+      },
+      ...(opts.fetchFn ? { fetch: opts.fetchFn } : {}),
+    };
+    this.client = createClient<paths>({
+      baseUrl: opts.apiUrl,
+      ...commonOpts,
+    });
+    this.adminClient = createClient<paths>({
+      baseUrl: opts.adminApiUrl ?? opts.apiUrl,
+      ...commonOpts,
+    });
+  }
+
+  async getAgentConfigBundle(agentId: string): Promise<AgentConfigResponse> {
+    const { data, error, response } = await this.client.GET(
+      "/agents/{id}/config",
+      { params: { path: { id: agentId } } },
+    );
+    if (error) {
+      throw new ShipwrightClientError(
+        response.status,
+        `GET /agents/${agentId}/config failed: ${response.status}`,
+      );
+    }
+    return data;
+  }
+
+  async listAgentCronJobs(agentId: string): Promise<AgentCronJob[]> {
+    const { data, error, response } = await this.client.GET(
+      "/agents/{id}/crons",
+      { params: { path: { id: agentId } } },
+    );
+    if (error) {
+      throw new ShipwrightClientError(
+        response.status,
+        `GET /agents/${agentId}/crons failed: ${response.status}`,
+      );
+    }
+    // The API returns ISO date strings; cast through unknown to the internal
+    // AgentCronJob type (which uses Date objects — deserialization is callers'
+    // concern, matching prior behaviour).
+    return data as unknown as AgentCronJob[];
+  }
+
+  async reconcileSystemCrons(agentId: string): Promise<void> {
+    // The reconcile endpoint only defines a 200 response in the spec, so
+    // openapi-fetch types `error` as never. Use response.ok instead.
+    const { response } = await this.adminClient.POST(
+      "/agents/{id}/crons/reconcile",
+      { params: { path: { id: agentId } } },
+    );
+    if (!response.ok) {
+      throw new ShipwrightClientError(
+        response.status,
+        `POST /agents/${agentId}/crons/reconcile failed: ${response.status}`,
+      );
+    }
+  }
+}

package/slack-account-status.unit.test.ts

@@ -0,0 +1,251 @@
+/**
+ * agent/src/runtime/slack-account-status.unit.test.ts
+ *
+ * Unit tests for SSP-8.3's account-status Slack gate: the pure
+ * isAccountPaused() predicate, plus handler-level gating for all three
+ * inbound Slack event handlers (message, app_mention, reaction_added).
+ * Mirrors slack-trial-expiry.unit.test.ts's harness.
+ */
+
+import { describe, expect, mock, test } from "bun:test";
+import {
+  type AgentAccountStatusRef,
+  createAgentAccountStatusRef,
+} from "./agent-account-status-ref.ts";
+import {
+  createSlackApp as _createSlackApp,
+  ACCOUNT_PAUSED_NOTICE,
+  isAccountPaused,
+} from "./slack.ts";
+
+function refWith(status: string | null): AgentAccountStatusRef {
+  const ref = createAgentAccountStatusRef();
+  ref.set(status);
+  return ref;
+}
+
+describe("isAccountPaused", () => {
+  test("fails open when the ref has never synced", () => {
+    expect(isAccountPaused(createAgentAccountStatusRef())).toBe(false);
+  });
+
+  test("not paused for an agent with no account (null)", () => {
+    expect(isAccountPaused(refWith(null))).toBe(false);
+  });
+
+  test("not paused for an active account", () => {
+    expect(isAccountPaused(refWith("active"))).toBe(false);
+  });
+
+  test("paused for suspended and trial_expired", () => {
+    expect(isAccountPaused(refWith("suspended"))).toBe(true);
+    expect(isAccountPaused(refWith("trial_expired"))).toBe(true);
+  });
+
+  test("self-heals once the ref syncs back to active", () => {
+    const ref = refWith("suspended");
+    expect(isAccountPaused(ref)).toBe(true);
+    ref.set("active");
+    expect(isAccountPaused(ref)).toBe(false);
+  });
+});
+
+type HandlerFn = (...args: unknown[]) => Promise<void>;
+
+let capturedMessageHandler: HandlerFn | null = null;
+let capturedMentionHandler: HandlerFn | null = null;
+let capturedReactionAddedHandler: HandlerFn | null = null;
+
+class MockApp {
+  constructor(_args: Record<string, unknown>) {
+    capturedMessageHandler = null;
+    capturedMentionHandler = null;
+    capturedReactionAddedHandler = null;
+  }
+
+  message(handler: HandlerFn) {
+    capturedMessageHandler = handler;
+  }
+
+  event(type: string, handler: HandlerFn) {
+    if (type === "app_mention") capturedMentionHandler = handler;
+    if (type === "reaction_added") capturedReactionAddedHandler = handler;
+  }
+}
+
+const mockGatingSlackConfig = {
+  botToken: "xoxb-test-token",
+  appToken: "xapp-test-token",
+  signingSecret: "test-secret",
+};
+
+function makeMockClient() {
+  return {
+    chat: {
+      postMessage: mock(async (_args: unknown) => ({ ts: "resp.ts.1" })),
+      startStream: mock(async (_args: unknown) => ({ ts: "stream.ts.1" })),
+      appendStream: mock(async (_args: unknown) => {}),
+      stopStream: mock(async (_args: unknown) => {}),
+    },
+    users: {
+      info: mock(async (_args: unknown) => ({
+        user: {
+          profile: { display_name: "Test User", email: "member@example.com" },
+          name: "testuser",
+        },
+      })),
+    },
+  };
+}
+
+function makeSay() {
+  return mock(async (_args: unknown) => ({ ts: "reply.ts.1" }));
+}
+
+function setupGatingApp(overrides: {
+  accountStatusRef: AgentAccountStatusRef;
+  runner?: (
+    message: string,
+    sessionKey?: string,
+  ) => Promise<{
+    result: string;
+    sessionId?: string;
+    streamIncomplete?: boolean;
+  }>;
+  getSessionFn?: (key: string) => Promise<string | undefined>;
+}) {
+  const runner =
+    overrides.runner ??
+    mock(async (_msg: string, _key?: string) => ({
+      result: "Claude response",
+      sessionId: "sess-1",
+    }));
+
+  _createSlackApp(
+    runner,
+    (text: string) => text,
+    (channel: string, ts: string) => `${channel}:${ts}`,
+    // biome-ignore lint/suspicious/noExplicitAny: mock factory for tests
+    (cfg) => new MockApp(cfg as Record<string, unknown>) as any,
+    mockGatingSlackConfig,
+    undefined, // sentryClient — default noop
+    async () => null, // fileDownloaderFn
+    {}, // voiceConfig
+    async () => null, // transcribeAudioFn
+    async () => null, // synthesizeSpeechFn
+    async (userId: string) => userId, // resolveUserFn (display name) — identity
+    "UBOT123", // botUserId
+    async () => ({ messages: [] }), // conversationsRepliesFn
+    overrides.getSessionFn ?? (async () => undefined), // getSessionFn
+    undefined, // blocksConverter — default
+    undefined, // chatTokenReporter — default noop
+    async () => undefined, // resolveUserEmailFn — default (irrelevant here)
+    undefined, // membershipRef — default (irrelevant here)
+    undefined, // trialExpiryRef — default (unsynced, fails open)
+    overrides.accountStatusRef,
+  );
+
+  return { runner };
+}
+
+describe("account-status gating — message handler", () => {
+  async function invokeDM(accountStatusRef: AgentAccountStatusRef) {
+    const { runner } = setupGatingApp({ accountStatusRef });
+    const client = makeMockClient();
+    const say = makeSay();
+    const message = {
+      channel: "D123",
+      ts: "111.222",
+      text: "Hello bot",
+      channel_type: "im",
+      user: "U-SENDER",
+    };
+    await capturedMessageHandler?.({ message, say, client });
+    return { runner, say };
+  }
+
+  for (const status of [null, "active"]) {
+    test(`${status ?? "no account"}: processed as today`, async () => {
+      const { runner, say } = await invokeDM(refWith(status));
+      expect(runner).toHaveBeenCalledTimes(1);
+      expect(say).not.toHaveBeenCalled();
+    });
+  }
+
+  for (const status of ["suspended", "trial_expired"]) {
+    test(`${status}: runner not called, one paused notice replied`, async () => {
+      const { runner, say } = await invokeDM(refWith(status));
+      expect(runner).not.toHaveBeenCalled();
+      expect(say).toHaveBeenCalledTimes(1);
+      const call = say.mock.calls[0]?.[0] as { text: string };
+      expect(call.text).toBe(ACCOUNT_PAUSED_NOTICE);
+    });
+  }
+
+  test("reactivation: messages are handled again after the next sync", async () => {
+    const ref = refWith("suspended");
+    expect((await invokeDM(ref)).runner).not.toHaveBeenCalled();
+    ref.set("active");
+    expect((await invokeDM(ref)).runner).toHaveBeenCalledTimes(1);
+  });
+});
+
+describe("account-status gating — app_mention handler", () => {
+  async function invokeMention(accountStatusRef: AgentAccountStatusRef) {
+    const { runner } = setupGatingApp({ accountStatusRef });
+    const client = makeMockClient();
+    const say = makeSay();
+    const event = {
+      text: "<@UBOT> do something",
+      channel: "C999",
+      ts: "222.333",
+      user: "U-SENDER",
+    };
+    await capturedMentionHandler?.({ event, say, client });
+    return { runner, say };
+  }
+
+  test("active: processed as today", async () => {
+    const { runner, say } = await invokeMention(refWith("active"));
+    expect(runner).toHaveBeenCalledTimes(1);
+    expect(say).not.toHaveBeenCalled();
+  });
+
+  test("suspended: runner not called, one paused notice replied", async () => {
+    const { runner, say } = await invokeMention(refWith("suspended"));
+    expect(runner).not.toHaveBeenCalled();
+    expect(say).toHaveBeenCalledTimes(1);
+    const call = say.mock.calls[0]?.[0] as { text: string };
+    expect(call.text).toBe(ACCOUNT_PAUSED_NOTICE);
+  });
+});
+
+describe("account-status gating — reaction_added handler", () => {
+  async function invokeReaction(accountStatusRef: AgentAccountStatusRef) {
+    const { runner } = setupGatingApp({ accountStatusRef });
+    const client = makeMockClient();
+    const event = {
+      reaction: "thumbsup",
+      item: { type: "message", channel: "D1", ts: "100.1" },
+      item_user: "UBOT123",
+      user: "U-SENDER",
+    };
+    await capturedReactionAddedHandler?.({ event, client });
+    return { runner, client };
+  }
+
+  test("active: processed as today", async () => {
+    const { runner, client } = await invokeReaction(refWith("active"));
+    expect(runner).toHaveBeenCalledTimes(1);
+    expect(client.chat.postMessage).not.toHaveBeenCalled();
+  });
+
+  test("trial_expired: runner not called, one paused notice posted", async () => {
+    const { runner, client } = await invokeReaction(refWith("trial_expired"));
+    expect(runner).not.toHaveBeenCalled();
+    expect(client.chat.postMessage).toHaveBeenCalledTimes(1);
+    const call = (client.chat.postMessage as ReturnType<typeof mock>).mock
+      .calls[0]?.[0] as { text: string };
+    expect(call.text).toBe(ACCOUNT_PAUSED_NOTICE);
+  });
+});

package/slack-bolt-client.integration.test.ts

@@ -0,0 +1,76 @@
+/**
+ * agent/src/runtime/slack-bolt-client.integration.test.ts
+ *
+ * Regression coverage for the streaming API surface SlackProgress
+ * (slack-progress.ts) now depends on unconditionally. With the
+ * SHIPWRIGHT_SLACK_THINKING_STEPS_ENABLED flag removed (TSD-1.1),
+ * streaming is the *only* mode — every agent, on every message, hits
+ * `chat.startStream`, `chat.appendStream`, and `chat.stopStream` on the
+ * client Bolt hands its event handlers (`app.client`).
+ *
+ * That client is built internally by @slack/bolt from *its own*
+ * dependency's `@slack/web-api` resolution — not the top-level
+ * `@slack/web-api` dependency declared in agent/package.json used elsewhere
+ * (e.g. the standalone `new WebClient(...)` in index.ts). This is the same
+ * class of risk the original setStatus-focused test (#2997/#3003) guarded
+ * against, now pointed at the streaming namespace: if Bolt's nested
+ * `@slack/web-api` copy ever diverges from (or predates) the top-level one
+ * and lacks these streaming methods, `app.client.chat.startStream` is
+ * `undefined` at runtime and every progress call silently fails (caught and
+ * warn-logged by SlackProgress, never crashing — see slack-progress.ts).
+ * The old setStatus/agents.sessions assertion is gone because that code
+ * path was removed with the flag.
+ *
+ * Neither existing suite catches this:
+ *   - slack-progress.unit.test.ts mocks `client.chat.startStream` etc.
+ *     directly, so it passes regardless of which @slack/web-api Bolt actually
+ *     resolves.
+ *   - slack.integration.test.ts injects a MockApp via createSlackApp's
+ *     appFactory param — it never constructs a real @slack/bolt App, so it
+ *     can't observe Bolt's real internal client shape.
+ *
+ * This test constructs a REAL @slack/bolt App (construction only — no
+ * .start(), no live socket-mode connection) with dummy credentials and
+ * asserts the resolved dependency tree actually has the streaming APIs on
+ * the client Bolt builds. This is the only test in the suite that would
+ * catch a future re-pin or transitive bump that un-dedupes the nested
+ * @slack/web-api copy from the top-level one.
+ *
+ * CPS-1.1 follow-up: Bolt 5.x's `App` constructor — independent of
+ * `socketMode`/receiver config, confirmed by reading App.js's init()
+ * (node_modules/@slack/bolt/dist/App.js) — calls `this.client.auth.test({
+ * token })` to verify the token, gated on the constructor's
+ * `tokenVerificationEnabled` option (defaults to `true`). With this suite's
+ * dummy token that call reached the real Slack API and rejected with
+ * WebAPIPlatformError("invalid_auth") shortly *after* construction
+ * returned — this test's assertion had already run and the (synchronous)
+ * test had already finished, so bun:test had no handle on that promise. It
+ * surfaced process-wide as an "Unhandled error between tests" landing in
+ * whichever file happened to be running at that moment — the root cause of
+ * the "different unrelated test fails every CI run" pattern observed on PR
+ * #3006 and #3008. `tokenVerificationEnabled: false` below disables that
+ * auth.test() call entirely, matching what this test's own docstring above
+ * already promises ("construction only ... no live connection") — the client
+ * shape assertion doesn't depend on verifying the dummy token is valid.
+ */
+
+import { describe, expect, test } from "bun:test";
+import { App } from "@slack/bolt";
+
+describe("real @slack/bolt App — client dependency resolution", () => {
+  test("app.client.chat has the streaming APIs SlackProgress depends on", () => {
+    const app = new App({
+      token: "xoxb-dummy-token",
+      appToken: "xapp-dummy-token",
+      socketMode: true,
+      signingSecret: "dummy-signing-secret",
+      tokenVerificationEnabled: false,
+    });
+
+    // The three streaming methods SlackProgress now calls unconditionally in
+    // every mode (flag removed, TSD-1.1) — see slack-progress.ts.
+    expect(typeof app.client.chat.startStream).toBe("function");
+    expect(typeof app.client.chat.appendStream).toBe("function");
+    expect(typeof app.client.chat.stopStream).toBe("function");
+  });
+});