npm - @arcote.tech/arc-cli - Versions diffs - 0.3.0 → 0.4.1 - Mend

@arcote.tech/arc-cli 0.3.0 → 0.4.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (15) hide show

package/dist/index.js +18069 -7197
package/package.json +2 -2
package/src/builder/module-builder.ts +348 -0
package/src/commands/platform-build.ts +7 -0
package/src/commands/platform-dev.ts +116 -0
package/src/commands/platform-start.ts +56 -0
package/src/i18n/catalog.ts +204 -0
package/src/i18n/compile.ts +37 -0
package/src/i18n/index.ts +77 -0
package/src/i18n/plugin.ts +55 -0
package/src/index.ts +24 -1
package/src/platform/server.ts +353 -0
package/src/platform/shared.ts +280 -0
package/src/utils/build.ts +93 -126
package/src/utils/config.ts +18 -31

package/src/platform/server.ts ADDED Viewed

@@ -0,0 +1,353 @@
+import {
+  cleanupClientSubs,
+  cleanupStreams,
+  createArcServer,
+  ContextHandler,
+  ConnectionManager,
+  type ArcHttpHandler,
+  type ArcRequestContext,
+  type ArcServer,
+} from "@arcote.tech/arc-host";
+import { existsSync, mkdirSync } from "fs";
+import { join } from "path";
+import { readTranslationsConfig } from "../i18n";
+import type { BuildManifest, WorkspaceInfo } from "./shared";
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+export interface PlatformServerOptions {
+  ws: WorkspaceInfo;
+  port: number;
+  manifest: BuildManifest;
+  /** Server context (from loadServerContext). If null, static-only mode. */
+  context?: any;
+  /** Path to SQLite database file */
+  dbPath?: string;
+  /** If true, enables SSE reload stream + mutable manifest (dev mode) */
+  devMode?: boolean;
+}
+export interface PlatformServer {
+  server: ReturnType<typeof Bun.serve>;
+  contextHandler: ContextHandler | null;
+  connectionManager: ConnectionManager | null;
+  /** Update manifest at runtime (dev mode rebuild) */
+  setManifest: (m: BuildManifest) => void;
+  /** Notify SSE clients of rebuild (dev mode only) */
+  notifyReload: (m: BuildManifest) => void;
+  /** Cleanup streams and stop server */
+  stop: () => void;
+}
+// ---------------------------------------------------------------------------
+// ContextHandler initialization
+// ---------------------------------------------------------------------------
+export async function initContextHandler(
+  context: any,
+  dbPath: string,
+): Promise<ContextHandler> {
+  const { createBunSQLiteAdapterFactory } = await import(
+    "@arcote.tech/arc-adapter-db-sqlite"
+  );
+  const dbDir = dbPath.substring(0, dbPath.lastIndexOf("/"));
+  if (dbDir) mkdirSync(dbDir, { recursive: true });
+  const dbAdapter = createBunSQLiteAdapterFactory(dbPath)(context);
+  const handler = new ContextHandler(context, dbAdapter);
+  await handler.init();
+  return handler;
+}
+// ---------------------------------------------------------------------------
+// Shell HTML
+// ---------------------------------------------------------------------------
+export function generateShellHtml(appName: string, manifest?: { title: string; favicon?: string }): string {
+  const importMap = {
+    imports: {
+      react: "/shell/react.js",
+      "react/jsx-runtime": "/shell/jsx-runtime.js",
+      "react/jsx-dev-runtime": "/shell/jsx-dev-runtime.js",
+      "react-dom": "/shell/react-dom.js",
+      "react-dom/client": "/shell/react-dom-client.js",
+      "@arcote.tech/arc": "/shell/arc.js",
+      "@arcote.tech/arc-ds": "/shell/arc-ds.js",
+      "@arcote.tech/arc-react": "/shell/arc-react.js",
+      "@arcote.tech/platform": "/shell/platform.js",
+    },
+  };
+  return `<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+  <title>${manifest?.title ?? appName}</title>${manifest?.favicon ? `\n  <link rel="icon" href="${manifest.favicon}">` : ""}${manifest ? `\n  <link rel="manifest" href="/manifest.json">` : ""}
+  <link rel="stylesheet" href="/styles.css" />
+  <link rel="stylesheet" href="/theme.css" />
+  <script type="importmap">${JSON.stringify(importMap)}</script>
+</head>
+<body>
+  <div id="root"></div>
+  <script type="module">
+    import { createRoot } from "react-dom/client";
+    import { createElement } from "react";
+    import { PlatformApp } from "@arcote.tech/platform";
+    createRoot(document.getElementById("root")).render(
+      createElement(PlatformApp)
+    );
+  </script>
+</body>
+</html>`;
+}
+// ---------------------------------------------------------------------------
+// Static file serving
+// ---------------------------------------------------------------------------
+const MIME: Record<string, string> = {
+  ".html": "text/html",
+  ".js": "application/javascript",
+  ".mjs": "application/javascript",
+  ".css": "text/css",
+  ".json": "application/json",
+  ".svg": "image/svg+xml",
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".ico": "image/x-icon",
+  ".woff2": "font/woff2",
+  ".woff": "font/woff",
+  ".ttf": "font/ttf",
+};
+function getMime(path: string): string {
+  const ext = path.substring(path.lastIndexOf("."));
+  return MIME[ext] ?? "application/octet-stream";
+}
+function serveFile(
+  filePath: string,
+  headers: Record<string, string> = {},
+): Response {
+  if (!existsSync(filePath))
+    return new Response("Not Found", { status: 404 });
+  return new Response(Bun.file(filePath), {
+    headers: { "Content-Type": getMime(filePath), ...headers },
+  });
+}
+// ---------------------------------------------------------------------------
+// Platform-specific HTTP handlers
+// ---------------------------------------------------------------------------
+function staticFilesHandler(ws: WorkspaceInfo, devMode: boolean): ArcHttpHandler {
+  return (_req, url, ctx) => {
+    const path = url.pathname;
+    if (path.startsWith("/shell/"))
+      return serveFile(join(ws.shellDir, path.slice(7)), ctx.corsHeaders);
+    if (path.startsWith("/modules/"))
+      return serveFile(join(ws.modulesDir, path.slice(9)), {
+        ...ctx.corsHeaders,
+        "Cache-Control": devMode ? "no-cache" : "max-age=31536000,immutable",
+      });
+    if (path.startsWith("/locales/"))
+      return serveFile(join(ws.arcDir, path.slice(1)), ctx.corsHeaders);
+    if (path === "/styles.css")
+      return serveFile(join(ws.arcDir, "styles.css"), ctx.corsHeaders);
+    if (path === "/theme.css")
+      return serveFile(join(ws.arcDir, "theme.css"), ctx.corsHeaders);
+    // Serve manifest.json from root dir
+    if ((path === "/manifest.json" || path === "/manifest.webmanifest") && ws.manifest) {
+      return serveFile(ws.manifest.path, ctx.corsHeaders);
+    }
+    // Public files (files with extensions)
+    if (path.lastIndexOf(".") > path.lastIndexOf("/")) {
+      const publicFile = join(ws.publicDir, path.slice(1));
+      if (existsSync(publicFile))
+        return serveFile(publicFile, ctx.corsHeaders);
+    }
+    return null;
+  };
+}
+function apiEndpointsHandler(
+  ws: WorkspaceInfo,
+  getManifest: () => BuildManifest,
+  cm: ConnectionManager | null,
+): ArcHttpHandler {
+  return (_req, url, ctx) => {
+    if (url.pathname === "/api/modules")
+      return Response.json(getManifest(), { headers: ctx.corsHeaders });
+    if (url.pathname === "/api/translations") {
+      const config = readTranslationsConfig(ws.rootDir);
+      return Response.json(config ?? { locales: [], sourceLocale: "" }, {
+        headers: ctx.corsHeaders,
+      });
+    }
+    if (url.pathname === "/health") {
+      return Response.json(
+        {
+          status: "ok",
+          modules: getManifest().modules.length,
+          clients: cm?.clientCount ?? 0,
+        },
+        { headers: ctx.corsHeaders },
+      );
+    }
+    return null;
+  };
+}
+function devReloadHandler(
+  sseClients: Set<ReadableStreamDefaultController>,
+): ArcHttpHandler {
+  return (_req, url, ctx) => {
+    if (url.pathname !== "/api/reload-stream") return null;
+    const stream = new ReadableStream({
+      start(controller) {
+        sseClients.add(controller);
+        controller.enqueue("data: connected\n\n");
+      },
+      cancel(controller) {
+        sseClients.delete(controller);
+      },
+    });
+    return new Response(stream, {
+      headers: {
+        ...ctx.corsHeaders,
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache",
+        Connection: "keep-alive",
+      },
+    });
+  };
+}
+function spaFallbackHandler(shellHtml: string): ArcHttpHandler {
+  return (_req, _url, ctx) => {
+    return new Response(shellHtml, {
+      headers: { ...ctx.corsHeaders, "Content-Type": "text/html" },
+    });
+  };
+}
+// ---------------------------------------------------------------------------
+// Start platform server — uses createArcServer + platform handlers
+// ---------------------------------------------------------------------------
+export async function startPlatformServer(
+  opts: PlatformServerOptions,
+): Promise<PlatformServer> {
+  const { ws, port, devMode, context } = opts;
+  let manifest = opts.manifest;
+  const getManifest = () => manifest;
+  const shellHtml = generateShellHtml(ws.appName, ws.manifest);
+  const sseClients = new Set<ReadableStreamDefaultController>();
+  if (!context) {
+    // No context — serve static files only (no WS/commands/queries)
+    const cors = {
+      "Access-Control-Allow-Origin": "*",
+      "Access-Control-Allow-Methods":
+        "GET, POST, PUT, DELETE, PATCH, OPTIONS",
+      "Access-Control-Allow-Headers": "Content-Type, Authorization",
+    };
+    const server = Bun.serve({
+      port,
+      fetch(req) {
+        const url = new URL(req.url);
+        if (req.method === "OPTIONS")
+          return new Response(null, { headers: cors });
+        const ctx: ArcRequestContext = {
+          rawToken: null,
+          tokenPayload: null,
+          corsHeaders: cors,
+        };
+        // Platform handlers only
+        const handlers: ArcHttpHandler[] = [
+          apiEndpointsHandler(ws, getManifest, null),
+          ...(devMode ? [devReloadHandler(sseClients)] : []),
+          staticFilesHandler(ws, !!devMode),
+          spaFallbackHandler(shellHtml),
+        ];
+        for (const handler of handlers) {
+          const response = handler(req, url, ctx);
+          if (response instanceof Promise) return response;
+          if (response) return response;
+        }
+        return new Response("Not Found", { status: 404, headers: cors });
+      },
+    });
+    return {
+      server,
+      contextHandler: null,
+      connectionManager: null,
+      setManifest: (m) => { manifest = m; },
+      notifyReload: (m) => {
+        const data = JSON.stringify(m);
+        for (const c of sseClients) {
+          try { c.enqueue(`data: ${data}\n\n`); }
+          catch { sseClients.delete(c); }
+        }
+      },
+      stop: () => server.stop(),
+    };
+  }
+  // Context available — use createArcServer with platform handlers on top
+  const { createBunSQLiteAdapterFactory } = await import(
+    "@arcote.tech/arc-adapter-db-sqlite"
+  );
+  const dbPath = opts.dbPath || join(ws.arcDir, "data", "arc.db");
+  const dbDir = dbPath.substring(0, dbPath.lastIndexOf("/"));
+  if (dbDir) mkdirSync(dbDir, { recursive: true });
+  const arcServer = await createArcServer({
+    context,
+    dbAdapterFactory: createBunSQLiteAdapterFactory(dbPath),
+    port,
+    httpHandlers: [
+      // Platform-specific handlers (checked AFTER arc handlers)
+      apiEndpointsHandler(ws, getManifest, null),
+      ...(devMode ? [devReloadHandler(sseClients)] : []),
+      staticFilesHandler(ws, !!devMode),
+      spaFallbackHandler(shellHtml),
+    ],
+    onWsClose: (clientId) => cleanupClientSubs(clientId),
+  });
+  return {
+    server: arcServer.server,
+    contextHandler: arcServer.contextHandler,
+    connectionManager: arcServer.connectionManager,
+    setManifest: (m) => { manifest = m; },
+    notifyReload: (m) => {
+      const data = JSON.stringify(m);
+      for (const c of sseClients) {
+        try { c.enqueue(`data: ${data}\n\n`); }
+        catch { sseClients.delete(c); }
+      }
+    },
+    stop: () => arcServer.stop(),
+  };
+}

