claude-code-swarm 0.3.4 → 0.3.6

package/references/swarmkit/src/hub/client.test.ts

@@ -0,0 +1,224 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { mkdirSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { randomUUID } from "node:crypto";
+import type { HubApiError as HubApiErrorType } from "./client.js";
+
+// Mock homedir so credentials go to temp dir
+let testDir: string;
+vi.mock("node:os", async () => {
+  const actual = await import("node:os");
+  return {
+    ...actual,
+    homedir: () => testDir,
+  };
+});
+
+const {
+  exchangeAuthCode,
+  getMe,
+  createHive,
+  listHives,
+  getHive,
+  startHive,
+  stopHive,
+  destroyHive,
+  getHubUrl,
+  HubApiError,
+} = await import("./client.js");
+
+const { writeCredentials } = await import("./credentials.js");
+
+beforeEach(() => {
+  testDir = join(tmpdir(), `swarmkit-client-test-${randomUUID()}`);
+  mkdirSync(testDir, { recursive: true });
+});
+
+afterEach(() => {
+  rmSync(testDir, { recursive: true, force: true });
+  delete process.env.SWARMKIT_HUB_URL;
+  vi.restoreAllMocks();
+});
+
+function mockFetch(response: unknown, status = 200) {
+  return vi.spyOn(globalThis, "fetch").mockResolvedValue({
+    ok: status >= 200 && status < 300,
+    status,
+    statusText: status === 200 ? "OK" : "Error",
+    json: async () => response,
+    headers: new Headers(),
+  } as Response);
+}
+
+describe("getHubUrl", () => {
+  it("returns default when no credentials", () => {
+    expect(getHubUrl()).toBe("https://hub.swarmkit.ai");
+  });
+
+  it("returns stored url when logged in", () => {
+    writeCredentials({ token: "t", apiUrl: "https://hub.custom.com" });
+    expect(getHubUrl()).toBe("https://hub.custom.com");
+  });
+
+  it("prefers SWARMKIT_HUB_URL env var", () => {
+    process.env.SWARMKIT_HUB_URL = "http://localhost:4000";
+    writeCredentials({ token: "t", apiUrl: "https://hub.custom.com" });
+    expect(getHubUrl()).toBe("http://localhost:4000");
+    delete process.env.SWARMKIT_HUB_URL;
+  });
+});
+
+describe("exchangeAuthCode", () => {
+  it("sends code and returns token", async () => {
+    const fetchSpy = mockFetch({ token: "jwt-123" });
+
+    const token = await exchangeAuthCode("auth-code-abc");
+    expect(token).toBe("jwt-123");
+
+    expect(fetchSpy).toHaveBeenCalledWith(
+      "https://hub.swarmkit.ai/v1/auth/code/exchange",
+      expect.objectContaining({
+        method: "POST",
+        body: JSON.stringify({ code: "auth-code-abc" }),
+      }),
+    );
+  });
+
+  it("throws HubApiError on failure", async () => {
+    mockFetch({ error: "Invalid code" }, 400);
+
+    await expect(exchangeAuthCode("bad")).rejects.toThrow(HubApiError);
+    await expect(exchangeAuthCode("bad")).rejects.toThrow("Invalid code");
+  });
+});
+
+describe("getMe", () => {
+  it("returns user profile", async () => {
+    writeCredentials({ token: "my-jwt", apiUrl: "https://hub.swarmkit.ai" });
+    const user = {
+      id: "usr_123",
+      email: "test@example.com",
+      name: "testuser",
+      avatar_url: null,
+      bio: null,
+    };
+    const fetchSpy = mockFetch(user);
+
+    const result = await getMe();
+    expect(result).toEqual(user);
+
+    // Check auth header was sent
+    const headers = fetchSpy.mock.calls[0][1]?.headers as Record<
+      string,
+      string
+    >;
+    expect(headers["Authorization"]).toBe("Bearer my-jwt");
+  });
+
+  it("throws 401 when not authenticated", async () => {
+    mockFetch({ error: "Unauthorized" }, 401);
+
+    try {
+      await getMe();
+      expect.unreachable();
+    } catch (err) {
+      expect(err).toBeInstanceOf(HubApiError);
+      expect((err as HubApiErrorType).statusCode).toBe(401);
+    }
+  });
+});
+
+describe("hive operations", () => {
+  beforeEach(() => {
+    writeCredentials({ token: "jwt", apiUrl: "https://hub.swarmkit.ai" });
+  });
+
+  const sampleHive = {
+    id: "hive_abc",
+    name: "My Hive",
+    slug: "my-hive",
+    owner_type: "user",
+    owner_id: "usr_123",
+    status: "running",
+    tier: "free",
+    endpoint_url: "https://my-hive.swarmkit.ai",
+    image_version: "latest",
+    health_status: "healthy",
+    created_at: "2025-01-01T00:00:00Z",
+    updated_at: "2025-01-01T00:00:00Z",
+  };
+
+  it("createHive sends name and tier", async () => {
+    const fetchSpy = mockFetch({ ...sampleHive, status: "provisioning" }, 201);
+
+    const hive = await createHive({ name: "My Hive", tier: "starter" });
+    expect(hive.name).toBe("My Hive");
+
+    const body = JSON.parse(fetchSpy.mock.calls[0][1]?.body as string);
+    expect(body.name).toBe("My Hive");
+    expect(body.tier).toBe("starter");
+  });
+
+  it("listHives returns array", async () => {
+    mockFetch([sampleHive]);
+    const hives = await listHives();
+    expect(hives).toHaveLength(1);
+    expect(hives[0].slug).toBe("my-hive");
+  });
+
+  it("getHive returns single hive", async () => {
+    mockFetch(sampleHive);
+    const hive = await getHive("my-hive");
+    expect(hive.slug).toBe("my-hive");
+  });
+
+  it("getHive encodes slug", async () => {
+    const fetchSpy = mockFetch(sampleHive);
+    await getHive("my hive");
+    expect(fetchSpy.mock.calls[0][0]).toContain("my%20hive");
+  });
+
+  it("startHive sends POST", async () => {
+    const fetchSpy = mockFetch(sampleHive);
+    await startHive("my-hive");
+    expect(fetchSpy.mock.calls[0][1]?.method).toBe("POST");
+    expect(fetchSpy.mock.calls[0][0]).toContain("/my-hive/start");
+  });
+
+  it("stopHive sends POST", async () => {
+    const fetchSpy = mockFetch({ ...sampleHive, status: "stopped" });
+    const hive = await stopHive("my-hive");
+    expect(hive.status).toBe("stopped");
+    expect(fetchSpy.mock.calls[0][0]).toContain("/my-hive/stop");
+  });
+
+  it("destroyHive sends DELETE", async () => {
+    const fetchSpy = mockFetch({ ...sampleHive, status: "destroyed" });
+    const hive = await destroyHive("my-hive");
+    expect(hive.status).toBe("destroyed");
+    expect(fetchSpy.mock.calls[0][1]?.method).toBe("DELETE");
+  });
+
+  it("throws 404 for missing hive", async () => {
+    mockFetch({ error: "Not found" }, 404);
+    try {
+      await getHive("nonexistent");
+      expect.unreachable();
+    } catch (err) {
+      expect(err).toBeInstanceOf(HubApiError);
+      expect((err as HubApiErrorType).statusCode).toBe(404);
+    }
+  });
+
+  it("throws 403 for tier limit exceeded", async () => {
+    mockFetch({ error: "Hive limit reached for free tier" }, 403);
+    try {
+      await createHive({ name: "Another" });
+      expect.unreachable();
+    } catch (err) {
+      expect(err).toBeInstanceOf(HubApiError);
+      expect((err as HubApiErrorType).statusCode).toBe(403);
+    }
+  });
+});

package/references/swarmkit/src/hub/client.ts

@@ -0,0 +1,185 @@
+import { readCredentials } from "./credentials.js";
+
+const DEFAULT_HUB_URL = "https://hub.swarmkit.ai";
+
+export interface HubUser {
+  id: string;
+  email: string;
+  name: string;
+  avatar_url: string | null;
+  bio: string | null;
+}
+
+export interface Hive {
+  id: string;
+  name: string;
+  slug: string;
+  owner_type: "user" | "organization";
+  owner_id: string;
+  status: HiveStatus;
+  tier: HiveTier;
+  endpoint_url: string | null;
+  image_version: string;
+  health_status: "healthy" | "unhealthy" | "unknown";
+  created_at: string;
+  updated_at: string;
+}
+
+export type HiveStatus =
+  | "provisioning"
+  | "running"
+  | "stopped"
+  | "suspended"
+  | "waking"
+  | "error"
+  | "destroyed"
+  | "destroy_failed";
+
+export type HiveTier = "free" | "starter" | "pro" | "enterprise";
+
+export interface CreateHiveOptions {
+  name: string;
+  tier?: HiveTier;
+}
+
+export class HubApiError extends Error {
+  constructor(
+    public readonly statusCode: number,
+    message: string,
+  ) {
+    super(message);
+    this.name = "HubApiError";
+  }
+}
+
+/** Get the SwarmHub base URL (serves both API at /v1 and frontend) */
+export function getHubUrl(): string {
+  return process.env.SWARMKIT_HUB_URL ?? readCredentials()?.apiUrl ?? DEFAULT_HUB_URL;
+}
+
+async function request<T>(
+  path: string,
+  options: {
+    method?: string;
+    body?: unknown;
+    token?: string;
+  } = {},
+): Promise<T> {
+  const { method = "GET", body, token } = options;
+  const url = `${getHubUrl()}${path}`;
+
+  const headers: Record<string, string> = {
+    "Accept": "application/json",
+  };
+
+  if (token) {
+    headers["Authorization"] = `Bearer ${token}`;
+  } else {
+    const creds = readCredentials();
+    if (creds?.token) {
+      headers["Authorization"] = `Bearer ${creds.token}`;
+    }
+  }
+
+  if (body !== undefined) {
+    headers["Content-Type"] = "application/json";
+  }
+
+  const response = await fetch(url, {
+    method,
+    headers,
+    body: body !== undefined ? JSON.stringify(body) : undefined,
+  });
+
+  if (!response.ok) {
+    let message: string;
+    try {
+      const err = (await response.json()) as { error?: string };
+      message = err.error ?? response.statusText;
+    } catch {
+      message = response.statusText;
+    }
+    throw new HubApiError(response.status, message);
+  }
+
+  // Handle 204 No Content
+  if (response.status === 204) {
+    return undefined as T;
+  }
+
+  return (await response.json()) as T;
+}
+
+// ─── Auth ────────────────────────────────────────────────────────────────────
+
+/** Exchange a temporary auth code for a JWT token */
+export async function exchangeAuthCode(code: string): Promise<string> {
+  const result = await request<{ token: string }>("/v1/auth/code/exchange", {
+    method: "POST",
+    body: { code },
+  });
+  return result.token;
+}
+
+/** Refresh an existing JWT token */
+export async function refreshToken(): Promise<string> {
+  const result = await request<{ token: string }>("/v1/auth/refresh", {
+    method: "POST",
+  });
+  return result.token;
+}
+
+// ─── User ────────────────────────────────────────────────────────────────────
+
+/** Get the current authenticated user */
+export async function getMe(): Promise<HubUser> {
+  return request<HubUser>("/v1/users/me");
+}
+
+// ─── Hives ───────────────────────────────────────────────────────────────────
+
+/** Create a new hive */
+export async function createHive(options: CreateHiveOptions): Promise<Hive> {
+  return request<Hive>("/v1/hives", {
+    method: "POST",
+    body: {
+      name: options.name,
+      owner_type: "user",
+      tier: options.tier ?? "free",
+    },
+  });
+}
+
+/** List all hives for the authenticated user */
+export async function listHives(): Promise<Hive[]> {
+  return request<Hive[]>("/v1/hives");
+}
+
+/** Get a single hive by slug */
+export async function getHive(slug: string): Promise<Hive> {
+  return request<Hive>(`/v1/hives/${encodeURIComponent(slug)}`);
+}
+
+/** Start a stopped hive */
+export async function startHive(slug: string): Promise<Hive> {
+  return request<Hive>(
+    `/v1/hives/${encodeURIComponent(slug)}/start`,
+    { method: "POST" },
+  );
+}
+
+/** Stop a running hive */
+export async function stopHive(slug: string): Promise<Hive> {
+  return request<Hive>(
+    `/v1/hives/${encodeURIComponent(slug)}/stop`,
+    { method: "POST" },
+  );
+}
+
+/** Destroy a hive permanently */
+export async function destroyHive(slug: string): Promise<Hive> {
+  return request<Hive>(
+    `/v1/hives/${encodeURIComponent(slug)}`,
+    { method: "DELETE" },
+  );
+}

package/references/swarmkit/src/hub/credentials.test.ts

@@ -0,0 +1,132 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import {
+  mkdirSync,
+  rmSync,
+  existsSync,
+  readFileSync,
+  writeFileSync,
+} from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { randomUUID } from "node:crypto";
+
+// Mock homedir so config writes go to a temp dir
+let testDir: string;
+vi.mock("node:os", async () => {
+  const actual = await import("node:os");
+  return {
+    ...actual,
+    homedir: () => testDir,
+  };
+});
+
+const {
+  readCredentials,
+  writeCredentials,
+  deleteCredentials,
+  isLoggedIn,
+} = await import("./credentials.js");
+
+beforeEach(() => {
+  testDir = join(tmpdir(), `swarmkit-cred-test-${randomUUID()}`);
+  mkdirSync(testDir, { recursive: true });
+});
+
+afterEach(() => {
+  rmSync(testDir, { recursive: true, force: true });
+});
+
+describe("readCredentials", () => {
+  it("returns null when no credentials file exists", () => {
+    expect(readCredentials()).toBeNull();
+  });
+
+  it("returns credentials when file exists", () => {
+    writeCredentials({
+      token: "jwt-token-123",
+      apiUrl: "https://api.swarmkit.ai",
+    });
+    const creds = readCredentials();
+    expect(creds).toEqual({
+      token: "jwt-token-123",
+      apiUrl: "https://api.swarmkit.ai",
+    });
+  });
+
+  it("returns null for malformed JSON", () => {
+    const dir = join(testDir, ".swarmkit");
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(join(dir, "credentials.json"), "not json");
+    expect(readCredentials()).toBeNull();
+  });
+
+  it("returns null when token is missing", () => {
+    const dir = join(testDir, ".swarmkit");
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(
+      join(dir, "credentials.json"),
+      JSON.stringify({ apiUrl: "https://api.swarmkit.ai" }),
+    );
+    expect(readCredentials()).toBeNull();
+  });
+});
+
+describe("writeCredentials", () => {
+  it("creates the credentials file", () => {
+    writeCredentials({
+      token: "test-token",
+      apiUrl: "https://api.example.com",
+    });
+    const path = join(testDir, ".swarmkit", "credentials.json");
+    expect(existsSync(path)).toBe(true);
+  });
+
+  it("writes valid JSON", () => {
+    writeCredentials({
+      token: "test-token",
+      apiUrl: "https://api.example.com",
+    });
+    const path = join(testDir, ".swarmkit", "credentials.json");
+    const raw = readFileSync(path, "utf-8");
+    const parsed = JSON.parse(raw);
+    expect(parsed.token).toBe("test-token");
+    expect(parsed.apiUrl).toBe("https://api.example.com");
+  });
+
+  it("overwrites existing credentials", () => {
+    writeCredentials({ token: "old", apiUrl: "https://old.com" });
+    writeCredentials({ token: "new", apiUrl: "https://new.com" });
+    const creds = readCredentials();
+    expect(creds?.token).toBe("new");
+    expect(creds?.apiUrl).toBe("https://new.com");
+  });
+});
+
+describe("deleteCredentials", () => {
+  it("removes the credentials file", () => {
+    writeCredentials({ token: "test", apiUrl: "https://api.test.com" });
+    deleteCredentials();
+    expect(readCredentials()).toBeNull();
+  });
+
+  it("does nothing when no credentials exist", () => {
+    expect(() => deleteCredentials()).not.toThrow();
+  });
+});
+
+describe("isLoggedIn", () => {
+  it("returns false when not logged in", () => {
+    expect(isLoggedIn()).toBe(false);
+  });
+
+  it("returns true when credentials exist", () => {
+    writeCredentials({ token: "test", apiUrl: "https://api.test.com" });
+    expect(isLoggedIn()).toBe(true);
+  });
+
+  it("returns false after logout", () => {
+    writeCredentials({ token: "test", apiUrl: "https://api.test.com" });
+    deleteCredentials();
+    expect(isLoggedIn()).toBe(false);
+  });
+});

package/references/swarmkit/src/hub/credentials.ts

@@ -0,0 +1,51 @@
+import { existsSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { getConfigDir, ensureConfigDir } from "../config/global.js";
+
+export interface HubCredentials {
+  /** JWT token from SwarmHub */
+  token: string;
+  /** SwarmHub API base URL that issued the token */
+  apiUrl: string;
+}
+
+function getCredentialsPath(): string {
+  return join(getConfigDir(), "credentials.json");
+}
+
+/** Read stored SwarmHub credentials, or null if not logged in */
+export function readCredentials(): HubCredentials | null {
+  const path = getCredentialsPath();
+  if (!existsSync(path)) return null;
+
+  try {
+    const raw = readFileSync(path, "utf-8");
+    const parsed = JSON.parse(raw) as Partial<HubCredentials>;
+    if (!parsed.token || !parsed.apiUrl) return null;
+    return { token: parsed.token, apiUrl: parsed.apiUrl };
+  } catch {
+    return null;
+  }
+}
+
+/** Store SwarmHub credentials (written with 0600 permissions) */
+export function writeCredentials(credentials: HubCredentials): void {
+  ensureConfigDir();
+  const path = getCredentialsPath();
+  writeFileSync(path, JSON.stringify(credentials, null, 2) + "\n", {
+    mode: 0o600,
+  });
+}
+
+/** Remove stored SwarmHub credentials */
+export function deleteCredentials(): void {
+  const path = getCredentialsPath();
+  if (existsSync(path)) {
+    unlinkSync(path);
+  }
+}
+
+/** Check if the user is logged in to SwarmHub */
+export function isLoggedIn(): boolean {
+  return readCredentials() !== null;
+}

package/references/swarmkit/src/index.ts

@@ -0,0 +1,116 @@
+// Public API — re-export modules for programmatic use
+
+export {
+  PACKAGES,
+  BUNDLES,
+  INTEGRATIONS,
+  getBundlePackages,
+  getActiveIntegrations,
+  getNewIntegrations,
+  getLostIntegrations,
+  getNpmName,
+  isKnownPackage,
+  getAllPackageNames,
+} from "./packages/registry.js";
+
+export type {
+  PackageDefinition,
+  BundleDefinition,
+  Integration,
+} from "./packages/registry.js";
+
+export {
+  installPackages,
+  uninstallPackage,
+  getInstalledVersion,
+  getLatestVersion,
+  updatePackages,
+  isClaudeCliAvailable,
+  getGlobalPackagePath,
+} from "./packages/installer.js";
+
+export type { InstallResult, UpdateResult } from "./packages/installer.js";
+
+export {
+  isInstalledPlugin,
+  registerPlugin,
+} from "./packages/plugin.js";
+
+export {
+  PROJECT_CONFIG_DIRS,
+  PROJECT_INIT_ORDER,
+  GLOBAL_CONFIG_DIRS,
+  isProjectInit,
+  isGlobalInit,
+  initProjectPackage,
+  initGlobalPackage,
+} from "./packages/setup.js";
+
+export type {
+  InitContext,
+  GlobalContext,
+  OpenhiveOptions,
+  SetupResult,
+} from "./packages/setup.js";
+
+export {
+  readConfig,
+  writeConfig,
+  isFirstRun,
+  getConfigDir,
+  addInstalledPackages,
+  removeInstalledPackage,
+  getSwarmkitVersion,
+  isConfigOutdated,
+} from "./config/global.js";
+
+export type { GlobalConfig } from "./config/global.js";
+
+export {
+  readKey,
+  writeKey,
+  deleteKey,
+  listKeys,
+  hasKey,
+} from "./config/keys.js";
+
+export { runAllChecks } from "./doctor/checks.js";
+
+export type {
+  CheckResult,
+  CheckContext,
+  CheckStatus,
+} from "./doctor/types.js";
+
+export type { DoctorReport } from "./doctor/checks.js";
+
+export {
+  readCredentials,
+  writeCredentials,
+  deleteCredentials,
+  isLoggedIn,
+} from "./hub/credentials.js";
+
+export type { HubCredentials } from "./hub/credentials.js";
+
+export {
+  exchangeAuthCode,
+  refreshToken,
+  getMe,
+  createHive,
+  listHives,
+  getHive,
+  startHive,
+  stopHive,
+  destroyHive,
+  getHubUrl,
+  HubApiError,
+} from "./hub/client.js";
+
+export type {
+  HubUser,
+  Hive,
+  HiveStatus,
+  HiveTier,
+  CreateHiveOptions,
+} from "./hub/client.js";