@arcote.tech/arc-cli 0.6.2 → 0.7.1

package/src/platform/startup.ts

@@ -0,0 +1,159 @@
+import { existsSync, readFileSync, watch } from "fs";
+import { join } from "path";
+import { startPlatformServer, type PlatformServer } from "./server";
+import type { BuildManifest } from "./shared";
+import {
+  buildAll,
+  err,
+  loadServerContext,
+  log,
+  ok,
+  type WorkspaceInfo,
+} from "./shared";
+
+// ---------------------------------------------------------------------------
+// startup — single entry point for `arc platform start` and `arc platform dev`.
+//
+// The runtime host code path is IDENTICAL in both modes. Only two things
+// differ:
+//   - dev mode runs `buildAll` on startup (and rebuilds on file changes)
+//   - dev mode wires up the file watcher + SSE notify on rebuild
+//
+// Production mode reads a pre-built manifest from disk (in the deploy image,
+// that manifest was baked in at image build time) and never rebuilds.
+//
+// Module access map and signed URL semantics, chunk-aware static serving,
+// /api/modules filtering — all identical. This is the "dev↔prod parity"
+// promise that the v0.7 refactor was built around.
+// ---------------------------------------------------------------------------
+
+export interface StartPlatformOptions {
+  ws: WorkspaceInfo;
+  /** Listening port. Defaults to PORT env var or 5005. */
+  port?: number;
+  /** SQLite database path. Defaults to `<ws.rootDir>/.arc/data/<mode>.db`. */
+  dbPath?: string;
+  /** Dev mode: rebuild on startup, watch for changes, SSE-notify clients on rebuild. */
+  devMode: boolean;
+}
+
+export async function startPlatform(
+  opts: StartPlatformOptions,
+): Promise<void> {
+  const { ws, devMode } = opts;
+  const port = opts.port ?? parseInt(process.env.PORT || "5005", 10);
+  const dbPath =
+    opts.dbPath ??
+    join(ws.rootDir, ".arc", "data", devMode ? "dev.db" : "prod.db");
+
+  // 1. Acquire the manifest. In dev we always rebuild (fast — cache makes
+  // subsequent passes incremental). In prod we read the pre-built one;
+  // missing manifest is a hard error.
+  let manifest: BuildManifest;
+  if (devMode) {
+    manifest = await buildAll(ws);
+  } else {
+    const manifestPath = join(ws.arcDir, "manifest.json");
+    if (!existsSync(manifestPath)) {
+      err("No build found. Run `arc platform build` first.");
+      process.exit(1);
+    }
+    manifest = JSON.parse(readFileSync(manifestPath, "utf-8"));
+  }
+
+  // 2. Server context — same code path in both modes; loadServerContext
+  // prefers .arc/platform/server/*.js (the canonical location after the
+  // copyContextServerBundles step in buildAll).
+  log("Loading server context...");
+  const { context, moduleAccess } = await loadServerContext(ws);
+  if (context) {
+    ok("Context loaded");
+  } else {
+    log("No context — server endpoints skipped");
+  }
+
+  // 3. Start the platform server. Cache headers + SSE behaviour are
+  // controlled inside the server by `devMode`; we just pass the flag.
+  const platform = await startPlatformServer({
+    ws,
+    port,
+    manifest,
+    context,
+    moduleAccess,
+    dbPath,
+    devMode,
+  });
+
+  ok(`Server on http://localhost:${port}`);
+  if (platform.contextHandler) {
+    ok("Commands, queries, WebSocket — all on same port");
+  }
+
+  // 4. Dev-only: file watcher + debounced rebuild + SSE notify.
+  if (devMode) {
+    attachDevWatcher(ws, platform);
+  }
+
+  // 5. Graceful shutdown for both modes.
+  const cleanup = () => {
+    platform.stop();
+    process.exit(0);
+  };
+  process.on("SIGTERM", cleanup);
+  process.on("SIGINT", cleanup);
+}
+
+function attachDevWatcher(ws: WorkspaceInfo, platform: PlatformServer): void {
+  log("Watching for changes...");
+  let rebuildTimer: ReturnType<typeof setTimeout> | null = null;
+  let isRebuilding = false;
+
+  const triggerRebuild = () => {
+    if (rebuildTimer) clearTimeout(rebuildTimer);
+    rebuildTimer = setTimeout(async () => {
+      if (isRebuilding) return;
+      isRebuilding = true;
+      log("Rebuilding...");
+      try {
+        const next = await buildAll(ws);
+        platform.setManifest(next);
+        platform.notifyReload(next);
+        ok(
+          `Rebuilt — initial + ${Object.keys(next.groups).length} group(s)`,
+        );
+      } catch (e) {
+        console.error(`Rebuild failed: ${e}`);
+      } finally {
+        isRebuilding = false;
+      }
+    }, 300);
+  };
+
+  for (const pkg of ws.packages) {
+    const srcDir = join(pkg.path, "src");
+    if (!existsSync(srcDir)) continue;
+
+    watch(srcDir, { recursive: true }, (_event, filename) => {
+      if (
+        !filename ||
+        filename.includes(".arc") ||
+        filename.endsWith(".d.ts") ||
+        filename.includes("node_modules") ||
+        filename.includes("dist")
+      )
+        return;
+      if (!filename.endsWith(".ts") && !filename.endsWith(".tsx")) return;
+      triggerRebuild();
+    });
+  }
+
+  // .po files — translations are a separate cache unit, but buildAll picks
+  // them up via finalizeTranslations after extraction. Treat the same as src.
+  const localesDir = join(ws.rootDir, "locales");
+  if (existsSync(localesDir)) {
+    watch(localesDir, { recursive: false }, (_event, filename) => {
+      if (!filename?.endsWith(".po")) return;
+      triggerRebuild();
+    });
+  }
+}