package/src/platform/shared.ts ADDED Viewed

@@ -0,0 +1,280 @@
+import { findUpSync } from "find-up";
+import { copyFileSync, existsSync, mkdirSync, readFileSync } from "fs";
+import { dirname, join } from "path";
+import {
+  buildPackages,
+  buildStyles,
+  discoverPackages,
+  isContextPackage,
+  type BuildManifest,
+  type WorkspacePackage,
+} from "../builder/module-builder";
+// Re-export for convenience
+export { buildPackages, buildStyles, isContextPackage };
+export type { BuildManifest, WorkspacePackage };
+// ---------------------------------------------------------------------------
+// Logging
+// ---------------------------------------------------------------------------
+const C = {
+  reset: "\x1b[0m",
+  green: "\x1b[32m",
+  red: "\x1b[31m",
+  cyan: "\x1b[36m",
+};
+export const log = (msg: string) =>
+  console.log(`${C.cyan}[arc]${C.reset} ${msg}`);
+export const ok = (msg: string) => console.log(`${C.green} ✓${C.reset} ${msg}`);
+export const err = (msg: string) =>
+  console.error(`${C.red} ✗${C.reset} ${msg}`);
+// ---------------------------------------------------------------------------
+// Workspace resolution
+// ---------------------------------------------------------------------------
+export interface ManifestInfo {
+  path: string;
+  title: string;
+  favicon?: string;
+}
+export interface WorkspaceInfo {
+  rootDir: string;
+  rootPkg: Record<string, any>;
+  appName: string;
+  arcDir: string;
+  modulesDir: string;
+  shellDir: string;
+  publicDir: string;
+  packages: WorkspacePackage[];
+  manifest?: ManifestInfo;
+}
+export function resolveWorkspace(): WorkspaceInfo {
+  const packageJsonPath = findUpSync("package.json", { cwd: process.cwd() });
+  if (!packageJsonPath) {
+    err("No package.json found");
+    process.exit(1);
+  }
+  const rootDir = dirname(packageJsonPath);
+  const rootPkg = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+  const appName = rootPkg.name ?? "Arc App";
+  const arcDir = join(rootDir, ".arc", "platform");
+  log("Scanning workspaces...");
+  const packages = discoverPackages(rootDir);
+  ok(
+    `Found ${packages.length} package(s): ${packages.map((p) => p.name).join(", ")}`,
+  );
+  if (packages.length === 0) {
+    err("No workspace packages found.");
+    process.exit(1);
+  }
+  // Detect manifest.json or manifest.webmanifest in root dir
+  let manifest: ManifestInfo | undefined;
+  for (const name of ["manifest.json", "manifest.webmanifest"]) {
+    const manifestPath = join(rootDir, name);
+    if (existsSync(manifestPath)) {
+      try {
+        const data = JSON.parse(readFileSync(manifestPath, "utf-8"));
+        const icons = data.icons as { src: string; sizes?: string }[] | undefined;
+        manifest = {
+          path: manifestPath,
+          title: data.name ?? appName,
+          favicon: icons?.[0]?.src,
+        };
+        ok(`Found ${name}: "${manifest.title}"`);
+      } catch {
+        err(`Failed to parse ${name}`);
+      }
+      break;
+    }
+  }
+  return {
+    rootDir,
+    rootPkg,
+    appName,
+    arcDir,
+    modulesDir: join(arcDir, "modules"),
+    shellDir: join(arcDir, "shell"),
+    publicDir: join(rootDir, "public"),
+    packages,
+    manifest,
+  };
+}
+// ---------------------------------------------------------------------------
+// Build pipeline — packages, CSS, theme, shell
+// ---------------------------------------------------------------------------
+export async function buildAll(ws: WorkspaceInfo): Promise<BuildManifest> {
+  log("Building packages...");
+  const manifest = await buildPackages(ws.rootDir, ws.modulesDir, ws.packages);
+  ok(`Built ${manifest.modules.length} module(s)`);
+  log("Building styles...");
+  await buildStyles(ws.rootDir, ws.arcDir);
+  ok("Styles built");
+  // Copy theme if configured
+  const themePath = ws.rootPkg.arc?.theme;
+  if (themePath) {
+    const src = join(ws.rootDir, themePath);
+    if (existsSync(src)) {
+      copyFileSync(src, join(ws.arcDir, "theme.css"));
+      ok("Theme copied");
+    }
+  }
+  log("Building shell...");
+  await buildShell(ws.shellDir);
+  ok("Shell built");
+  return manifest;
+}
+// ---------------------------------------------------------------------------
+// Shell builder — framework packages for import map
+// ---------------------------------------------------------------------------
+async function buildShell(outDir: string): Promise<void> {
+  mkdirSync(outDir, { recursive: true });
+  const tmpDir = join(outDir, "_tmp");
+  mkdirSync(tmpDir, { recursive: true });
+  // Step 1: Build React layer (bundles React CJS → ESM)
+  const reactEntries: [string, string][] = [
+    [
+      "react",
+      `import React from "react";
+export default React;
+export const {
+  Children, Component, Fragment, Profiler, PureComponent, StrictMode, Suspense,
+  cloneElement, createContext, createElement, createRef, forwardRef, isValidElement,
+  lazy, memo, startTransition, use, useCallback, useContext, useDebugValue,
+  useDeferredValue, useEffect, useId, useImperativeHandle, useInsertionEffect,
+  useLayoutEffect, useMemo, useReducer, useRef, useState, useSyncExternalStore,
+  useTransition, version, useActionState, useOptimistic,
+} = React;`,
+    ],
+    ["jsx-runtime", `export { jsx, jsxs, Fragment } from "react/jsx-runtime";`],
+    [
+      "jsx-dev-runtime",
+      `export { jsxDEV, Fragment } from "react/jsx-dev-runtime";`,
+    ],
+    [
+      "react-dom",
+      `import ReactDOM from "react-dom";
+export default ReactDOM;
+export const { createPortal, flushSync } = ReactDOM;`,
+    ],
+    [
+      "react-dom-client",
+      `export { createRoot, hydrateRoot } from "react-dom/client";`,
+    ],
+  ];
+  const reactEps: string[] = [];
+  for (const [name, code] of reactEntries) {
+    const f = join(tmpDir, `${name}.ts`);
+    Bun.write(f, code);
+    reactEps.push(f);
+  }
+  const r1 = await Bun.build({
+    entrypoints: reactEps,
+    outdir: outDir,
+    splitting: true,
+    format: "esm",
+    target: "browser",
+    naming: "[name].[ext]",
+  });
+  if (!r1.success) {
+    for (const l of r1.logs) console.error(l);
+    throw new Error("Shell React build failed");
+  }
+  // Step 2: Build Arc layer (react is EXTERNAL — resolved via import map)
+  const arcEntries: [string, string][] = [
+    ["arc", "@arcote.tech/arc"],
+    ["arc-ds", "@arcote.tech/arc-ds"],
+    ["arc-react", "@arcote.tech/arc-react"],
+    ["platform", "@arcote.tech/platform"],
+  ];
+  const arcEps: string[] = [];
+  for (const [name, pkg] of arcEntries) {
+    const f = join(tmpDir, `${name}.ts`);
+    Bun.write(f, `export * from "${pkg}";\n`);
+    arcEps.push(f);
+  }
+  const r2 = await Bun.build({
+    entrypoints: arcEps,
+    outdir: outDir,
+    splitting: true,
+    format: "esm",
+    target: "browser",
+    naming: "[name].[ext]",
+    external: [
+      "react",
+      "react-dom",
+      "react/jsx-runtime",
+      "react/jsx-dev-runtime",
+      "react-dom/client",
+    ],
+  });
+  if (!r2.success) {
+    for (const l of r2.logs) console.error(l);
+    throw new Error("Shell Arc build failed");
+  }
+  // Clean tmp
+  const { rmSync } = await import("fs");
+  rmSync(tmpDir, { recursive: true, force: true });
+}
+// ---------------------------------------------------------------------------
+// Server context loading
+// ---------------------------------------------------------------------------
+export async function loadServerContext(
+  packages: WorkspacePackage[],
+): Promise<any | null> {
+  const ctxPackages = packages.filter((p) => isContextPackage(p.packageJson));
+  if (ctxPackages.length === 0) return null;
+  // Set globals for server context — framework packages (arc-auth etc.)
+  // use these at runtime to tree-shake browser/server code paths.
+  (globalThis as any).ONLY_SERVER = true;
+  (globalThis as any).ONLY_BROWSER = false;
+  (globalThis as any).ONLY_CLIENT = false;
+  // Import all context packages — side effects from module().build()
+  // register context elements into the global registry via setContext().
+  for (const ctx of ctxPackages) {
+    const serverDist = join(ctx.path, "dist", "server", "main", "index.js");
+    if (!existsSync(serverDist)) {
+      err(`Context server dist not found: ${serverDist}`);
+      continue;
+    }
+    try {
+      await import(serverDist);
+    } catch (e) {
+      err(`Failed to load server context from ${ctx.name}: ${e}`);
+    }
+  }
+  // After all imports, module().build() side effects have called setContext()
+  // in the arc-ui registry. Retrieve the merged context from there.
+  const { getContext } = await import("@arcote.tech/platform");
+  return getContext() ?? null;
+}