openpalm 0.2.0 → 0.2.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openpalm",
-  "version": "0.2.0",
+  "version": "0.2.7",
   "description": "CLI tool for installing and managing an OpenPalm stack",
   "type": "module",
   "license": "MIT",
@@ -18,26 +18,14 @@
     "installer"
   ],
   "bin": {
-    "openpalm": "./src/main.ts"
+    "openpalm": "./dist/openpalm.js"
   },
   "files": [
-    "src/**/*.ts"
+    "dist/**",
+    "README.md",
+    "LICENSE"
   ],
   "engines": {
-    "bun": ">=1.0.0"
-  },
-  "scripts": {
-    "start": "bun run src/main.ts",
-    "test": "bun test",
-    "build": "bun build src/main.ts --compile --outfile dist/openpalm",
-    "build:linux-x64": "bun build src/main.ts --compile --target=bun-linux-x64 --outfile dist/openpalm-linux-x64",
-    "build:linux-arm64": "bun build src/main.ts --compile --target=bun-linux-arm64 --outfile dist/openpalm-linux-arm64",
-    "build:darwin-x64": "bun build src/main.ts --compile --target=bun-darwin-x64 --outfile dist/openpalm-darwin-x64",
-    "build:darwin-arm64": "bun build src/main.ts --compile --target=bun-darwin-arm64 --outfile dist/openpalm-darwin-arm64",
-    "build:windows-x64": "bun build src/main.ts --compile --target=bun-windows-x64 --outfile dist/openpalm-windows-x64.exe",
-    "build:windows-arm64": "bun build src/main.ts --compile --target=bun-windows-arm64 --outfile dist/openpalm-windows-arm64.exe"
-  },
-  "dependencies": {
-    "@openpalm/lib": "workspace:*"
+    "bun": ">=1.2.0"
   }
 }

package/src/commands/create-channel.ts