package/runtime/Dockerfile

@@ -1,29 +0,0 @@
-# arcote/runtime — generic Arc platform runtime container.
-#
-# Image is intentionally version-agnostic. CLI version comes from the
-# ARC_CLI_VERSION env var set by docker-compose (generated per-deploy by
-# `arc platform deploy`), so a single `arcote/runtime:1` tag serves every
-# CLI release. Bumping CLI only requires `bun publish` — no image rebuild.
-#
-# Layout in container:
-#   /app/.arc/cli/<ARC_CLI_VERSION>/   ← arc-cli + direct deps (installed by entrypoint, cached)
-#   /app/.arc/platform/                ← user volume: code, framework + per-module deps
-#   /app/.arc/data/                    ← user volume: sqlite
-#   /root/.bun/install/cache/          ← shared bun store (volume)
-
-FROM oven/bun:1-alpine
-
-# tini for proper signal handling. build-base/python3/git in case any user dep
-# has a native postinstall step (e.g. better-sqlite3). curl for healthchecks.
-RUN apk add --no-cache tini ca-certificates build-base python3 git curl
-
-WORKDIR /app
-
-COPY entrypoint.sh /entrypoint.sh
-RUN chmod +x /entrypoint.sh
-
-EXPOSE 5005
-ENV PORT=5005 \
-    ARC_DEPLOY_API=1
-
-ENTRYPOINT ["tini", "--", "/entrypoint.sh"]

package/runtime/build-and-push.sh

@@ -1,23 +0,0 @@
-#!/usr/bin/env bash
-# build-and-push.sh — manual multi-arch publish of pkrasinski/arc-runtime to Docker Hub.
-#
-# Image is generic (no CLI version baked in) — one tag covers every CLI release.
-# Re-run only when the entrypoint script or base image needs to change.
-#
-# Prereqs: docker buildx + multi-arch builder configured, `docker login` done.
-#
-# Usage: bash build-and-push.sh [tag=1]
-
-set -euo pipefail
-
-TAG="${1:-1}"
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-
-docker buildx build \
-  --platform linux/amd64,linux/arm64 \
-  --tag "pkrasinski/arc-runtime:${TAG}" \
-  --tag "pkrasinski/arc-runtime:latest" \
-  --push \
-  "${SCRIPT_DIR}"
-
-echo "✓ Published pkrasinski/arc-runtime:${TAG} (multi-arch)"

