openlattice-fly 0.0.3

package/tests/fly-provider.test.ts

@@ -0,0 +1,538 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { FlyProvider } from "../src/fly-provider";
+
+// ── Mock fetch ──────────────────────────────────────────────────────
+
+const mocks = vi.hoisted(() => {
+  const mockFetch = vi.fn();
+  return { mockFetch };
+});
+
+vi.stubGlobal("fetch", mocks.mockFetch);
+
+// ── Helpers ─────────────────────────────────────────────────────────
+
+function mockFetchResponse(
+  status: number,
+  body: unknown,
+  headers?: Record<string, string>
+) {
+  return {
+    ok: status >= 200 && status < 300,
+    status,
+    headers: {
+      get: (key: string) => headers?.[key] ?? null,
+    },
+    json: () => Promise.resolve(body),
+    text: () => Promise.resolve(JSON.stringify(body)),
+  };
+}
+
+function setupDefaultMocks() {
+  mocks.mockFetch.mockImplementation((url: string, opts?: RequestInit) => {
+    const method = opts?.method ?? "GET";
+    const path = new URL(url).pathname;
+
+    // POST /machines — create
+    if (method === "POST" && path.endsWith("/machines")) {
+      return Promise.resolve(
+        mockFetchResponse(200, {
+          id: "mach_test123",
+          name: "test-machine",
+          state: "started",
+          region: "ord",
+          created_at: "2024-01-01T00:00:00Z",
+        })
+      );
+    }
+
+    // GET /machines/{id}/wait — wait for state
+    if (method === "GET" && path.includes("/wait")) {
+      return Promise.resolve(mockFetchResponse(200, {}));
+    }
+
+    // GET /machines/{id} — inspect
+    if (method === "GET" && path.match(/\/machines\/[^/]+$/)) {
+      return Promise.resolve(
+        mockFetchResponse(200, {
+          id: "mach_test123",
+          state: "started",
+          region: "ord",
+          created_at: "2024-01-01T00:00:00Z",
+        })
+      );
+    }
+
+    // GET /machines — list
+    if (method === "GET" && path.endsWith("/machines")) {
+      return Promise.resolve(mockFetchResponse(200, []));
+    }
+
+    // POST /machines/{id}/exec — exec
+    if (method === "POST" && path.includes("/exec")) {
+      return Promise.resolve(
+        mockFetchResponse(200, {
+          exit_code: 0,
+          stdout: "",
+          stderr: "",
+        })
+      );
+    }
+
+    // DELETE /machines/{id} — destroy
+    if (method === "DELETE") {
+      return Promise.resolve(mockFetchResponse(200, { ok: true }));
+    }
+
+    // POST /machines/{id}/stop
+    if (method === "POST" && path.includes("/stop")) {
+      return Promise.resolve(mockFetchResponse(200, { ok: true }));
+    }
+
+    // POST /machines/{id}/start
+    if (method === "POST" && path.includes("/start")) {
+      return Promise.resolve(mockFetchResponse(200, {}));
+    }
+
+    // POST /machines/{id}/suspend
+    if (method === "POST" && path.includes("/suspend")) {
+      return Promise.resolve(mockFetchResponse(200, { ok: true }));
+    }
+
+    return Promise.resolve(mockFetchResponse(200, {}));
+  });
+}
+
+// ── Tests ───────────────────────────────────────────────────────────
+
+describe("FlyProvider", () => {
+  let provider: FlyProvider;
+
+  const defaultConfig = {
+    appName: "test-app",
+    apiToken: "test-token",
+  };
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    setupDefaultMocks();
+    provider = new FlyProvider(defaultConfig);
+  });
+
+  describe("constructor", () => {
+    it("sets name to 'fly'", () => {
+      expect(provider.name).toBe("fly");
+    });
+
+    it("declares expected capabilities", () => {
+      expect(provider.capabilities.restart).toBe(true);
+      expect(provider.capabilities.pause).toBe(true);
+      expect(provider.capabilities.snapshot).toBe(false);
+      expect(provider.capabilities.gpu).toBe(true);
+      expect(provider.capabilities.logs).toBe(false);
+      expect(provider.capabilities.tailscale).toBe(true);
+      expect(provider.capabilities.architectures).toContain("x86_64");
+    });
+
+    it("throws if appName is missing", () => {
+      expect(
+        () => new FlyProvider({ appName: "" } as any)
+      ).toThrow("appName");
+    });
+
+    it("throws if API token is missing", () => {
+      const origEnv = process.env.FLY_API_TOKEN;
+      delete process.env.FLY_API_TOKEN;
+      expect(
+        () => new FlyProvider({ appName: "test" })
+      ).toThrow("API token");
+      process.env.FLY_API_TOKEN = origEnv;
+    });
+  });
+
+  describe("provision", () => {
+    it("creates a machine and returns node info", async () => {
+      const node = await provider.provision({
+        runtime: { image: "python:3.12" },
+      });
+
+      expect(node.externalId).toBe("mach_test123");
+      expect(mocks.mockFetch).toHaveBeenCalled();
+    });
+
+    it("sends correct image in machine config", async () => {
+      await provider.provision({
+        runtime: { image: "nginx:latest" },
+      });
+
+      const createCall = mocks.mockFetch.mock.calls.find(
+        (c: any[]) => c[1]?.method === "POST" && c[0].includes("/machines") && !c[0].includes("/")
+      );
+      // Check any POST to /machines
+      const postCalls = mocks.mockFetch.mock.calls.filter(
+        (c: any[]) => c[1]?.method === "POST"
+      );
+      const body = JSON.parse(postCalls[0][1].body);
+      expect(body.config.image).toBe("nginx:latest");
+    });
+
+    it("uses sleep inf as default command", async () => {
+      await provider.provision({
+        runtime: { image: "python:3.12" },
+      });
+
+      const postCalls = mocks.mockFetch.mock.calls.filter(
+        (c: any[]) => c[1]?.method === "POST" && !c[0].includes("/wait")
+      );
+      const body = JSON.parse(postCalls[0][1].body);
+      expect(body.config.init.exec).toEqual(["/bin/sleep", "inf"]);
+    });
+
+    it("uses custom command when provided", async () => {
+      await provider.provision({
+        runtime: {
+          image: "python:3.12",
+          command: ["python", "server.py"],
+        },
+      });
+
+      const postCalls = mocks.mockFetch.mock.calls.filter(
+        (c: any[]) => c[1]?.method === "POST" && !c[0].includes("/wait")
+      );
+      const body = JSON.parse(postCalls[0][1].body);
+      expect(body.config.init.exec).toEqual(["python", "server.py"]);
+    });
+
+    it("sets resource limits", async () => {
+      await provider.provision({
+        runtime: { image: "python:3.12" },
+        cpu: { cores: 2 },
+        memory: { sizeGiB: 4 },
+      });
+
+      const postCalls = mocks.mockFetch.mock.calls.filter(
+        (c: any[]) => c[1]?.method === "POST" && !c[0].includes("/wait")
+      );
+      const body = JSON.parse(postCalls[0][1].body);
+      expect(body.config.guest.cpus).toBe(2);
+      expect(body.config.guest.memory_mb).toBe(4096);
+    });
+
+    it("sets GPU when specified", async () => {
+      await provider.provision({
+        runtime: { image: "python:3.12" },
+        gpu: { type: "a100-80gb", count: 1 },
+      });
+
+      const postCalls = mocks.mockFetch.mock.calls.filter(
+        (c: any[]) => c[1]?.method === "POST" && !c[0].includes("/wait")
+      );
+      const body = JSON.parse(postCalls[0][1].body);
+      expect(body.config.guest.gpu_kind).toBe("a100-80gb");
+    });
+
+    it("includes endpoints when ports are specified", async () => {
+      const node = await provider.provision({
+        runtime: { image: "nginx" },
+        network: { ports: [{ port: 80 }] },
+      });
+
+      expect(node.endpoints).toHaveLength(1);
+      expect(node.endpoints[0].port).toBe(80);
+    });
+
+    it("waits for machine to start", async () => {
+      await provider.provision({
+        runtime: { image: "python:3.12" },
+      });
+
+      const waitCalls = mocks.mockFetch.mock.calls.filter(
+        (c: any[]) => c[0].includes("/wait")
+      );
+      expect(waitCalls).toHaveLength(1);
+    });
+
+    it("calls tailscale up via exec when tailscaleAuthKey is set", async () => {
+      await provider.provision({
+        runtime: { image: "tailscale/fly" },
+        network: { tailscaleAuthKey: "tskey-auth-abc123" },
+      });
+
+      // After machine create + wait, there should be an exec call
+      const execCalls = mocks.mockFetch.mock.calls.filter(
+        (c: any[]) => c[1]?.method === "POST" && c[0].includes("/exec")
+      );
+      expect(execCalls.length).toBeGreaterThanOrEqual(1);
+      const execBody = JSON.parse(execCalls[0][1].body);
+      expect(execBody.cmd.join(" ")).toContain("tskey-auth-abc123");
+    });
+  });
+
+  describe("exec", () => {
+    it("executes command via Machines API", async () => {
+      mocks.mockFetch.mockImplementation((url: string, opts?: RequestInit) => {
+        if (opts?.method === "POST" && url.includes("/exec")) {
+          return Promise.resolve(
+            mockFetchResponse(200, {
+              exit_code: 0,
+              stdout: "hello world\n",
+              stderr: "",
+            })
+          );
+        }
+        // Default mocks for provision
+        if (opts?.method === "POST" && url.endsWith("/machines")) {
+          return Promise.resolve(
+            mockFetchResponse(200, {
+              id: "mach_exec",
+              state: "started",
+              region: "ord",
+            })
+          );
+        }
+        if (url.includes("/wait")) {
+          return Promise.resolve(mockFetchResponse(200, {}));
+        }
+        return Promise.resolve(mockFetchResponse(200, {}));
+      });
+
+      const node = await provider.provision({
+        runtime: { image: "python:3.12" },
+      });
+
+      const result = await provider.exec(node.externalId, [
+        "echo",
+        "hello world",
+      ]);
+
+      expect(result.exitCode).toBe(0);
+      expect(result.stdout).toContain("hello world");
+    });
+
+    it("captures stderr and exit codes", async () => {
+      mocks.mockFetch.mockImplementation((url: string, opts?: RequestInit) => {
+        if (opts?.method === "POST" && url.includes("/exec")) {
+          return Promise.resolve(
+            mockFetchResponse(200, {
+              exit_code: 42,
+              stdout: "",
+              stderr: "error occurred\n",
+            })
+          );
+        }
+        if (opts?.method === "POST" && url.endsWith("/machines")) {
+          return Promise.resolve(
+            mockFetchResponse(200, { id: "mach1", state: "started", region: "ord" })
+          );
+        }
+        if (url.includes("/wait")) {
+          return Promise.resolve(mockFetchResponse(200, {}));
+        }
+        return Promise.resolve(mockFetchResponse(200, {}));
+      });
+
+      const node = await provider.provision({
+        runtime: { image: "python:3.12" },
+      });
+
+      const result = await provider.exec(node.externalId, [
+        "sh",
+        "-c",
+        "exit 42",
+      ]);
+
+      expect(result.exitCode).toBe(42);
+      expect(result.stderr).toContain("error occurred");
+    });
+
+    it("wraps command with cwd and env", async () => {
+      const node = await provider.provision({
+        runtime: { image: "python:3.12" },
+      });
+
+      await provider.exec(node.externalId, ["ls"], {
+        cwd: "/app",
+        env: { FOO: "bar" },
+      });
+
+      const execCall = mocks.mockFetch.mock.calls.find(
+        (c: any[]) => c[0].includes("/exec")
+      );
+      const body = JSON.parse(execCall[1].body);
+      expect(body.cmd).toEqual([
+        "sh",
+        "-c",
+        "cd /app && export FOO='bar' && ls",
+      ]);
+    });
+  });
+
+  describe("destroy", () => {
+    it("deletes machine with force=true", async () => {
+      const node = await provider.provision({
+        runtime: { image: "python:3.12" },
+      });
+
+      await provider.destroy(node.externalId);
+
+      const deleteCall = mocks.mockFetch.mock.calls.find(
+        (c: any[]) => c[1]?.method === "DELETE"
+      );
+      expect(deleteCall).toBeDefined();
+      expect(deleteCall[0]).toContain("force=true");
+    });
+
+    it("is idempotent for 404", async () => {
+      mocks.mockFetch.mockImplementation((url: string, opts?: RequestInit) => {
+        if (opts?.method === "DELETE") {
+          const err = mockFetchResponse(404, { error: "not found" });
+          return Promise.resolve(err);
+        }
+        return Promise.resolve(mockFetchResponse(200, {}));
+      });
+
+      await expect(
+        provider.destroy("nonexistent")
+      ).resolves.toBeUndefined();
+    });
+  });
+
+  describe("inspect", () => {
+    it("returns running for started machine", async () => {
+      const status = await provider.inspect("mach_test123");
+      expect(status.status).toBe("running");
+    });
+
+    it("returns paused for suspended machine", async () => {
+      mocks.mockFetch.mockImplementation((url: string, opts?: RequestInit) => {
+        if (url.includes("/machines/") && opts?.method !== "POST") {
+          return Promise.resolve(
+            mockFetchResponse(200, {
+              id: "mach_sus",
+              state: "suspended",
+              region: "ord",
+            })
+          );
+        }
+        return Promise.resolve(mockFetchResponse(200, {}));
+      });
+
+      const status = await provider.inspect("mach_sus");
+      expect(status.status).toBe("paused");
+    });
+
+    it("returns terminated for 404", async () => {
+      mocks.mockFetch.mockImplementation(() => {
+        const resp = mockFetchResponse(404, { error: "not found" });
+        return Promise.resolve(resp);
+      });
+
+      const status = await provider.inspect("nonexistent");
+      expect(status.status).toBe("terminated");
+    });
+  });
+
+  describe("stop / start", () => {
+    it("stop sends stop request", async () => {
+      const node = await provider.provision({
+        runtime: { image: "python:3.12" },
+      });
+
+      await provider.stop(node.externalId);
+
+      const stopCall = mocks.mockFetch.mock.calls.find(
+        (c: any[]) => c[0].includes("/stop")
+      );
+      expect(stopCall).toBeDefined();
+    });
+
+    it("start sends start request and waits", async () => {
+      const node = await provider.provision({
+        runtime: { image: "python:3.12" },
+      });
+
+      await provider.start(node.externalId);
+
+      const startCall = mocks.mockFetch.mock.calls.find(
+        (c: any[]) => c[0].includes("/start")
+      );
+      expect(startCall).toBeDefined();
+    });
+  });
+
+  describe("pause / resume", () => {
+    it("pause sends suspend request", async () => {
+      const node = await provider.provision({
+        runtime: { image: "python:3.12" },
+      });
+
+      await provider.pause(node.externalId);
+
+      const suspendCall = mocks.mockFetch.mock.calls.find(
+        (c: any[]) => c[0].includes("/suspend")
+      );
+      expect(suspendCall).toBeDefined();
+    });
+
+    it("resume sends start request", async () => {
+      const node = await provider.provision({
+        runtime: { image: "python:3.12" },
+      });
+
+      await provider.resume(node.externalId);
+
+      const startCall = mocks.mockFetch.mock.calls.find(
+        (c: any[]) => c[0].includes("/start")
+      );
+      expect(startCall).toBeDefined();
+    });
+  });
+
+  describe("healthCheck", () => {
+    it("returns healthy when API is reachable", async () => {
+      const health = await provider.healthCheck();
+      expect(health.healthy).toBe(true);
+      expect(health.latencyMs).toBeTypeOf("number");
+    });
+
+    it("returns unhealthy when API fails", async () => {
+      mocks.mockFetch.mockRejectedValue(new Error("network error"));
+
+      const health = await provider.healthCheck();
+      expect(health.healthy).toBe(false);
+      expect(health.message).toContain("unreachable");
+    });
+  });
+
+  describe("getExtension", () => {
+    it("returns network extension", async () => {
+      const node = await provider.provision({
+        runtime: { image: "nginx" },
+      });
+
+      const ext = provider.getExtension(node.externalId, "network");
+      expect(ext).toBeDefined();
+      expect(ext).toHaveProperty("getUrl");
+    });
+
+    it("network extension returns fly.dev URL", async () => {
+      const node = await provider.provision({
+        runtime: { image: "nginx" },
+      });
+
+      const ext = provider.getExtension(node.externalId, "network")!;
+      const url = await ext.getUrl(80);
+      expect(url).toContain("test-app.fly.dev");
+    });
+
+    it("returns undefined for unsupported extensions", async () => {
+      const node = await provider.provision({
+        runtime: { image: "python:3.12" },
+      });
+
+      expect(
+        provider.getExtension(node.externalId, "files")
+      ).toBeUndefined();
+    });
+  });
+});

