@mycadet/gateway 0.12.10 → 0.13.0

package/src/__tests__/auth-fallback-count-tracker.test.ts

@@ -1,92 +0,0 @@
-import { describe, expect, test } from "bun:test";
-
-import { AuthFallbackCountTracker } from "../auth-fallback-count-tracker.js";
-
-describe("AuthFallbackCountTracker", () => {
-  test("increments per (guard, path, failureKind) key", () => {
-    const t = new AuthFallbackCountTracker(0);
-    t.increment("edge", "/v1/chat", "missing_authorization");
-    t.increment("edge", "/v1/chat", "missing_authorization");
-    t.increment("edge", "/v1/chat", "token_validation_failed");
-    t.increment("edge-guardian", "/v1/chat", "missing_authorization");
-
-    const snap = t.snapshot();
-    expect(snap.length).toBe(3);
-    const find = (g: string, p: string, f: string) =>
-      snap.find((c) => c.guard === g && c.path === p && c.failureKind === f)
-        ?.count;
-    expect(find("edge", "/v1/chat", "missing_authorization")).toBe(2);
-    expect(find("edge", "/v1/chat", "token_validation_failed")).toBe(1);
-    expect(find("edge-guardian", "/v1/chat", "missing_authorization")).toBe(1);
-  });
-
-  test("drain returns the window + counts and resets", () => {
-    const t = new AuthFallbackCountTracker(1000);
-    t.increment("edge", "/v1/a", "missing_authorization");
-    t.increment("edge", "/v1/a", "missing_authorization");
-
-    const batch = t.drain(2000);
-    expect(batch.windowStart).toBe(1000);
-    expect(batch.windowEnd).toBe(2000);
-    expect(batch.counts).toEqual([
-      {
-        guard: "edge",
-        path: "/v1/a",
-        failureKind: "missing_authorization",
-        count: 2,
-      },
-    ]);
-
-    // Drained — tracker is empty and the window is re-anchored to the drain.
-    expect(t.snapshot()).toEqual([]);
-    const empty = t.drain(3000);
-    expect(empty.counts).toEqual([]);
-    expect(empty.windowStart).toBe(2000);
-    expect(empty.windowEnd).toBe(3000);
-  });
-
-  test("an empty drain leaves the window start anchored", () => {
-    const t = new AuthFallbackCountTracker(1000);
-    // Nothing recorded yet — draining must not shift windowStart forward.
-    expect(t.drain(2000)).toMatchObject({ windowStart: 1000, windowEnd: 2000 });
-    t.increment("edge", "/v1/a", "missing_authorization");
-    expect(t.drain(3000).windowStart).toBe(1000);
-  });
-
-  test("merge folds a drained batch back in", () => {
-    const t = new AuthFallbackCountTracker(0);
-    t.increment("edge", "/v1/a", "missing_authorization");
-    const batch = t.drain(100);
-
-    // Simulate a failed flush: counts come back, plus a newer count for the
-    // same key that accumulated after the drain.
-    t.increment("edge", "/v1/a", "missing_authorization");
-    t.merge(batch.counts);
-
-    const snap = t.snapshot();
-    expect(snap.length).toBe(1);
-    expect(snap[0].count).toBe(2);
-  });
-
-  test("caps distinct keys but keeps counting existing ones", () => {
-    const t = new AuthFallbackCountTracker(0);
-    // MAX_TRACKED_KEYS is 10_000; exceed it with distinct paths.
-    for (let i = 0; i < 10_050; i++) {
-      t.increment("edge", `/v1/p${i}`, "missing_authorization");
-    }
-    const snap = t.snapshot();
-    expect(snap.length).toBe(10_000);
-
-    // An already-tracked key still increments past the cap.
-    t.increment("edge", "/v1/p0", "missing_authorization");
-    expect(t.snapshot().find((c) => c.path === "/v1/p0")?.count).toBe(2);
-  });
-
-  test("reset clears counts", () => {
-    const t = new AuthFallbackCountTracker(0);
-    t.increment("edge", "/v1/a", "missing_authorization");
-    t.reset(500);
-    expect(t.snapshot()).toEqual([]);
-    expect(t.drain(600).windowStart).toBe(500);
-  });
-});

