openpalm 0.9.4 → 0.9.6

package/src/setup-wizard/server.test.ts

@@ -0,0 +1,347 @@
+import { describe, expect, it, beforeEach, afterEach } from "bun:test";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { createSetupServer } from "./server.ts";
+import type { CoreAssetProvider } from "@openpalm/lib";
+
+// ── Helpers ──────────────────────────────────────────────────────────────
+
+let tempBase: string;
+let configDir: string;
+let dataDir: string;
+let stateDir: string;
+
+const savedEnv: Record<string, string | undefined> = {};
+
+function createStubAssetProvider(): CoreAssetProvider {
+  return {
+    coreCompose: () => "services:\n  caddy:\n    image: caddy:latest\n",
+    caddyfile: () =>
+      ":80 {\n  @denied not remote_ip 127.0.0.0/8 ::1\n  respond @denied 403\n}\n",
+    ollamaCompose: () => "services:\n  ollama:\n    image: ollama/ollama\n",
+    agentsMd: () => "# Agents\n",
+    opencodeConfig: () => '{"$schema":"https://opencode.ai/config.json"}\n',
+    adminOpencodeConfig: () => '{"$schema":"https://opencode.ai/config.json","plugin":["@openpalm/admin-tools"]}\n',
+    secretsSchema: () => "ADMIN_TOKEN=string\n",
+    stackSchema: () => "OPENPALM_IMAGE_TAG=string\n",
+    cleanupLogs: () => "name: cleanup-logs\nschedule: daily\n",
+    cleanupData: () => "name: cleanup-data\nschedule: weekly\n",
+    validateConfig: () => "name: validate-config\nschedule: hourly\n",
+  };
+}
+
+function makeSetupDirs(): void {
+  tempBase = mkdtempSync(join(tmpdir(), "openpalm-server-test-"));
+  configDir = join(tempBase, "config");
+  dataDir = join(tempBase, "data");
+  stateDir = join(tempBase, "state");
+
+  for (const dir of [
+    configDir,
+    join(configDir, "channels"),
+    join(configDir, "connections"),
+    join(configDir, "assistant"),
+    join(configDir, "automations"),
+    join(configDir, "stash"),
+    dataDir,
+    join(dataDir, "admin"),
+    join(dataDir, "memory"),
+    join(dataDir, "assistant"),
+    join(dataDir, "guardian"),
+    join(dataDir, "caddy"),
+    join(dataDir, "caddy", "data"),
+    join(dataDir, "caddy", "config"),
+    join(dataDir, "automations"),
+    join(dataDir, "opencode"),
+    stateDir,
+    join(stateDir, "artifacts"),
+    join(stateDir, "audit"),
+    join(stateDir, "artifacts", "channels"),
+    join(stateDir, "automations"),
+    join(stateDir, "opencode"),
+  ]) {
+    mkdirSync(dir, { recursive: true });
+  }
+
+  writeFileSync(join(stateDir, "artifacts", "stack.env"), "OPENPALM_SETUP_COMPLETE=false\n");
+  writeFileSync(
+    join(configDir, "secrets.env"),
+    [
+      "# OpenPalm Secrets",
+      "export OPENPALM_ADMIN_TOKEN=",
+      "export ADMIN_TOKEN=",
+      "export OPENAI_API_KEY=",
+      "export OPENAI_BASE_URL=",
+      "export ANTHROPIC_API_KEY=",
+      "export GROQ_API_KEY=",
+      "export MISTRAL_API_KEY=",
+      "export GOOGLE_API_KEY=",
+      "export MEMORY_USER_ID=default_user",
+      "export MEMORY_AUTH_TOKEN=abc123",
+      "export OWNER_NAME=",
+      "export OWNER_EMAIL=",
+      "",
+    ].join("\n")
+  );
+}
+
+// ── Test Suites ──────────────────────────────────────────────────────────
+
+// Incrementing port counter to ensure no port conflicts between tests
+let nextPort = 19100;
+
+describe("setup wizard server", () => {
+  let serverPort: number;
+
+  beforeEach(() => {
+    makeSetupDirs();
+
+    savedEnv.OPENPALM_CONFIG_HOME = process.env.OPENPALM_CONFIG_HOME;
+    savedEnv.OPENPALM_DATA_HOME = process.env.OPENPALM_DATA_HOME;
+    savedEnv.OPENPALM_STATE_HOME = process.env.OPENPALM_STATE_HOME;
+    process.env.OPENPALM_CONFIG_HOME = configDir;
+    process.env.OPENPALM_DATA_HOME = dataDir;
+    process.env.OPENPALM_STATE_HOME = stateDir;
+
+    // Use incrementing ports to avoid conflicts between sequential tests
+    serverPort = nextPort++;
+  });
+
+  afterEach(() => {
+    process.env.OPENPALM_CONFIG_HOME = savedEnv.OPENPALM_CONFIG_HOME;
+    process.env.OPENPALM_DATA_HOME = savedEnv.OPENPALM_DATA_HOME;
+    process.env.OPENPALM_STATE_HOME = savedEnv.OPENPALM_STATE_HOME;
+    if (tempBase) rmSync(tempBase, { recursive: true, force: true });
+  });
+
+  it("serves the wizard HTML at GET /setup", async () => {
+    const { server, stop } = createSetupServer(serverPort, {
+      assetProvider: createStubAssetProvider(),
+      configDir,
+    });
+
+    try {
+      const res = await fetch(`http://localhost:${serverPort}/setup`);
+      expect(res.status).toBe(200);
+      expect(res.headers.get("content-type")).toContain("text/html");
+      const body = await res.text();
+      expect(body).toContain("OpenPalm Setup Wizard");
+    } finally {
+      stop();
+    }
+  });
+
+  it("serves wizard.js at GET /setup/wizard.js", async () => {
+    const { server, stop } = createSetupServer(serverPort, {
+      assetProvider: createStubAssetProvider(),
+      configDir,
+    });
+
+    try {
+      const res = await fetch(`http://localhost:${serverPort}/setup/wizard.js`);
+      expect(res.status).toBe(200);
+      expect(res.headers.get("content-type")).toContain("application/javascript");
+    } finally {
+      stop();
+    }
+  });
+
+  it("serves wizard.css at GET /setup/wizard.css", async () => {
+    const { server, stop } = createSetupServer(serverPort, {
+      assetProvider: createStubAssetProvider(),
+      configDir,
+    });
+
+    try {
+      const res = await fetch(`http://localhost:${serverPort}/setup/wizard.css`);
+      expect(res.status).toBe(200);
+      expect(res.headers.get("content-type")).toContain("text/css");
+    } finally {
+      stop();
+    }
+  });
+
+  it("returns setup status at GET /api/setup/status", async () => {
+    const { server, stop } = createSetupServer(serverPort, {
+      assetProvider: createStubAssetProvider(),
+      configDir,
+    });
+
+    try {
+      const res = await fetch(`http://localhost:${serverPort}/api/setup/status`);
+      expect(res.status).toBe(200);
+      const data = (await res.json()) as { ok: boolean; setupComplete: boolean };
+      expect(data.ok).toBe(true);
+      expect(data.setupComplete).toBe(false);
+    } finally {
+      stop();
+    }
+  });
+
+  it("returns provider detection at GET /api/setup/detect-providers", async () => {
+    const { server, stop } = createSetupServer(serverPort, {
+      assetProvider: createStubAssetProvider(),
+      configDir,
+    });
+
+    try {
+      // detectLocalProviders probes real network endpoints with 3s timeouts each,
+      // so we allow a generous timeout for this test.
+      const controller = new AbortController();
+      const timer = setTimeout(() => controller.abort(), 15000);
+      const res = await fetch(`http://localhost:${serverPort}/api/setup/detect-providers`, {
+        signal: controller.signal,
+      });
+      clearTimeout(timer);
+      expect(res.status).toBe(200);
+      const data = (await res.json()) as { ok: boolean; providers: unknown[] };
+      expect(data.ok).toBe(true);
+      expect(Array.isArray(data.providers)).toBe(true);
+    } finally {
+      stop();
+    }
+  }, 20000); // Extended test timeout for network probing
+
+  it("returns 404 for unknown routes", async () => {
+    const { server, stop } = createSetupServer(serverPort, {
+      assetProvider: createStubAssetProvider(),
+      configDir,
+    });
+
+    try {
+      const res = await fetch(`http://localhost:${serverPort}/nonexistent`);
+      expect(res.status).toBe(404);
+      const data = (await res.json()) as { ok: boolean; error: string };
+      expect(data.ok).toBe(false);
+      expect(data.error).toBe("not_found");
+    } finally {
+      stop();
+    }
+  });
+
+  it("returns deploy status at GET /api/setup/deploy-status", async () => {
+    const { server, stop, updateDeployStatus } = createSetupServer(serverPort, {
+      assetProvider: createStubAssetProvider(),
+      configDir,
+    });
+
+    try {
+      updateDeployStatus([
+        { service: "caddy", status: "pending", label: "Caddy" },
+        { service: "memory", status: "pulling", label: "Memory" },
+      ]);
+
+      const res = await fetch(`http://localhost:${serverPort}/api/setup/deploy-status`);
+      expect(res.status).toBe(200);
+      const data = (await res.json()) as {
+        ok: boolean;
+        setupComplete: boolean;
+        deployStatus: Array<{ service: string; status: string; label: string }>;
+      };
+      expect(data.ok).toBe(true);
+      expect(data.deployStatus).toHaveLength(2);
+      expect(data.deployStatus[0].service).toBe("caddy");
+    } finally {
+      stop();
+    }
+  });
+
+  it("rejects invalid JSON on POST /api/setup/complete", async () => {
+    const { server, stop } = createSetupServer(serverPort, {
+      assetProvider: createStubAssetProvider(),
+      configDir,
+    });
+
+    try {
+      const res = await fetch(`http://localhost:${serverPort}/api/setup/complete`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: "not-json",
+      });
+      expect(res.status).toBe(400);
+      const data = (await res.json()) as { ok: boolean; error: string };
+      expect(data.ok).toBe(false);
+      expect(data.error).toBe("invalid_json");
+    } finally {
+      stop();
+    }
+  });
+
+  it("completes setup and resolves waitForComplete", async () => {
+    const { server, stop, waitForComplete } = createSetupServer(serverPort, {
+      assetProvider: createStubAssetProvider(),
+      configDir,
+    });
+
+    try {
+      const body = {
+        adminToken: "test-admin-token-12345",
+        ownerName: "Test",
+        ownerEmail: "test@example.com",
+        memoryUserId: "test_user",
+        ollamaEnabled: false,
+        connections: [
+          {
+            id: "openai-main",
+            name: "OpenAI",
+            provider: "openai",
+            baseUrl: "https://api.openai.com",
+            apiKey: "sk-test-key-123",
+          },
+        ],
+        assignments: {
+          llm: { connectionId: "openai-main", model: "gpt-4o" },
+          embeddings: { connectionId: "openai-main", model: "text-embedding-3-small" },
+        },
+      };
+
+      // Fire POST and await both the response and the completion signal
+      const [res, result] = await Promise.all([
+        fetch(`http://localhost:${serverPort}/api/setup/complete`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(body),
+        }),
+        waitForComplete(),
+      ]);
+
+      expect(res.status).toBe(200);
+      const data = (await res.json()) as { ok: boolean };
+      expect(data.ok).toBe(true);
+      expect(result.ok).toBe(true);
+
+      // Subsequent POST should return "already complete"
+      const res2 = await fetch(`http://localhost:${serverPort}/api/setup/complete`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(body),
+      });
+      expect(res2.status).toBe(200);
+      const data2 = (await res2.json()) as { ok: boolean; message: string };
+      expect(data2.message).toBe("Setup already complete");
+    } finally {
+      stop();
+    }
+  });
+
+  it("returns 400 for invalid setup input on POST /api/setup/complete", async () => {
+    const { server, stop } = createSetupServer(serverPort, {
+      assetProvider: createStubAssetProvider(),
+      configDir,
+    });
+
+    try {
+      const res = await fetch(`http://localhost:${serverPort}/api/setup/complete`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ adminToken: "short" }),
+      });
+      expect(res.status).toBe(400);
+      const data = (await res.json()) as { ok: boolean; error: string };
+      expect(data.ok).toBe(false);
+    } finally {
+      stop();
+    }
+  });
+});