@@ -1,262 +0,0 @@
-import { mkdirSync, writeFileSync, existsSync } from "node:fs";
-import { join, resolve } from "node:path";
-
-function usage(): never {
-  throw new Error("Usage: openpalm dev create-channel <channel-name> [--port <number>]");
-}
-
-export function createChannel(args: string[]): void {
-  const nameArg = args.find((arg) => !arg.startsWith("--"));
-  if (!nameArg) usage();
-
-  const name = nameArg.toLowerCase();
-  if (!/^[a-z][a-z0-9-]*$/.test(name)) {
-    throw new Error(`Error: channel name must be lowercase alphanumeric with hyphens, got \"${name}\"`);
-  }
-  if (name.length > 32) throw new Error("Error: channel name must be 32 characters or fewer");
-
-  const reserved = new Set(["chat", "discord", "voice", "telegram", "webhook"]);
-  if (reserved.has(name)) {
-    throw new Error(`Error: \"${name}\" is an existing built-in channel. Choose a different name.`);
-  }
-
-  const portIndex = args.indexOf("--port");
-  const defaultPort = portIndex !== -1 && args[portIndex + 1] ? Number(args[portIndex + 1]) : 8190;
-  if (Number.isNaN(defaultPort) || defaultPort < 1024 || defaultPort > 65535) {
-    throw new Error("Error: --port must be a number between 1024 and 65535");
-  }
-
-  const root = resolve(import.meta.dir, "../../../..");
-  const channelDir = join(root, "channels", name);
-  if (existsSync(channelDir)) throw new Error(`Error: channels/${name}/ already exists.`);
-
-  const envPrefix = name.replace(/-/g, "_").toUpperCase();
-  const secretVar = `CHANNEL_${envPrefix}_SECRET`;
-  const inboundTokenVar = `${envPrefix}_INBOUND_TOKEN`;
-  const serviceName = `channel-${name}`;
-  const camel = name.replace(/-([a-z])/g, (_, letter: string) => letter.toUpperCase());
-  const pascal = camel.charAt(0).toUpperCase() + camel.slice(1);
-  const createFn = `create${pascal}Channel`;
-
-  const channelTs = `import type { ChannelAdapter, InboundResult } from "@openpalm/lib/channel.ts";
-
-const INBOUND_TOKEN = Bun.env.${inboundTokenVar} ?? "";
-
-export function ${createFn}(): ChannelAdapter {
-  return {
-    name: "${name}",
-    routes: [
-      {
-        method: "POST",
-        path: "/${name}/inbound",
-        handler: async (req: Request): Promise<InboundResult> => {
-          if (INBOUND_TOKEN && req.headers.get("x-${name}-token") !== INBOUND_TOKEN) {
-            return { ok: false, status: 401, body: { error: "unauthorized" } };
-          }
-
-          const body = (await req.json()) as {
-            userId?: string;
-            text?: string;
-            metadata?: Record<string, unknown>;
-          };
-
-          if (!body.text) {
-            return { ok: false, status: 400, body: { error: "text_required" } };
-          }
-
-          return {
-            ok: true,
-            payload: {
-              userId: body.userId ?? "${name}-user",
-              channel: "${name}",
-              text: body.text,
-              metadata: body.metadata ?? {},
-            },
-          };
-        },
-      },
-    ],
-
-    health: () => ({ ok: true, service: "${serviceName}" }),
-  };
-}
-`;
-
-  const serverTs = `import { createHmac } from "node:crypto";
-import { ${createFn} } from "./channel.ts";
-import type { ChannelAdapter } from "@openpalm/lib/channel.ts";
-
-const PORT = Number(Bun.env.PORT ?? ${defaultPort});
-const GATEWAY_URL = Bun.env.GATEWAY_URL ?? "http://gateway:8080";
-const SHARED_SECRET = Bun.env.${secretVar} ?? "";
-
-export function signPayload(secret: string, body: string) {
-  return createHmac("sha256", secret).update(body).digest("hex");
-}
-
-function json(status: number, data: unknown) {
-  return new Response(JSON.stringify(data, null, 2), {
-    status,
-    headers: { "content-type": "application/json" },
-  });
-}
-
-export function createFetch(
-  adapter: ChannelAdapter,
-  gatewayUrl: string,
-  sharedSecret: string,
-  forwardFetch: typeof fetch = fetch,
-) {
-  const routeMap = new Map(adapter.routes.map((route) => [route.method + " " + route.path, route.handler]));
-
-  return async function handle(req: Request): Promise<Response> {
-    const url = new URL(req.url);
-    if (url.pathname === "/health") return json(200, adapter.health());
-
-    const handler = routeMap.get(req.method + " " + url.pathname);
-    if (!handler) return json(404, { error: "not_found" });
-
-    const result = await handler(req);
-    if (!result.ok) return json(result.status, result.body);
-
-    const gatewayPayload = {
-      ...result.payload,
-      nonce: crypto.randomUUID(),
-      timestamp: Date.now(),
-    };
-
-    const serialized = JSON.stringify(gatewayPayload);
-    const sig = signPayload(sharedSecret, serialized);
-
-    const resp = await forwardFetch(gatewayUrl + "/channel/inbound", {
-      method: "POST",
-      headers: {
-        "content-type": "application/json",
-        "x-channel-signature": sig,
-      },
-      body: serialized,
-    });
-
-    return new Response(await resp.text(), {
-      status: resp.status,
-      headers: { "content-type": "application/json" },
-    });
-  };
-}
-
-if (import.meta.main) {
-  const adapter = ${createFn}();
-  Bun.serve({ port: PORT, fetch: createFetch(adapter, GATEWAY_URL, SHARED_SECRET) });
-  console.log("${name} channel listening on " + PORT);
-}
-`;
-
-  const testTs = `import { describe, expect, it } from "bun:test";
-import { ${createFn} } from "./channel.ts";
-import { createFetch, signPayload } from "./server.ts";
-
-describe("${name} adapter", () => {
-  const adapter = ${createFn}();
-
-  it("returns health status", async () => {
-    const handler = createFetch(adapter, "http://gateway", "secret");
-    const resp = await handler(new Request("http://test/health"));
-    expect(resp.status).toBe(200);
-    const data = (await resp.json()) as { ok: boolean; service: string };
-    expect(data.ok).toBe(true);
-    expect(data.service).toBe("${serviceName}");
-  });
-
-  it("returns 404 for unknown routes", async () => {
-    const handler = createFetch(adapter, "http://gateway", "secret");
-    const resp = await handler(new Request("http://test/unknown"));
-    expect(resp.status).toBe(404);
-  });
-
-  it("returns 400 when text is missing", async () => {
-    const handler = createFetch(adapter, "http://gateway", "secret");
-    const resp = await handler(new Request("http://test/${name}/inbound", {
-      method: "POST",
-      body: JSON.stringify({ userId: "u1" }),
-      headers: { "content-type": "application/json" },
-    }));
-    expect(resp.status).toBe(400);
-  });
-
-  it("normalizes payload and forwards with valid HMAC", async () => {
-    let capturedUrl = "";
-    let capturedSig = "";
-    let capturedBody = "";
-
-    const mockFetch = async (input: RequestInfo | URL, init?: RequestInit) => {
-      capturedUrl = String(input);
-      capturedSig = String((init?.headers as Record<string, string>)["x-channel-signature"]);
-      capturedBody = String(init?.body);
-      return new Response(JSON.stringify({ ok: true }), { status: 200 });
-    };
-
-    const handler = createFetch(adapter, "http://gateway", "test-secret", mockFetch as typeof fetch);
-
-    const resp = await handler(new Request("http://test/${name}/inbound", {
-      method: "POST",
-      body: JSON.stringify({ userId: "u1", text: "hello" }),
-      headers: { "content-type": "application/json" },
-    }));
-
-    expect(resp.status).toBe(200);
-    expect(capturedUrl).toBe("http://gateway/channel/inbound");
-
-    const parsed = JSON.parse(capturedBody) as Record<string, unknown>;
-    expect(parsed.channel).toBe("${name}");
-    expect(parsed.text).toBe("hello");
-    expect(parsed.userId).toBe("u1");
-    expect(typeof parsed.nonce).toBe("string");
-    expect(typeof parsed.timestamp).toBe("number");
-    expect(capturedSig).toBe(signPayload("test-secret", capturedBody));
-  });
-});
-`;
-
-  const packageJson = `{
-  "name": "@openpalm/channel-${name}",
-  "private": true,
-  "type": "module",
-  "scripts": {
-    "start": "bun run server.ts",
-    "test": "bun test"
-  }
-}
-`;
-
-  const dockerfile = `FROM oven/bun:1.1.42
-WORKDIR /app
-COPY package.json ./
-COPY server.ts ./server.ts
-COPY channel.ts ./channel.ts
-RUN bun install --production
-CMD ["bun", "run", "server.ts"]
-`;
-
-  const envFile = `# Channel-specific overrides managed by admin UI\n${inboundTokenVar}=\n`;
-
-  mkdirSync(channelDir, { recursive: true });
-
-  const files: Array<[string, string]> = [
-    ["channel.ts", channelTs],
-    ["server.ts", serverTs],
-    ["server.test.ts", testTs],
-    ["package.json", packageJson],
-    ["Dockerfile", dockerfile],
-  ];
-
-  for (const [fileName, content] of files) {
-    writeFileSync(join(channelDir, fileName), content, "utf8");
-  }
-
-  const channelEnvDir = join(root, "assets", "config", "channels");
-  if (existsSync(channelEnvDir)) {
-    writeFileSync(join(channelEnvDir, `${name}.env`), envFile, "utf8");
-  }
-
-  console.log(`✔ Channel scaffolded: channels/${name}/`);
-}