package/src/__tests__/auth-fallback-reporter.test.ts

@@ -1,101 +0,0 @@
-import { describe, expect, mock, test } from "bun:test";
-
-import { AuthFallbackCountTracker } from "../auth-fallback-count-tracker.js";
-import { AuthFallbackReporter } from "../auth-fallback-reporter.js";
-
-const BASE_URL = "http://127.0.0.1:7821";
-
-function makeReporter(
-  tracker: AuthFallbackCountTracker,
-  fetchImpl: typeof import("../fetch.js").fetchImpl,
-) {
-  return new AuthFallbackReporter({
-    tracker,
-    baseUrl: BASE_URL,
-    intervalMs: 60_000,
-    fetchImpl,
-    mintToken: () => "test-service-token",
-  });
-}
-
-describe("AuthFallbackReporter", () => {
-  test("does nothing when there is nothing to flush", async () => {
-    const tracker = new AuthFallbackCountTracker(0);
-    const fetchMock = mock(async () => new Response("{}", { status: 200 }));
-    await makeReporter(tracker, fetchMock as never).flush();
-    expect(fetchMock).not.toHaveBeenCalled();
-  });
-
-  test("drains and POSTs the counts to the daemon route with a service token", async () => {
-    const tracker = new AuthFallbackCountTracker(0);
-    tracker.increment("edge", "/v1/chat", "missing_authorization");
-    tracker.increment("edge", "/v1/chat", "missing_authorization");
-    tracker.increment("edge-guardian", "/v1/sync", "guardian_mismatch");
-
-    const fetchMock = mock(async () => new Response("{}", { status: 200 }));
-    await makeReporter(tracker, fetchMock as never).flush();
-
-    expect(fetchMock).toHaveBeenCalledTimes(1);
-    const [url, init] = fetchMock.mock.calls[0] as unknown as [
-      string,
-      RequestInit,
-    ];
-    expect(url).toBe(`${BASE_URL}/v1/internal/telemetry/auth-fallback`);
-    expect(init.method).toBe("POST");
-    const headers = init.headers as Record<string, string>;
-    expect(headers["Content-Type"]).toBe("application/json");
-    expect(headers["Authorization"]).toBe("Bearer test-service-token");
-
-    const body = JSON.parse(init.body as string);
-    expect(typeof body.window_start).toBe("number");
-    expect(typeof body.window_end).toBe("number");
-    expect(body.counts).toEqual(
-      expect.arrayContaining([
-        {
-          guard: "edge",
-          path: "/v1/chat",
-          failure_kind: "missing_authorization",
-          count: 2,
-        },
-        {
-          guard: "edge-guardian",
-          path: "/v1/sync",
-          failure_kind: "guardian_mismatch",
-          count: 1,
-        },
-      ]),
-    );
-
-    // Successful flush drains the tracker.
-    expect(tracker.snapshot()).toEqual([]);
-  });
-
-  test("re-queues counts when the daemon returns a non-OK status", async () => {
-    const tracker = new AuthFallbackCountTracker(0);
-    tracker.increment("edge", "/v1/chat", "missing_authorization");
-
-    const fetchMock = mock(async () => new Response("nope", { status: 404 }));
-    await makeReporter(tracker, fetchMock as never).flush();
-
-    expect(fetchMock).toHaveBeenCalledTimes(1);
-    // Counts merged back so the next flush retries them.
-    const snap = tracker.snapshot();
-    expect(snap.length).toBe(1);
-    expect(snap[0].count).toBe(1);
-  });
-
-  test("re-queues counts when the POST throws", async () => {
-    const tracker = new AuthFallbackCountTracker(0);
-    tracker.increment("edge", "/v1/chat", "missing_authorization");
-    tracker.increment("edge", "/v1/chat", "missing_authorization");
-
-    const fetchMock = mock(async () => {
-      throw new Error("connection refused");
-    });
-    await makeReporter(tracker, fetchMock as never).flush();
-
-    const snap = tracker.snapshot();
-    expect(snap.length).toBe(1);
-    expect(snap[0].count).toBe(2);
-  });
-});