package/runtime/entrypoint.sh

@@ -1,58 +0,0 @@
-#!/bin/sh
-# entrypoint.sh — installs arc-cli at ARC_CLI_VERSION (cached per version),
-# then hands off to `arc platform start`. The CLI itself decides between
-# pre-deploy mode (no manifest yet) and full mode based on volume state —
-# no logic for that lives here.
-#
-# bun install of framework peers and per-module deps is done by the CLI in
-# response to /api/deploy/framework and /api/deploy/modules/:name — this
-# script only ensures the CLI binary itself is present.
-
-set -e
-
-: "${ARC_CLI_VERSION:?ARC_CLI_VERSION env var required (set by docker-compose)}"
-
-CLI_DIR="/app/.arc/cli/${ARC_CLI_VERSION}"
-CLI_BIN="${CLI_DIR}/node_modules/@arcote.tech/arc-cli/dist/index.js"
-
-if [ ! -f "$CLI_BIN" ]; then
-  echo "[entrypoint] installing @arcote.tech/arc-cli@${ARC_CLI_VERSION}..."
-  mkdir -p "$CLI_DIR"
-  cd "$CLI_DIR"
-  echo '{"name":"arc-runtime-cli","private":true,"type":"module"}' > package.json
-  bun add "@arcote.tech/arc-cli@${ARC_CLI_VERSION}"
-fi
-
-# resolveWorkspace() in arc platform start exits hard if /app has no
-# package.json. In runtime mode the workspace lives in /app/.arc/platform/
-# but the CLI still walks up from cwd. Drop a stub manifest here so the
-# walk-up resolves to /app/.arc/platform (or to a stable "no workspace"
-# state in pre-deploy).
-if [ ! -f /app/package.json ]; then
-  cat > /app/package.json <<'EOF'
-{
-  "name": "arc-runtime",
-  "private": true,
-  "type": "module",
-  "workspaces": []
-}
-EOF
-fi
-
-# Make /app/.arc/platform the working directory — that's where deployed user
-# code, deps and node_modules live (volume mount).
-mkdir -p /app/.arc/platform
-cd /app/.arc/platform
-if [ ! -f package.json ]; then
-  cat > package.json <<'EOF'
-{
-  "name": "arc-platform-runtime",
-  "private": true,
-  "type": "module",
-  "workspaces": []
-}
-EOF
-fi
-
-echo "[entrypoint] starting arc platform (cli=${ARC_CLI_VERSION})"
-exec bun run "$CLI_BIN" platform start

package/src/commands/build-shell.ts