package/tests/integration.test.ts

@@ -0,0 +1,118 @@
+import { describe, it, expect, beforeAll, afterEach } from "vitest";
+import { FlyProvider } from "../src/fly-provider";
+
+const HAS_FLY =
+  !!process.env.FLY_API_TOKEN && !!process.env.FLY_APP_NAME;
+
+describe.skipIf(!HAS_FLY)("FlyProvider integration", () => {
+  let provider: FlyProvider;
+  const toCleanup: string[] = [];
+
+  beforeAll(() => {
+    provider = new FlyProvider({
+      appName: process.env.FLY_APP_NAME!,
+      apiToken: process.env.FLY_API_TOKEN,
+      region: process.env.FLY_REGION ?? "ord",
+    });
+  });
+
+  afterEach(async () => {
+    for (const id of toCleanup) {
+      try {
+        await provider.destroy(id);
+      } catch {
+        /* best-effort */
+      }
+    }
+    toCleanup.length = 0;
+  });
+
+  it(
+    "provisions, execs, and destroys",
+    async () => {
+      const node = await provider.provision({
+        runtime: { image: "alpine:3.19" },
+      });
+      toCleanup.push(node.externalId);
+
+      expect(node.externalId).toBeTruthy();
+
+      const result = await provider.exec(node.externalId, [
+        "echo",
+        "hello from fly",
+      ]);
+      expect(result.exitCode).toBe(0);
+      expect(result.stdout).toContain("hello from fly");
+
+      await provider.destroy(node.externalId);
+      toCleanup.pop();
+
+      const status = await provider.inspect(node.externalId);
+      expect(status.status).toBe("terminated");
+    },
+    120_000
+  );
+
+  it(
+    "stop and start",
+    async () => {
+      const node = await provider.provision({
+        runtime: { image: "alpine:3.19" },
+      });
+      toCleanup.push(node.externalId);
+
+      await provider.stop(node.externalId);
+      const stopped = await provider.inspect(node.externalId);
+      expect(stopped.status).toBe("stopped");
+
+      await provider.start(node.externalId);
+      const started = await provider.inspect(node.externalId);
+      expect(started.status).toBe("running");
+    },
+    120_000
+  );
+
+  it(
+    "pause and resume (suspend)",
+    async () => {
+      const node = await provider.provision({
+        runtime: { image: "alpine:3.19" },
+        memory: { sizeGiB: 0.25 }, // Must be <= 2GB for suspend
+      });
+      toCleanup.push(node.externalId);
+
+      await provider.pause(node.externalId);
+      const paused = await provider.inspect(node.externalId);
+      expect(paused.status).toBe("paused");
+
+      await provider.resume(node.externalId);
+      const resumed = await provider.inspect(node.externalId);
+      expect(resumed.status).toBe("running");
+    },
+    120_000
+  );
+
+  it(
+    "healthCheck returns healthy",
+    async () => {
+      const health = await provider.healthCheck();
+      expect(health.healthy).toBe(true);
+    },
+    30_000
+  );
+
+  it(
+    "destroy is idempotent",
+    async () => {
+      const node = await provider.provision({
+        runtime: { image: "alpine:3.19" },
+      });
+
+      await provider.destroy(node.externalId);
+      await expect(
+        provider.destroy(node.externalId)
+      ).resolves.toBeUndefined();
+    },
+    120_000
+  );
+});

package/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "commonjs",
+    "declaration": true,
+    "outDir": "dist",
+    "rootDir": "src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "moduleResolution": "node"
+  },
+  "include": ["src"]
+}