package/src/__tests__/backup-worker-cloud-mode.test.ts

@@ -1,44 +0,0 @@
-import { afterEach, expect, mock, test } from "bun:test";
-
-let exportRequested = false;
-const originalIsPlatform = process.env.IS_CLOUD;
-
-mock.module("../config-file-utils.js", () => ({
-  readConfigFileOrEmpty: () => ({
-    backup: {
-      enabled: true,
-      intervalHours: 1,
-      retention: 3,
-      offsite: { enabled: false },
-    },
-  }),
-}));
-
-mock.module("../fetch.js", () => ({
-  fetchImpl: async () => {
-    exportRequested = true;
-    throw new Error("Platform backup export must not be requested");
-  },
-}));
-
-afterEach(() => {
-  if (originalIsPlatform === undefined) {
-    delete process.env.IS_CLOUD;
-  } else {
-    process.env.IS_CLOUD = originalIsPlatform;
-  }
-  mock.restore();
-});
-
-test("platform mode disables the backup worker", async () => {
-  process.env.IS_CLOUD = "true";
-  const { startBackupWorker } = await import("../backup/backup-worker.js");
-
-  const worker = startBackupWorker({
-    assistantRuntimeBaseUrl: "http://127.0.0.1:7821",
-  });
-  await worker.runOnce();
-  worker.stop();
-
-  expect(exportRequested).toBeFalse();
-});

package/src/__tests__/backup-worker-export-timeout.test.ts

