@vellumai/assistant 0.5.3 → 0.5.5

package/src/oauth/platform-connection.test.ts

@@ -1,5 +1,6 @@
-import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
+import { describe, expect, mock, test } from "bun:test";
 
+import type { VellumPlatformClient } from "../platform/client.js";
 import { BackendError, VellumError } from "../util/errors.js";
 import {
   CredentialRequiredError,
@@ -7,40 +8,53 @@ import {
   ProviderUnreachableError,
 } from "./platform-connection.js";
 
+function makeMockClient(
+  fetchImpl?: typeof globalThis.fetch,
+): VellumPlatformClient {
+  const mockFetchFn =
+    fetchImpl ??
+    (mock(async () => {
+      return new Response(
+        JSON.stringify({ status: 200, headers: {}, body: null }),
+        { status: 200 },
+      );
+    }) as unknown as typeof globalThis.fetch);
+
+  return {
+    baseUrl: "https://platform.example.com",
+    assistantApiKey: "test-api-key",
+    platformAssistantId: "asst-abc",
+    fetch: mock(async (path: string, init?: RequestInit) => {
+      const url = `https://platform.example.com${path}`;
+      const headers = new Headers(init?.headers);
+      headers.set("Authorization", "Api-Key test-api-key");
+      return mockFetchFn(url, { ...init, headers });
+    }),
+  } as unknown as VellumPlatformClient;
+}
+
 const DEFAULT_OPTIONS = {
   id: "conn-1",
   providerKey: "integration:google",
   externalId: "ext-123",
   accountInfo: "user@example.com",
-  assistantId: "asst-abc",
-  platformBaseUrl: "https://platform.example.com",
-  apiKey: "test-api-key",
+  client: makeMockClient(),
+  connectionId: "platform-conn-123",
 };
 
 describe("PlatformOAuthConnection", () => {
-  let originalFetch: typeof globalThis.fetch;
-
-  beforeEach(() => {
-    originalFetch = globalThis.fetch;
-  });
-
-  afterEach(() => {
-    globalThis.fetch = originalFetch;
-  });
-
   test("successful proxied request", async () => {
     const upstreamBody = { messages: [{ id: "msg-1", snippet: "Hello" }] };
 
-    globalThis.fetch = mock(
-      async (url: string | URL | Request, init?: RequestInit) => {
-        expect(url).toBe(
-          "https://platform.example.com/v1/assistants/asst-abc/external-provider-proxy/google/",
+    const client = makeMockClient(
+      mock(async (url: string | URL | Request, init?: RequestInit) => {
+        expect(String(url)).toBe(
+          "https://platform.example.com/v1/assistants/asst-abc/external-provider-proxy/platform-conn-123/",
         );
         expect(init?.method).toBe("POST");
-        expect(init?.headers).toEqual({
-          Authorization: "Api-Key test-api-key",
-          "Content-Type": "application/json",
-        });
+        const headers = new Headers(init?.headers);
+        expect(headers.get("Authorization")).toBe("Api-Key test-api-key");
+        expect(headers.get("Content-Type")).toBe("application/json");
 
         const parsed = JSON.parse(init?.body as string);
         expect(parsed).toEqual({
@@ -61,10 +75,13 @@ describe("PlatformOAuthConnection", () => {
           }),
           { status: 200 },
         );
-      },
-    ) as unknown as typeof globalThis.fetch;
+      }) as unknown as typeof globalThis.fetch,
+    );
 
-    const conn = new PlatformOAuthConnection(DEFAULT_OPTIONS);
+    const conn = new PlatformOAuthConnection({
+      ...DEFAULT_OPTIONS,
+      client,
+    });
     const result = await conn.request({
       method: "GET",
       path: "/gmail/v1/users/me/messages",
@@ -77,8 +94,8 @@ describe("PlatformOAuthConnection", () => {
   });
 
   test("forwards baseUrl when provided", async () => {
-    globalThis.fetch = mock(
-      async (_url: string | URL | Request, init?: RequestInit) => {
+    const client = makeMockClient(
+      mock(async (_url: string | URL | Request, init?: RequestInit) => {
         const parsed = JSON.parse(init?.body as string);
         expect(parsed.request.baseUrl).toBe(
           "https://www.googleapis.com/calendar/v3",
@@ -88,10 +105,10 @@ describe("PlatformOAuthConnection", () => {
           JSON.stringify({ status: 200, headers: {}, body: {} }),
           { status: 200 },
         );
-      },
-    ) as unknown as typeof globalThis.fetch;
+      }) as unknown as typeof globalThis.fetch,
+    );
 
-    const conn = new PlatformOAuthConnection(DEFAULT_OPTIONS);
+    const conn = new PlatformOAuthConnection({ ...DEFAULT_OPTIONS, client });
     await conn.request({
       method: "GET",
       path: "/calendars/primary/events",
@@ -100,8 +117,8 @@ describe("PlatformOAuthConnection", () => {
   });
 
   test("omits baseUrl from envelope when not provided", async () => {
-    globalThis.fetch = mock(
-      async (_url: string | URL | Request, init?: RequestInit) => {
+    const client = makeMockClient(
+      mock(async (_url: string | URL | Request, init?: RequestInit) => {
         const parsed = JSON.parse(init?.body as string);
         expect("baseUrl" in parsed.request).toBe(false);
 
@@ -109,10 +126,10 @@ describe("PlatformOAuthConnection", () => {
           JSON.stringify({ status: 200, headers: {}, body: null }),
           { status: 200 },
         );
-      },
-    ) as unknown as typeof globalThis.fetch;
+      }) as unknown as typeof globalThis.fetch,
+    );
 
-    const conn = new PlatformOAuthConnection(DEFAULT_OPTIONS);
+    const conn = new PlatformOAuthConnection({ ...DEFAULT_OPTIONS, client });
     await conn.request({ method: "GET", path: "/some/path" });
   });
 
@@ -127,22 +144,26 @@ describe("PlatformOAuthConnection", () => {
   });
 
   test("424 response throws CredentialRequiredError", async () => {
-    globalThis.fetch = mock(async () => {
-      return new Response("", { status: 424 });
-    }) as unknown as typeof globalThis.fetch;
+    const client = makeMockClient(
+      mock(
+        async () => new Response("", { status: 424 }),
+      ) as unknown as typeof globalThis.fetch,
+    );
 
-    const conn = new PlatformOAuthConnection(DEFAULT_OPTIONS);
+    const conn = new PlatformOAuthConnection({ ...DEFAULT_OPTIONS, client });
     await expect(
       conn.request({ method: "GET", path: "/test" }),
     ).rejects.toThrow(CredentialRequiredError);
   });
 
   test("502 response throws ProviderUnreachableError", async () => {
-    globalThis.fetch = mock(async () => {
-      return new Response("", { status: 502 });
-    }) as unknown as typeof globalThis.fetch;
+    const client = makeMockClient(
+      mock(
+        async () => new Response("", { status: 502 }),
+      ) as unknown as typeof globalThis.fetch,
+    );
 
-    const conn = new PlatformOAuthConnection(DEFAULT_OPTIONS);
+    const conn = new PlatformOAuthConnection({ ...DEFAULT_OPTIONS, client });
     await expect(
       conn.request({ method: "GET", path: "/test" }),
     ).rejects.toThrow(ProviderUnreachableError);
@@ -155,36 +176,24 @@ describe("PlatformOAuthConnection", () => {
     );
   });
 
-  test("strips trailing slash from platformBaseUrl to avoid double slashes", async () => {
-    globalThis.fetch = mock(async (url: string | URL | Request) => {
-      expect(String(url)).toBe(
-        "https://platform.example.com/v1/assistants/asst-abc/external-provider-proxy/google/",
-      );
-      return new Response(
-        JSON.stringify({ status: 200, headers: {}, body: null }),
-        { status: 200 },
-      );
-    }) as unknown as typeof globalThis.fetch;
-
-    const conn = new PlatformOAuthConnection({
-      ...DEFAULT_OPTIONS,
-      platformBaseUrl: "https://platform.example.com/",
-    });
-    await conn.request({ method: "GET", path: "/test" });
-  });
-
-  test("strips integration: prefix from providerKey for slug", async () => {
-    globalThis.fetch = mock(async (url: string | URL | Request) => {
-      expect(String(url)).toContain("/external-provider-proxy/slack/");
-      return new Response(
-        JSON.stringify({ status: 200, headers: {}, body: null }),
-        { status: 200 },
-      );
-    }) as unknown as typeof globalThis.fetch;
+  test("uses connectionId in proxy URL regardless of providerKey format", async () => {
+    const client = makeMockClient(
+      mock(async (url: string | URL | Request) => {
+        expect(String(url)).toContain(
+          "/external-provider-proxy/slack-conn-456/",
+        );
+        return new Response(
+          JSON.stringify({ status: 200, headers: {}, body: null }),
+          { status: 200 },
+        );
+      }) as unknown as typeof globalThis.fetch,
+    );
 
     const conn = new PlatformOAuthConnection({
       ...DEFAULT_OPTIONS,
+      client,
       providerKey: "integration:slack",
+      connectionId: "slack-conn-456",
     });
     await conn.request({ method: "GET", path: "/test" });
   });

package/src/oauth/platform-connection.ts

@@ -1,3 +1,4 @@
+import type { VellumPlatformClient } from "../platform/client.js";
 import { BackendError } from "../util/errors.js";
 import type {
   OAuthConnection,
@@ -24,9 +25,9 @@ export interface PlatformOAuthConnectionOptions {
   providerKey: string;
   externalId: string;
   accountInfo: string | null;
-  assistantId: string;
-  platformBaseUrl: string;
-  apiKey: string;
+  client: VellumPlatformClient;
+  /** Platform-side connection ID used in the proxy URL path. */
+  connectionId: string;
 }
 
 export class PlatformOAuthConnection implements OAuthConnection {
@@ -35,18 +36,13 @@ export class PlatformOAuthConnection implements OAuthConnection {
   readonly externalId: string;
   readonly accountInfo: string | null;
 
-  private readonly assistantId: string;
-  private readonly platformBaseUrl: string;
-  private readonly apiKey: string;
+  private readonly client: VellumPlatformClient;
+  private readonly connectionId: string;
 
   constructor(options: PlatformOAuthConnectionOptions) {
-    const missing: string[] = [];
-    if (!options.platformBaseUrl) missing.push("platform base URL");
-    if (!options.apiKey) missing.push("assistant API key");
-    if (!options.assistantId) missing.push("assistant ID");
-    if (missing.length > 0) {
+    if (!options.connectionId) {
       throw new BackendError(
-        `Platform-managed connection for "${options.providerKey}" cannot be created: missing ${missing.join(", ")}. ` +
+        `Platform-managed connection for "${options.providerKey}" cannot be created: missing connection ID. ` +
           `Log in to the Vellum platform or switch to using your own OAuth app.`,
       );
     }
@@ -55,14 +51,12 @@ export class PlatformOAuthConnection implements OAuthConnection {
     this.providerKey = options.providerKey;
     this.externalId = options.externalId;
     this.accountInfo = options.accountInfo;
-    this.assistantId = options.assistantId;
-    this.platformBaseUrl = options.platformBaseUrl.replace(/\/+$/, "");
-    this.apiKey = options.apiKey;
+    this.client = options.client;
+    this.connectionId = options.connectionId;
   }
 
   async request(req: OAuthConnectionRequest): Promise<OAuthConnectionResponse> {
-    const providerSlug = this.providerKey.replace(/^integration:/, "");
-    const proxyUrl = `${this.platformBaseUrl}/v1/assistants/${this.assistantId}/external-provider-proxy/${providerSlug}/`;
+    const proxyPath = `/v1/assistants/${this.client.platformAssistantId}/external-provider-proxy/${this.connectionId}/`;
 
     const body: Record<string, unknown> = {
       request: {
@@ -75,10 +69,9 @@ export class PlatformOAuthConnection implements OAuthConnection {
       },
     };
 
-    const response = await fetch(proxyUrl, {
+    const response = await this.client.fetch(proxyPath, {
       method: "POST",
       headers: {
-        Authorization: `Api-Key ${this.apiKey}`,
         "Content-Type": "application/json",
       },
       body: JSON.stringify(body),

package/src/permissions/trust-client.ts

@@ -0,0 +1,343 @@
+/**
+ * HTTP client for the gateway's trust rule endpoints.
+ *
+ * Provides CRUD operations over trust rules stored in the gateway,
+ * replacing direct filesystem access to trust.json when the assistant
+ * runs in a containerized environment.
+ *
+ * Both async and synchronous variants are exported. The sync variants
+ * use `Bun.spawnSync` + `curl` to make blocking HTTP calls — acceptable
+ * for user-initiated write operations that are infrequent.
+ */
+
+import type { TrustRule } from "@vellumai/ces-contracts";
+
+import { getGatewayInternalBaseUrl } from "../config/env.js";
+import { mintDaemonDeliveryToken } from "../runtime/auth/token-service.js";
+import { getLogger } from "../util/logger.js";
+
+const log = getLogger("trust-client");
+
+const REQUEST_TIMEOUT_MS = 10_000;
+
+// ---------------------------------------------------------------------------
+// Result types (not in ces-contracts — local to the client)
+// ---------------------------------------------------------------------------
+
+export interface AcceptStarterBundleResult {
+  accepted: boolean;
+  rulesAdded: number;
+}
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+/**
+ * Resolve the gateway base URL for trust rule requests.
+ *
+ * Prefers the `GATEWAY_INTERNAL_URL` env var (set in Docker environments
+ * where the gateway runs in a separate container), falling back to the
+ * existing `getGatewayInternalBaseUrl()` helper for local deployments.
+ */
+function getBaseUrl(): string {
+  return process.env.GATEWAY_INTERNAL_URL ?? getGatewayInternalBaseUrl();
+}
+
+function authHeaders(): Record<string, string> {
+  return {
+    Authorization: `Bearer ${mintDaemonDeliveryToken()}`,
+    "Content-Type": "application/json",
+  };
+}
+
+/**
+ * Execute a fetch request with standard timeout and error handling.
+ * Throws a descriptive error on non-OK responses or network failures.
+ */
+async function request<T>(
+  method: string,
+  path: string,
+  body?: unknown,
+): Promise<T> {
+  const url = `${getBaseUrl()}${path}`;
+  const options: RequestInit = {
+    method,
+    headers: authHeaders(),
+    signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
+  };
+  if (body !== undefined) {
+    options.body = JSON.stringify(body);
+  }
+
+  let response: Response;
+  try {
+    response = await fetch(url, options);
+  } catch (err) {
+    log.error({ err, method, path }, "Trust rule request failed (network)");
+    throw new Error(
+      `Trust rule request failed: ${method} ${path}: ${err instanceof Error ? err.message : String(err)}`,
+    );
+  }
+
+  if (!response.ok) {
+    const text = await response.text().catch(() => "<unreadable>");
+    log.error(
+      { status: response.status, body: text, method, path },
+      "Trust rule request failed",
+    );
+    throw new Error(
+      `Trust rule request failed (${response.status}): ${method} ${path}: ${text}`,
+    );
+  }
+
+  return (await response.json()) as T;
+}
+
+/**
+ * Synchronous HTTP request via `Bun.spawnSync` + `curl`.
+ *
+ * Used by the gateway trust store adapter for write operations that must
+ * return synchronously to satisfy the `TrustStoreBackend` interface.
+ * Write operations are user-initiated and infrequent, so blocking is acceptable.
+ */
+function requestSync<T>(method: string, path: string, body?: unknown): T {
+  const url = `${getBaseUrl()}${path}`;
+  const headers = authHeaders();
+  const args: string[] = [
+    "curl",
+    "-s",
+    "-S",
+    "-X",
+    method,
+    "--max-time",
+    String(Math.ceil(REQUEST_TIMEOUT_MS / 1000)),
+    "-H",
+    `Authorization: ${headers.Authorization}`,
+    "-H",
+    "Content-Type: application/json",
+    "-w",
+    "\n%{http_code}",
+  ];
+  if (body !== undefined) {
+    args.push("-d", JSON.stringify(body));
+  }
+  args.push(url);
+
+  const proc = Bun.spawnSync(args, {
+    stdout: "pipe",
+    stderr: "pipe",
+  });
+
+  if (proc.exitCode !== 0) {
+    const stderr = proc.stderr.toString().trim();
+    log.error(
+      { exitCode: proc.exitCode, stderr, method, path },
+      "Trust rule sync request failed (curl)",
+    );
+    throw new Error(
+      `Trust rule sync request failed: ${method} ${path}: curl exit ${proc.exitCode}: ${stderr}`,
+    );
+  }
+
+  const output = proc.stdout.toString().trim();
+  // curl -w "\n%{http_code}" appends the HTTP status code on the last line
+  const lastNewline = output.lastIndexOf("\n");
+  const responseBody = lastNewline >= 0 ? output.slice(0, lastNewline) : "";
+  const statusCode = parseInt(
+    lastNewline >= 0 ? output.slice(lastNewline + 1) : output,
+    10,
+  );
+
+  if (statusCode < 200 || statusCode >= 300) {
+    log.error(
+      { status: statusCode, body: responseBody, method, path },
+      "Trust rule sync request failed",
+    );
+    throw new Error(
+      `Trust rule sync request failed (${statusCode}): ${method} ${path}: ${responseBody}`,
+    );
+  }
+
+  if (!responseBody) {
+    return {} as T;
+  }
+
+  try {
+    return JSON.parse(responseBody) as T;
+  } catch (err) {
+    log.error(
+      { err, responseBody, method, path },
+      "Failed to parse sync response JSON",
+    );
+    throw new Error(
+      `Trust rule sync request: failed to parse response: ${method} ${path}`,
+    );
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+
+/** Fetch all trust rules from the gateway. */
+export async function getAllRules(): Promise<TrustRule[]> {
+  const data = await request<{ rules: TrustRule[] }>("GET", "/v1/trust-rules");
+  return data.rules;
+}
+
+/** Create a new trust rule. */
+export async function addRule(params: {
+  tool: string;
+  pattern: string;
+  scope: string;
+  decision?: TrustRule["decision"];
+  priority?: number;
+  allowHighRisk?: boolean;
+  executionTarget?: string;
+}): Promise<TrustRule> {
+  const data = await request<{ rule: TrustRule }>(
+    "POST",
+    "/v1/trust-rules",
+    params,
+  );
+  return data.rule;
+}
+
+/** Update an existing trust rule by ID. */
+export async function updateRule(
+  id: string,
+  updates: {
+    tool?: string;
+    pattern?: string;
+    scope?: string;
+    decision?: TrustRule["decision"];
+    priority?: number;
+    allowHighRisk?: boolean;
+    executionTarget?: string;
+  },
+): Promise<TrustRule> {
+  const data = await request<{ rule: TrustRule }>(
+    "PATCH",
+    `/v1/trust-rules/${encodeURIComponent(id)}`,
+    updates,
+  );
+  return data.rule;
+}
+
+/** Remove a trust rule by ID. Returns true if the rule was found and deleted. */
+export async function removeRule(id: string): Promise<boolean> {
+  const data = await request<{ success: boolean }>(
+    "DELETE",
+    `/v1/trust-rules/${encodeURIComponent(id)}`,
+  );
+  return data.success;
+}
+
+/** Clear all user trust rules (default rules are preserved by the gateway). */
+export async function clearRules(): Promise<void> {
+  await request<{ success: boolean }>("POST", "/v1/trust-rules/clear");
+}
+
+/**
+ * Find the highest-priority matching rule for a tool invocation.
+ *
+ * @param tool      Tool name (e.g. "host_bash")
+ * @param candidates  Command candidates to match against rule patterns
+ * @param scope     Working directory scope
+ */
+export async function findMatchingRule(
+  tool: string,
+  candidates: string[],
+  scope: string,
+): Promise<TrustRule | null> {
+  const params = new URLSearchParams({
+    tool,
+    commands: candidates.join(","),
+    scope,
+  });
+  const data = await request<{ rule: TrustRule | null }>(
+    "GET",
+    `/v1/trust-rules/match?${params.toString()}`,
+  );
+  return data.rule;
+}
+
+/** Accept the starter approval bundle, seeding common low-risk allow rules. */
+export async function acceptStarterBundle(): Promise<AcceptStarterBundleResult> {
+  return request<AcceptStarterBundleResult>(
+    "POST",
+    "/v1/trust-rules/starter-bundle",
+  );
+}
+
+// ---------------------------------------------------------------------------
+// Synchronous API — used by the gateway trust store adapter
+// ---------------------------------------------------------------------------
+
+/** Fetch all trust rules from the gateway (synchronous). */
+export function getAllRulesSync(): TrustRule[] {
+  const data = requestSync<{ rules: TrustRule[] }>("GET", "/v1/trust-rules");
+  return data.rules;
+}
+
+/** Create a new trust rule (synchronous). */
+export function addRuleSync(params: {
+  tool: string;
+  pattern: string;
+  scope: string;
+  decision?: TrustRule["decision"];
+  priority?: number;
+  allowHighRisk?: boolean;
+  executionTarget?: string;
+}): TrustRule {
+  const data = requestSync<{ rule: TrustRule }>(
+    "POST",
+    "/v1/trust-rules",
+    params,
+  );
+  return data.rule;
+}
+
+/** Update an existing trust rule by ID (synchronous). */
+export function updateRuleSync(
+  id: string,
+  updates: {
+    tool?: string;
+    pattern?: string;
+    scope?: string;
+    decision?: TrustRule["decision"];
+    priority?: number;
+    allowHighRisk?: boolean;
+    executionTarget?: string;
+  },
+): TrustRule {
+  const data = requestSync<{ rule: TrustRule }>(
+    "PATCH",
+    `/v1/trust-rules/${encodeURIComponent(id)}`,
+    updates,
+  );
+  return data.rule;
+}
+
+/** Remove a trust rule by ID (synchronous). Returns true if deleted. */
+export function removeRuleSync(id: string): boolean {
+  const data = requestSync<{ success: boolean }>(
+    "DELETE",
+    `/v1/trust-rules/${encodeURIComponent(id)}`,
+  );
+  return data.success;
+}
+
+/** Clear all user trust rules (synchronous). */
+export function clearRulesSync(): void {
+  requestSync<{ success: boolean }>("POST", "/v1/trust-rules/clear");
+}
+
+/** Accept the starter approval bundle (synchronous). */
+export function acceptStarterBundleSync(): AcceptStarterBundleResult {
+  return requestSync<AcceptStarterBundleResult>(
+    "POST",
+    "/v1/trust-rules/starter-bundle",
+  );
+}