package/src/commands/extensions.ts

@@ -1,122 +0,0 @@
-import { join } from "node:path";
-import { readEnvFile } from "@openpalm/lib/env.ts";
-import { resolveXDGPaths } from "@openpalm/lib/paths.ts";
-import { error, info } from "@openpalm/lib/ui.ts";
-
-/**
- * Implements the extensions command for managing OpenPalm extensions.
- * @param subcommand - The subcommand to execute: "install", "uninstall", or "list"
- * @param args - Remaining CLI arguments (may contain --plugin <id>)
- */
-export async function extensions(
-  subcommand: string,
-  args: string[]
-): Promise<void> {
-  // Helper function to find argument value
-  function getArg(name: string): string | undefined {
-    const index = args.indexOf(`--${name}`);
-    return index >= 0 && index + 1 < args.length ? args[index + 1] : undefined;
-  }
-
-  // Get admin token from environment or state .env file
-  let adminToken = Bun.env.ADMIN_TOKEN;
-  if (!adminToken) {
-    try {
-      const stateEnvPath = join(resolveXDGPaths().state, ".env");
-      const envVars = await readEnvFile(stateEnvPath);
-      adminToken = envVars.ADMIN_TOKEN;
-    } catch {
-      // Ignore errors reading env file
-    }
-  }
-
-  if (!adminToken) {
-    error("ADMIN_TOKEN not found in environment or state .env file");
-    process.exit(1);
-  }
-
-  // Determine base URL
-  const base =
-    Bun.env.ADMIN_APP_URL ??
-    Bun.env.GATEWAY_URL ??
-    "http://localhost/admin";
-
-  // Build headers
-  const headers = {
-    "content-type": "application/json",
-    "x-admin-token": adminToken,
-  };
-
-  /** Check HTTP response status and throw on failure. */
-  function checkResponse(response: Response, action: string): void {
-    if (!response.ok) {
-      throw new Error(
-        `${action} failed: HTTP ${response.status} ${response.statusText}`
-      );
-    }
-  }
-
-  try {
-    switch (subcommand) {
-      case "install": {
-        const pluginId = getArg("plugin");
-        if (!pluginId) {
-          error("--plugin <id> is required for install");
-          info("Usage: openpalm extensions install --plugin <id>");
-          process.exit(1);
-        }
-
-        const response = await fetch(`${base}/admin/plugins/install`, {
-          method: "POST",
-          headers,
-          body: JSON.stringify({ pluginId }),
-        });
-
-        checkResponse(response, "Extension install");
-        const text = await response.text();
-        info(text);
-        break;
-      }
-
-      case "uninstall": {
-        const pluginId = getArg("plugin");
-        if (!pluginId) {
-          error("--plugin <id> is required for uninstall");
-          info("Usage: openpalm extensions uninstall --plugin <id>");
-          process.exit(1);
-        }
-
-        const response = await fetch(`${base}/admin/plugins/uninstall`, {
-          method: "POST",
-          headers,
-          body: JSON.stringify({ pluginId }),
-        });
-
-        checkResponse(response, "Extension uninstall");
-        const text = await response.text();
-        info(text);
-        break;
-      }
-
-      case "list": {
-        const response = await fetch(`${base}/admin/installed`, {
-          method: "GET",
-          headers,
-        });
-
-        checkResponse(response, "Extension list");
-        const text = await response.text();
-        info(text);
-        break;
-      }
-
-      default:
-        error(`Unknown subcommand: ${subcommand}`);
-        info("Usage: openpalm extensions <install|uninstall|list> [--plugin <id>]");
-        process.exit(1);
-    }
-  } catch (err) {
-    error(`Failed to execute extensions command: ${err}`);
-    process.exit(1);
-  }
-}