@@ -1,164 +0,0 @@
-/**
- * Regression tests for the export deadline in the backup worker.
- *
- * `fetch` resolves as soon as the response headers arrive; the bundle streams
- * in afterwards. The worker used to clear its abort timer in a `finally` on
- * that call, which left the download — the part that actually takes an hour on
- * a large workspace — with no deadline at all. A body that stalled after
- * headers hung `performBackup` forever, and with it the `snapshotInProgress`
- * mutex, so every later tick logged "snapshot already in progress" until the
- * gateway was restarted.
- *
- * These drive a response whose headers arrive normally and whose body never
- * produces a chunk, and assert the run gives up and lets go of the mutex.
- */
-
-import { mkdtemp, rm } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
-
-let localDir: string;
-
-/**
- * The failure this file guards against is a hang, which a bare `await` would
- * inherit — a regression would stall the runner instead of reporting. Race
- * every run against a deadline so it fails fast and says why.
- */
-function withDeadline<T>(work: Promise<T>, label: string): Promise<T> {
-  return Promise.race([
-    work,
-    new Promise<never>((_, reject) =>
-      setTimeout(
-        () => reject(new Error(`${label} did not settle within 10s`)),
-        10_000,
-      ),
-    ),
-  ]);
-}
-
-/**
- * Records the init the worker passed to fetch, so a test can assert on the
- * deadline options rather than waiting one out.
- */
-let lastInit: (RequestInit & { timeout?: boolean | number }) | undefined;
-
-/** A response that sends headers immediately and then never sends a chunk. */
-function stalledBodyResponse(): Response {
-  const body = new ReadableStream<Uint8Array>({
-    start(controller) {
-      // One chunk so the transfer visibly begins, then silence forever.
-      controller.enqueue(new Uint8Array([0x1f, 0x8b]));
-    },
-  });
-  return new Response(body, { status: 200 });
-}
-
-beforeEach(async () => {
-  localDir = await mkdtemp(join(tmpdir(), "backup-worker-timeout-"));
-
-  mock.module("../config-file-utils.js", () => ({
-    readConfigFileOrEmpty: () => ({
-      backup: {
-        enabled: true,
-        intervalHours: 6,
-        retention: 3,
-        // Offsite off keeps the run local: no encryption key is needed, so
-        // nothing touches the gateway security dir.
-        offsite: { enabled: false },
-        localDirectory: localDir,
-      },
-    }),
-  }));
-
-  mock.module("../auth/token-exchange.js", () => ({
-    mintServiceToken: () => "test-service-token",
-  }));
-
-  mock.module("../fetch.js", () => ({
-    fetchImpl: async (
-      _input: string | URL | Request,
-      init?: RequestInit & { timeout?: boolean | number },
-    ) => {
-      lastInit = init;
-      init?.signal?.throwIfAborted();
-      return stalledBodyResponse();
-    },
-  }));
-});
-
-afterEach(async () => {
-  mock.restore();
-  await rm(localDir, { recursive: true, force: true });
-});
-
-describe("backup export deadline", () => {
-  test("a body that stalls after headers aborts instead of hanging", async () => {
-    const { createSnapshotNow } = await import("../backup/backup-worker.js");
-
-    const startedAt = Date.now();
-    const run = withDeadline(
-      createSnapshotNow({
-        assistantRuntimeBaseUrl: "http://127.0.0.1:7821",
-        exportTimeoutMs: 300,
-      }),
-      "stalled export",
-    );
-
-    await expect(run).rejects.toThrow(/aborted|abort/i);
-    // The deadline fired rather than the call returning on its own; the guard
-    // is that this resolved at all, well inside the real 60-minute budget.
-    expect(Date.now() - startedAt).toBeLessThan(15_000);
-  }, 30_000);
-
-  test("the concurrency mutex is released after a stalled transfer", async () => {
-    const { createSnapshotNow } = await import("../backup/backup-worker.js");
-
-    const deps = {
-      assistantRuntimeBaseUrl: "http://127.0.0.1:7821",
-      exportTimeoutMs: 300,
-    };
-
-    await expect(
-      withDeadline(createSnapshotNow(deps), "first stalled export"),
-    ).rejects.toThrow();
-
-    // A wedged mutex surfaces here: the second run is refused outright rather
-    // than getting as far as its own stalled transfer.
-    const secondFailure = await withDeadline(
-      createSnapshotNow(deps),
-      "second stalled export",
-    ).then(
-      () => null,
-      (err: unknown) => (err instanceof Error ? err.message : String(err)),
-    );
-
-    expect(secondFailure).not.toBeNull();
-    expect(secondFailure).not.toContain("already in progress");
-  }, 30_000);
-});
-
-describe("backup export request options", () => {
-  test("opts out of the runtime's default request timeout", async () => {
-    // The daemon builds the entire archive before it can write a response
-    // header, so on a large workspace no header arrives for many minutes. The
-    // runtime's 300-second default would kill that request — and it is NOT
-    // extended by the abort signal below, so the explicit budget alone does
-    // not save it. This is the option that makes the budget real.
-    const { createSnapshotNow } = await import("../backup/backup-worker.js");
-
-    await expect(
-      withDeadline(
-        createSnapshotNow({
-          assistantRuntimeBaseUrl: "http://127.0.0.1:7821",
-          exportTimeoutMs: 300,
-        }),
-        "stalled export",
-      ),
-    ).rejects.toThrow();
-
-    expect(lastInit?.timeout).toBe(false);
-    // The caller's own deadline is still what governs.
-    expect(lastInit?.signal).toBeInstanceOf(AbortSignal);
-  }, 30_000);
-});

package/src/__tests__/migration-teleport-gcs-proxy.test.ts