package/src/setup-wizard/server.ts

@@ -0,0 +1,297 @@
+/**
+ * CLI setup wizard HTTP server.
+ *
+ * Serves the setup wizard UI and provides API endpoints for provider detection,
+ * model listing, and setup completion. Runs temporarily during `openpalm install`,
+ * blocking until the user completes the wizard.
+ *
+ * Uses Bun.serve() with a fetch handler for routing.
+ */
+import {
+  type SetupInput,
+  type SetupResult,
+  type CoreAssetProvider,
+  performSetup,
+  detectProviders,
+  isSetupComplete,
+  fetchProviderModels,
+  resolveConfigHome,
+  resolveStateHome,
+  FilesystemAssetProvider,
+  resolveDataHome,
+} from "@openpalm/lib";
+
+// ── Types ────────────────────────────────────────────────────────────────
+
+type DeployStatusEntry = {
+  service: string;
+  status: "pending" | "pulling" | "ready" | "running" | "error";
+  label: string;
+};
+
+type SetupServerState = {
+  setupComplete: boolean;
+  setupResult: SetupResult | null;
+  deployStatus: DeployStatusEntry[];
+  deployError: string | null;
+};
+
+// ── JSON Response Helpers ────────────────────────────────────────────────
+
+function jsonResponse(status: number, body: unknown): Response {
+  return new Response(JSON.stringify(body), {
+    status,
+    headers: {
+      "Content-Type": "application/json",
+      "Cache-Control": "no-store",
+    },
+  });
+}
+
+function errorResponse(status: number, code: string, message: string): Response {
+  return jsonResponse(status, { ok: false, error: code, message });
+}
+
+// ── Route Matching ───────────────────────────────────────────────────────
+
+/**
+ * Match a URL path against a pattern with `:param` segments.
+ * Returns the matched params or null if no match.
+ */
+function matchRoute(
+  path: string,
+  pattern: string
+): Record<string, string> | null {
+  const pathSegments = path.split("/").filter(Boolean);
+  const patternSegments = pattern.split("/").filter(Boolean);
+
+  if (pathSegments.length !== patternSegments.length) return null;
+
+  const params: Record<string, string> = {};
+  for (let i = 0; i < patternSegments.length; i++) {
+    const patSeg = patternSegments[i];
+    if (patSeg.startsWith(":")) {
+      params[patSeg.slice(1)] = decodeURIComponent(pathSegments[i]);
+    } else if (patSeg !== pathSegments[i]) {
+      return null;
+    }
+  }
+  return params;
+}
+
+// ── Server Factory ───────────────────────────────────────────────────────
+
+export type SetupServer = {
+  server: ReturnType<typeof Bun.serve>;
+  waitForComplete: () => Promise<SetupResult>;
+  stop: () => void;
+  /** Update deploy status for a service (for progress tracking). */
+  updateDeployStatus: (entries: DeployStatusEntry[]) => void;
+  setDeployError: (error: string) => void;
+  markAllRunning: () => void;
+};
+
+/**
+ * Create and start the setup wizard HTTP server.
+ *
+ * @param port - Port to listen on (default 8100)
+ * @param opts - Optional overrides for asset provider and config dir
+ */
+export function createSetupServer(
+  port: number = 8100,
+  opts?: {
+    assetProvider?: CoreAssetProvider;
+    configDir?: string;
+  }
+): SetupServer {
+  const configDir = opts?.configDir ?? resolveConfigHome();
+  const assetProvider = opts?.assetProvider ?? new FilesystemAssetProvider(resolveDataHome());
+
+  // Mutable server state
+  const state: SetupServerState = {
+    setupComplete: false,
+    setupResult: null,
+    deployStatus: [],
+    deployError: null,
+  };
+
+  // Completion signal: resolves when setup POST succeeds
+  let resolveComplete: ((result: SetupResult) => void) | null = null;
+  const completionPromise = new Promise<SetupResult>((resolve) => {
+    resolveComplete = resolve;
+  });
+
+  // ── Request Handler ──────────────────────────────────────────────────
+
+  async function handleRequest(req: Request): Promise<Response> {
+    const url = new URL(req.url);
+    const path = url.pathname;
+    const method = req.method;
+
+    // ── Static Assets ────────────────────────────────────────────────
+
+    if (method === "GET" && (path === "/setup" || path === "/setup/")) {
+      return new Response(WIZARD_HTML, {
+        status: 200,
+        headers: { "Content-Type": "text/html; charset=utf-8" },
+      });
+    }
+
+    if (method === "GET" && path === "/setup/wizard.js") {
+      return new Response(WIZARD_JS, {
+        status: 200,
+        headers: { "Content-Type": "application/javascript; charset=utf-8" },
+      });
+    }
+
+    if (method === "GET" && path === "/setup/wizard.css") {
+      return new Response(WIZARD_CSS, {
+        status: 200,
+        headers: { "Content-Type": "text/css; charset=utf-8" },
+      });
+    }
+
+    // ── API: Setup Status ────────────────────────────────────────────
+
+    if (method === "GET" && path === "/api/setup/status") {
+      const stateDir = resolveStateHome();
+      const complete = isSetupComplete(stateDir, configDir);
+      return jsonResponse(200, {
+        ok: true,
+        setupComplete: complete || state.setupComplete,
+      });
+    }
+
+    // ── API: Detect Providers ────────────────────────────────────────
+
+    if (method === "GET" && path === "/api/setup/detect-providers") {
+      try {
+        const providers = await detectProviders();
+        return jsonResponse(200, { ok: true, providers });
+      } catch (err) {
+        return errorResponse(500, "detection_failed", String(err));
+      }
+    }
+
+    // ── API: Fetch Models for a Provider ─────────────────────────────
+    // Uses POST to keep API keys out of URLs/query strings.
+
+    const modelsMatch = matchRoute(path, "/api/setup/models/:provider");
+    if (method === "POST" && modelsMatch) {
+      const provider = modelsMatch.provider;
+
+      let reqBody: Record<string, unknown> = {};
+      try {
+        reqBody = (await req.json()) as Record<string, unknown>;
+      } catch {
+        return errorResponse(400, "invalid_json", "Request body must be valid JSON");
+      }
+
+      const apiKey = typeof reqBody.apiKey === "string" ? reqBody.apiKey : "";
+      const baseUrl = typeof reqBody.baseUrl === "string" ? reqBody.baseUrl : "";
+
+      try {
+        const result = await fetchProviderModels(provider, apiKey, baseUrl, configDir);
+        return jsonResponse(200, { ok: true, ...result });
+      } catch (err) {
+        return errorResponse(500, "model_fetch_failed", String(err));
+      }
+    }
+
+    // ── API: Complete Setup ──────────────────────────────────────────
+
+    if (method === "POST" && path === "/api/setup/complete") {
+      if (state.setupComplete) {
+        return jsonResponse(200, { ok: true, message: "Setup already complete" });
+      }
+
+      let body: unknown;
+      try {
+        body = await req.json();
+      } catch {
+        return errorResponse(400, "invalid_json", "Request body must be valid JSON");
+      }
+
+      const input = body as SetupInput;
+      const result = await performSetup(input, assetProvider);
+
+      if (result.ok) {
+        state.setupComplete = true;
+        state.setupResult = result;
+        // Signal completion
+        resolveComplete?.(result);
+      }
+
+      return jsonResponse(result.ok ? 200 : 400, result);
+    }
+
+    // ── API: Deploy Status ───────────────────────────────────────────
+
+    if (method === "GET" && path === "/api/setup/deploy-status") {
+      return jsonResponse(200, {
+        ok: true,
+        setupComplete: state.setupComplete,
+        deployStatus: state.deployStatus,
+        deployError: state.deployError,
+      });
+    }
+
+    // ── 404 ──────────────────────────────────────────────────────────
+
+    return errorResponse(404, "not_found", `Route not found: ${method} ${path}`);
+  }
+
+  // ── Start Server ─────────────────────────────────────────────────────
+
+  const server = Bun.serve({
+    port,
+    hostname: "127.0.0.1",
+    fetch: handleRequest,
+  });
+
+  return {
+    server,
+    waitForComplete: () => completionPromise,
+    stop: () => server.stop(),
+    updateDeployStatus: (entries: DeployStatusEntry[]) => {
+      state.deployStatus = entries;
+    },
+    setDeployError: (error: string) => {
+      state.deployError = error;
+    },
+    markAllRunning: () => {
+      for (const entry of state.deployStatus) {
+        if (entry.status !== "error") {
+          entry.status = "running";
+        }
+      }
+    },
+  };
+}
+
+// ── Convenience: Wait for Setup Complete ─────────────────────────────────
+
+/**
+ * High-level helper: starts the server, waits for setup to complete, then stops.
+ */
+export async function waitForSetupComplete(
+  port: number = 8100,
+  opts?: {
+    assetProvider?: CoreAssetProvider;
+    configDir?: string;
+  }
+): Promise<SetupResult> {
+  const { server, waitForComplete, stop } = createSetupServer(port, opts);
+  try {
+    return await waitForComplete();
+  } finally {
+    stop();
+  }
+}
+
+// ── Static Assets (wizard UI from task 2.1) ─────────────────────────────
+// Embedded at build time via Bun text imports from sibling files.
+
+import WIZARD_HTML from "./index.html" with { type: "text" };
+import WIZARD_JS from "./wizard.js" with { type: "text" };
+import WIZARD_CSS from "./wizard.css" with { type: "text" };