chainlesschain 0.156.6 → 0.156.7

package/src/lib/packer/web-panel-builder.js

@@ -0,0 +1,157 @@
+/**
+ * Phase 2: web-panel-builder
+ *
+ * Ensures packages/cli/src/assets/web-panel/ (or packages/web-panel/dist)
+ * has a built Vue panel ready to embed. If missing or stale, runs
+ * `npm run build:web-panel` from the CLI package root.
+ *
+ * Stale = source files in packages/web-panel/src newer than dist/index.html.
+ */
+
+import fs from "node:fs";
+import path from "node:path";
+import { spawnSync } from "node:child_process";
+import { PackError, EXIT } from "./errors.js";
+
+/**
+ * @param {object} ctx
+ * @param {string} ctx.cliRoot              packages/cli absolute path
+ * @param {boolean} ctx.skipBuild           reuse existing dist
+ * @param {object} [ctx.logger]             optional logger.log(msg)
+ * @returns {{distDir:string, rebuilt:boolean, assetCount:number}}
+ */
+export function ensureWebPanel(ctx) {
+  const { cliRoot, skipBuild, logger } = ctx;
+  const log = logger?.log || (() => {});
+
+  const candidates = [
+    path.join(cliRoot, "src", "assets", "web-panel"),
+    path.resolve(cliRoot, "..", "web-panel", "dist"),
+  ];
+
+  let distDir = candidates.find((d) =>
+    fs.existsSync(path.join(d, "index.html")),
+  );
+
+  // Decide if a rebuild is needed
+  let rebuilt = false;
+  let needsBuild = !distDir;
+  if (distDir && !skipBuild) {
+    needsBuild = isDistStale(distDir);
+  }
+
+  if (needsBuild && skipBuild) {
+    throw new PackError(
+      "web-panel/dist is missing or stale, but --skip-web-panel-build was passed.",
+      EXIT.WEB_PANEL,
+    );
+  }
+
+  if (needsBuild) {
+    log("  [web-panel] Building Vue panel via 'npm run build:web-panel'...");
+    const npmCmd = process.platform === "win32" ? "npm.cmd" : "npm";
+    const res = spawnSync(npmCmd, ["run", "build:web-panel"], {
+      cwd: cliRoot,
+      stdio: "inherit",
+      windowsHide: true,
+    });
+    if (res.status !== 0) {
+      throw new PackError(
+        `'npm run build:web-panel' exited with code ${res.status}`,
+        EXIT.WEB_PANEL,
+      );
+    }
+    rebuilt = true;
+    distDir = candidates.find((d) => fs.existsSync(path.join(d, "index.html")));
+  }
+
+  if (!distDir) {
+    throw new PackError(
+      "web-panel build did not produce dist/index.html in any expected location.",
+      EXIT.WEB_PANEL,
+    );
+  }
+
+  const assetCount = countAssets(distDir);
+  if (assetCount < 2) {
+    throw new PackError(
+      `web-panel dist looks empty (only ${assetCount} files). Build may be broken.`,
+      EXIT.WEB_PANEL,
+    );
+  }
+
+  return { distDir, rebuilt, assetCount };
+}
+
+/**
+ * dist is stale if any source file is newer than dist/index.html.
+ * Source roots tried in order; missing roots are skipped.
+ */
+function isDistStale(distDir) {
+  const indexHtml = path.join(distDir, "index.html");
+  if (!fs.existsSync(indexHtml)) return true;
+  const builtAt = fs.statSync(indexHtml).mtimeMs;
+
+  const sourceRoots = [
+    path.resolve(distDir, "..", "..", "..", "web-panel", "src"),
+    path.resolve(distDir, "..", "src"),
+  ];
+  for (const root of sourceRoots) {
+    if (!fs.existsSync(root)) continue;
+    if (latestMTimeRecursive(root, builtAt) > builtAt) return true;
+  }
+  return false;
+}
+
+/**
+ * Walk dir; return earliest mtime that exceeds threshold.
+ * Short-circuits on first hit.
+ */
+function latestMTimeRecursive(dir, threshold) {
+  let max = 0;
+  const stack = [dir];
+  while (stack.length) {
+    const cur = stack.pop();
+    let entries;
+    try {
+      entries = fs.readdirSync(cur, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const e of entries) {
+      const full = path.join(cur, e.name);
+      try {
+        const st = fs.statSync(full);
+        if (e.isDirectory()) {
+          stack.push(full);
+        } else if (st.mtimeMs > max) {
+          max = st.mtimeMs;
+          if (max > threshold) return max;
+        }
+      } catch {
+        /* skip */
+      }
+    }
+  }
+  return max;
+}
+
+function countAssets(distDir) {
+  let count = 0;
+  const stack = [distDir];
+  while (stack.length) {
+    const cur = stack.pop();
+    let entries;
+    try {
+      entries = fs.readdirSync(cur, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const e of entries) {
+      const full = path.join(cur, e.name);
+      if (e.isDirectory()) stack.push(full);
+      else count++;
+    }
+  }
+  return count;
+}

package/src/lib/web-ui-server.js

@@ -4,8 +4,16 @@
  * The UI is a self-contained single-page app with an embedded WebSocket client.
  *
  * Usage:
- *   const server = createWebUIServer({ wsPort, wsToken, wsHost, projectRoot, projectName, mode });
+ *   const server = createWebUIServer({ wsPort, wsToken, wsHost, projectRoot, projectName, mode, uiMode });
  *   server.listen(18810, '127.0.0.1');
+ *
+ * uiMode controls which front-end is served:
+ *   - "auto"    (default): SPA if web-panel/dist exists, else embedded HTML
+ *   - "full":   SPA only — throws if web-panel/dist is missing
+ *   - "minimal": embedded HTML only, even if SPA is available
+ *
+ * `cc pack` artifacts always set uiMode="full" so the bundled exe never
+ * silently degrades to the minimal HTML when assets failed to bundle.
  */
 
 import http from "http";
@@ -13,6 +21,7 @@ import fs from "fs";
 import path from "path";
 import { fileURLToPath } from "url";
 import { getInlineSource as getEnvelopeInlineSource } from "./web-ui-envelope.js";
+import { CLISkillLoader } from "./skill-loader.js";
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 
@@ -1209,6 +1218,67 @@ function findWebPanelDist(staticDir) {
   return null;
 }
 
+/**
+ * Handle `/api/*` routes. Returns `true` if the request was handled (caller
+ * must stop further processing) and `false` for everything else (caller
+ * continues with the static/SPA handler).
+ *
+ * Currently exposes a single read-only endpoint:
+ *
+ *   GET /api/skills → 200 { schema: 1, skills: [{name, source, category,
+ *                    description, version}] }
+ *
+ * The smoke-runner's project-mode probe (packer/smoke-runner.js) hits this
+ * to verify bundled skills were materialized and registered. The shape is
+ * deliberately minimal — the Web UI's richer skill views use WS.
+ *
+ * @param {import("http").IncomingMessage} req
+ * @param {import("http").ServerResponse}  res
+ * @returns {boolean}  true if handled, false if the caller should continue
+ */
+export function handleApiRequest(req, res) {
+  const urlPath = req.url.split("?")[0];
+  if (!urlPath.startsWith("/api/")) return false;
+
+  if (urlPath === "/api/skills") {
+    if (req.method !== "GET") {
+      res.writeHead(405, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: "Method Not Allowed" }));
+      return true;
+    }
+    try {
+      const loader = new CLISkillLoader();
+      const resolved = loader.loadAll();
+      const skills = resolved.map((s) => ({
+        name: s.id,
+        displayName: s.displayName,
+        source: s.source,
+        category: s.category,
+        description: s.description,
+        version: s.version,
+      }));
+      res.writeHead(200, {
+        "Content-Type": "application/json; charset=utf-8",
+        "Cache-Control": "no-store",
+        "X-Content-Type-Options": "nosniff",
+      });
+      res.end(JSON.stringify({ schema: 1, skills }));
+    } catch (err) {
+      res.writeHead(500, { "Content-Type": "application/json" });
+      res.end(
+        JSON.stringify({ error: "Skill load failed", detail: err.message }),
+      );
+    }
+    return true;
+  }
+
+  // Unknown /api/* path — explicit 404 so callers (smoke-runner) can tell
+  // "endpoint not implemented" from "server broken".
+  res.writeHead(404, { "Content-Type": "application/json" });
+  res.end(JSON.stringify({ error: "Not Found", path: urlPath }));
+  return true;
+}
+
 /**
  * Create and return a Node.js HTTP server that serves the Web UI.
  *
@@ -1223,16 +1293,37 @@ function findWebPanelDist(staticDir) {
  * @param {string|null} opts.projectRoot
  * @param {string|null} opts.projectName
  * @param {"project"|"global"} opts.mode
+ * @param {"auto"|"full"|"minimal"} [opts.uiMode="auto"]
  * @param {string|null} [opts.staticDir]   - Optional override for dist directory
  * @returns {import("http").Server}
  */
 export function createWebUIServer(opts) {
-  const distDir = findWebPanelDist(opts.staticDir || null);
+  const uiMode = opts.uiMode || "auto";
+  if (uiMode !== "auto" && uiMode !== "full" && uiMode !== "minimal") {
+    throw new Error(
+      `Invalid uiMode "${uiMode}". Expected "auto", "full", or "minimal".`,
+    );
+  }
+
+  const distDir =
+    uiMode === "minimal" ? null : findWebPanelDist(opts.staticDir || null);
+
+  if (uiMode === "full" && !distDir) {
+    throw new Error(
+      'uiMode="full" requires a built web-panel dist directory, but none was found. ' +
+        "Run `npm run build:web-panel` in packages/cli, or pass `staticDir` to override.",
+    );
+  }
+
   const configJson = buildConfigJson(opts);
 
   if (distDir) {
     // ── Serve built Vue3 web panel ──────────────────────────────────────────
     return http.createServer((req, res) => {
+      // /api/* routes are handled before the static file logic so GET /api/skills
+      // doesn't accidentally resolve to index.html via the SPA fallback.
+      if (handleApiRequest(req, res)) return;
+
       if (req.method !== "GET") {
         res.writeHead(405, { "Content-Type": "text/plain" });
         res.end("Method Not Allowed");
@@ -1290,6 +1381,8 @@ export function createWebUIServer(opts) {
   // ── Fallback: embedded classic single-page HTML ─────────────────────────
   const html = buildHtml(opts);
   return http.createServer((req, res) => {
+    if (handleApiRequest(req, res)) return;
+
     const urlPath = req.url.split("?")[0];
     if (
       req.method !== "GET" ||

package/src/lib/ws-server.js

@@ -13,4 +13,5 @@
 export {
   ChainlessChainWSServer,
   tokenizeCommand,
+  isCommandBlocked,
 } from "../gateways/ws/ws-server.js";

package/src/runtime/agent-runtime.js

@@ -495,6 +495,7 @@ export class AgentRuntime {
       projectName,
       mode,
       staticDir: this.policy.webPanelDir,
+      uiMode: this.policy.uiMode,
     });
 
     await new Promise((resolve, reject) => {

package/src/runtime/policies/agent-policy.js

@@ -51,5 +51,6 @@ export function resolveUiPolicy(overrides = {}) {
     open: overrides.open !== false,
     token: overrides.token || null,
     webPanelDir: overrides.webPanelDir || null,
+    uiMode: overrides.uiMode || "auto",
   };
 }

package/src/assets/web-panel/assets/index-DQgS_8Fd.js

@@ -1 +0,0 @@
-import{A as o}from"./Row-BFUWxIkx.js";import{w as t}from"./index-DaMG8ksh.js";import"./useConfigInject-ImjEZhXr.js";import"./vendor-C5RM7MZO.js";import"./icons-CpgFsfkd.js";import"./responsiveObserve-C5giLhLf.js";import"./useFlexGapSupport-Cd-PoTMl.js";import"./styleChecker-BzLSEXyu.js";import"./index-BFFb9yPd.js";const n=t(o);export{n as default};

package/src/assets/web-panel/assets/index-f4W8Sok0.js

@@ -1 +0,0 @@
-import{C as o}from"./Col-HJI40OzO.js";import{w as t}from"./index-DaMG8ksh.js";import"./useConfigInject-ImjEZhXr.js";import"./vendor-C5RM7MZO.js";import"./icons-CpgFsfkd.js";import"./index-BFFb9yPd.js";const l=t(o);export{l as default};