@mycadet/gateway 0.12.11 → 0.13.0

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" } });
-  });
-});