@@ -1,216 +0,0 @@
-import { describe, test, expect, mock, afterEach } from "bun:test";
-import type { GatewayConfig } from "../config.js";
-import { initSigningKey } from "../auth/token-service.js";
-
-const TEST_SIGNING_KEY = Buffer.from("test-signing-key-at-least-32-bytes-long");
-initSigningKey(TEST_SIGNING_KEY);
-
-type FetchFn = (
-  input: string | URL | Request,
-  init?: RequestInit,
-) => Promise<Response>;
-let fetchMock: ReturnType<typeof mock<FetchFn>> = mock(
-  async () => new Response(),
-);
-
-mock.module("../fetch.js", () => ({
-  fetchImpl: (...args: Parameters<FetchFn>) => fetchMock(...args),
-}));
-
-const {
-  createMigrationExportToGcsProxyHandler,
-  createMigrationImportFromGcsProxyHandler,
-  createMigrationJobStatusProxyHandler,
-} = await import("../http/routes/migration-proxy.js");
-
-function makeConfig(overrides: Partial<GatewayConfig> = {}): GatewayConfig {
-  const merged: GatewayConfig = {
-    assistantRuntimeBaseUrl: "http://localhost:7821",
-    routingEntries: [],
-    port: 7830,
-    runtimeProxyRequireAuth: true,
-    runtimeTimeoutMs: 30000,
-    runtimeMaxRetries: 2,
-    runtimeInitialBackoffMs: 500,
-    maxWebhookPayloadBytes: 1048576,
-    logFile: { dir: undefined, retentionDays: 30 },
-    maxAttachmentBytes: {
-      telegram: 50 * 1024 * 1024,
-      slack: 100 * 1024 * 1024,
-      whatsapp: 16 * 1024 * 1024,
-      default: 50 * 1024 * 1024,
-    },
-    maxAttachmentConcurrency: 3,
-    gatewayInternalBaseUrl: "http://127.0.0.1:7830",
-    trustProxy: false,
-    ...overrides,
-  };
-  return merged;
-}
-
-afterEach(() => {
-  fetchMock = mock(async () => new Response());
-});
-
-describe("teleport-gcs migration proxies", () => {
-  test("export-to-gcs: forwards POST body to daemon and returns 202", async () => {
-    let capturedUrl: string | undefined;
-    let capturedMethod: string | undefined;
-    let capturedBody: ArrayBuffer | undefined;
-    let capturedHeaders: Headers | undefined;
-    fetchMock = mock(
-      async (input: string | URL | Request, init?: RequestInit) => {
-        capturedUrl = String(input);
-        capturedMethod = init?.method;
-        capturedBody = init?.body as ArrayBuffer;
-        capturedHeaders = init?.headers as unknown as Headers;
-        return new Response(
-          JSON.stringify({ job_id: "job-export-1", status: "pending" }),
-          {
-            status: 202,
-            headers: { "content-type": "application/json" },
-          },
-        );
-      },
-    );
-
-    const handler = createMigrationExportToGcsProxyHandler(makeConfig());
-    const bodyText = JSON.stringify({
-      upload_url: "https://storage.example/u",
-      description: "x",
-    });
-    const res = await handler(
-      new Request("http://localhost:7830/v1/migrations/export-to-gcs", {
-        method: "POST",
-        headers: {
-          authorization: "Bearer caller-token",
-          "content-type": "application/json",
-        },
-        body: bodyText,
-      }),
-    );
-
-    expect(res.status).toBe(202);
-    expect(capturedUrl).toBe(
-      "http://localhost:7821/v1/migrations/export-to-gcs",
-    );
-    expect(capturedMethod).toBe("POST");
-    expect(capturedHeaders?.get("authorization")).toMatch(/^Bearer ey/);
-    expect(capturedHeaders?.has("host")).toBe(false);
-    expect(Buffer.from(capturedBody!).toString("utf8")).toBe(bodyText);
-    expect(await res.json()).toEqual({
-      job_id: "job-export-1",
-      status: "pending",
-    });
-  });
-
-  test("import-from-gcs: forwards POST body to daemon and returns 202", async () => {
-    let capturedUrl: string | undefined;
-    let capturedMethod: string | undefined;
-    let capturedHeaders: Headers | undefined;
-    fetchMock = mock(
-      async (input: string | URL | Request, init?: RequestInit) => {
-        capturedUrl = String(input);
-        capturedMethod = init?.method;
-        capturedHeaders = init?.headers as unknown as Headers;
-        return new Response(
-          JSON.stringify({ job_id: "job-import-1", status: "pending" }),
-          {
-            status: 202,
-            headers: { "content-type": "application/json" },
-          },
-        );
-      },
-    );
-
-    const handler = createMigrationImportFromGcsProxyHandler(makeConfig());
-    const res = await handler(
-      new Request("http://localhost:7830/v1/migrations/import-from-gcs", {
-        method: "POST",
-        headers: {
-          authorization: "Bearer caller-token",
-          "content-type": "application/json",
-        },
-        body: JSON.stringify({ bundle_url: "https://storage.example/b" }),
-      }),
-    );
-
-    expect(res.status).toBe(202);
-    expect(capturedUrl).toBe(
-      "http://localhost:7821/v1/migrations/import-from-gcs",
-    );
-    expect(capturedMethod).toBe("POST");
-    expect(capturedHeaders?.get("authorization")).toMatch(/^Bearer ey/);
-  });
-
-  test("jobs/:job_id: forwards GET to daemon with encoded job id", async () => {
-    let capturedUrl: string | undefined;
-    let capturedMethod: string | undefined;
-    fetchMock = mock(
-      async (input: string | URL | Request, init?: RequestInit) => {
-        capturedUrl = String(input);
-        capturedMethod = init?.method;
-        return new Response(
-          JSON.stringify({
-            job_id: "abc/def",
-            type: "export",
-            status: "processing",
-          }),
-          {
-            status: 200,
-            headers: { "content-type": "application/json" },
-          },
-        );
-      },
-    );
-
-    const handler = createMigrationJobStatusProxyHandler(makeConfig());
-    const res = await handler(
-      new Request("http://localhost:7830/v1/migrations/jobs/abc%2Fdef"),
-      "abc/def",
-    );
-
-    expect(res.status).toBe(200);
-    expect(capturedMethod).toBe("GET");
-    expect(capturedUrl).toBe(
-      "http://localhost:7821/v1/migrations/jobs/abc%2Fdef",
-    );
-  });
-
-  test("export-to-gcs: returns 502 on upstream connection failure", async () => {
-    fetchMock = mock(async () => {
-      throw new Error("connection refused");
-    });
-
-    const handler = createMigrationExportToGcsProxyHandler(makeConfig());
-    const res = await handler(
-      new Request("http://localhost:7830/v1/migrations/export-to-gcs", {
-        method: "POST",
-        headers: { "content-type": "application/json" },
-        body: "{}",
-      }),
-    );
-
-    expect(res.status).toBe(502);
-    expect(await res.json()).toEqual({ error: "Bad Gateway" });
-  });
-
-  test("jobs/:job_id: forwards upstream non-2xx (e.g. 404 job_not_found)", async () => {
-    fetchMock = mock(
-      async () =>
-        new Response(JSON.stringify({ error: { code: "job_not_found" } }), {
-          status: 404,
-          headers: { "content-type": "application/json" },
-        }),
-    );
-
-    const handler = createMigrationJobStatusProxyHandler(makeConfig());
-    const res = await handler(
-      new Request("http://localhost:7830/v1/migrations/jobs/unknown"),
-      "unknown",
-    );
-
-    expect(res.status).toBe(404);
-    expect(await res.json()).toEqual({ error: { code: "job_not_found" } });
-  });
-});