@@ -1,152 +0,0 @@
-import { existsSync, mkdirSync, readdirSync, readFileSync, rmSync, writeFileSync } from "fs";
-import { join } from "path";
-
-// ---------------------------------------------------------------------------
-// _build-shell — hidden subcommand used by the runtime container's
-// /api/deploy/framework handler after `bun install` of the framework peers.
-// Discovers every @arcote.tech/* package + react/react-dom under --from and
-// emits one ESM shell bundle per package under --out. The browser then loads
-// these as singletons (shared across all user modules).
-//
-// Decoupled from `arc platform build` (which runs in the user's workspace) —
-// this command operates purely on an installed node_modules tree, with no
-// concept of workspace packages or build cache.
-// ---------------------------------------------------------------------------
-
-export interface BuildShellOptions {
-  out: string;
-  from: string;
-}
-
-const REACT_ENTRIES: Array<[string, string]> = [
-  ["react", `export * from "react";\nimport * as React from "react";\nexport default React;`],
-  ["react-dom", `export * from "react-dom";\nimport * as ReactDOM from "react-dom";\nexport default ReactDOM;`],
-  ["jsx-runtime", `export * from "react/jsx-runtime";`],
-  ["jsx-dev-runtime", `export * from "react/jsx-dev-runtime";`],
-  ["react-dom-client", `export { createRoot, hydrateRoot } from "react-dom/client";`],
-];
-
-const SHELL_BASE_EXTERNAL = [
-  "react",
-  "react-dom",
-  "react/jsx-runtime",
-  "react/jsx-dev-runtime",
-  "react-dom/client",
-];
-
-export async function buildShell(opts: BuildShellOptions): Promise<void> {
-  const outDir = opts.out;
-  const fromDir = opts.from;
-
-  if (!existsSync(fromDir)) {
-    console.error(`[_build-shell] --from not found: ${fromDir}`);
-    process.exit(1);
-  }
-
-  mkdirSync(outDir, { recursive: true });
-  const tmpDir = join(outDir, "_tmp");
-  mkdirSync(tmpDir, { recursive: true });
-
-  try {
-    const arcPkgs = discoverArcPackages(fromDir);
-    if (arcPkgs.length === 0) {
-      console.warn("[_build-shell] no @arcote.tech/* packages discovered");
-    }
-
-    console.log(
-      `[_build-shell] building shell for react + ${arcPkgs.length} @arcote.tech/* package(s)`,
-    );
-
-    await buildReactShell(outDir, tmpDir, fromDir);
-    for (const pkg of arcPkgs) {
-      await buildArcEntry(pkg, arcPkgs, outDir, tmpDir, fromDir);
-    }
-
-    console.log(`[_build-shell] done → ${outDir}`);
-  } finally {
-    rmSync(tmpDir, { recursive: true, force: true });
-  }
-}
-
-// ---------------------------------------------------------------------------
-// Discovery — list every @arcote.tech/* dir under node_modules
-// ---------------------------------------------------------------------------
-
-function discoverArcPackages(fromDir: string): string[] {
-  const arcDir = join(fromDir, "@arcote.tech");
-  if (!existsSync(arcDir)) return [];
-  return readdirSync(arcDir)
-    .filter((name) => existsSync(join(arcDir, name, "package.json")))
-    .map((name) => `@arcote.tech/${name}`);
-}
-
-// ---------------------------------------------------------------------------
-// React shell (separated because it's not under @arcote.tech)
-// ---------------------------------------------------------------------------
-
-async function buildReactShell(
-  outDir: string,
-  tmpDir: string,
-  fromDir: string,
-): Promise<void> {
-  const eps: string[] = [];
-  for (const [name, code] of REACT_ENTRIES) {
-    const f = join(tmpDir, `${name}.ts`);
-    await Bun.write(f, code);
-    eps.push(f);
-  }
-
-  const r = await Bun.build({
-    entrypoints: eps,
-    outdir: outDir,
-    splitting: true,
-    format: "esm",
-    target: "browser",
-    naming: "[name].[ext]",
-    root: fromDir,
-  });
-  if (!r.success) {
-    for (const l of r.logs) console.error(l);
-    throw new Error("React shell build failed");
-  }
-}
-
-// ---------------------------------------------------------------------------
-// Per-@arcote.tech package shell
-// ---------------------------------------------------------------------------
-
-async function buildArcEntry(
-  pkg: string,
-  allArcPkgs: string[],
-  outDir: string,
-  tmpDir: string,
-  fromDir: string,
-): Promise<void> {
-  const shortName = pkg.replace("@arcote.tech/", "");
-  const otherExternals = allArcPkgs.filter((p) => p !== pkg);
-
-  const f = join(tmpDir, `${shortName}.ts`);
-  await Bun.write(f, `export * from "${pkg}";\n`);
-
-  // Bun needs to resolve `pkg` from fromDir. Setting `root: fromDir` and
-  // letting Bun walk up node_modules works because @arcote.tech/* lives at
-  // `fromDir/@arcote.tech/<name>`.
-  const r = await Bun.build({
-    entrypoints: [f],
-    outdir: outDir,
-    format: "esm",
-    target: "browser",
-    naming: "[name].[ext]",
-    root: fromDir,
-    external: [...SHELL_BASE_EXTERNAL, ...otherExternals],
-    define: {
-      ONLY_SERVER: "false",
-      ONLY_BROWSER: "true",
-      ONLY_CLIENT: "true",
-    },
-  });
-  if (!r.success) {
-    for (const l of r.logs) console.error(l);
-    throw new Error(`Shell build failed for ${pkg}`);
-  }
-}