agent-hub-sdd 0.1.2 → 0.1.4

package/README.md

@@ -12,13 +12,17 @@ Na pasta do repositório (depois de `npm install`):
 npm run app
 ```
 
-Pelo npm, quando a versão 0.1.1 estiver publicada:
+Pelo npm (precisa do Node 20+ no PATH):
 
 ```powershell
-npx agent-hub-sdd
+npx --yes agent-hub-sdd@latest
 ```
 
-Isso abre a janela do app. Na primeira vez o npm baixa o Electron e o Next.
+Isso abre a **janela** do app. Na primeira vez o npm baixa o Electron e o Next. Se uma versão antiga ficou em cache e a janela não sobe, use a versão explícita:
+
+```powershell
+npx --yes agent-hub-sdd@0.1.4
+```
 
 ## App no Windows (a partir do código)
 

package/electron/main.mjs

@@ -1,8 +1,11 @@
 import { spawn } from "node:child_process";
+import fs from "node:fs";
 import http from "node:http";
+import { createRequire } from "node:module";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { app, BrowserWindow, dialog, ipcMain, shell } from "electron";
+import { stageHub } from "./stage-hub.mjs";
 
 const PORT = Number(process.env.AGENT_HUB_PORT || 43147);
 const HUB = `http://127.0.0.1:${PORT}`;
@@ -12,9 +15,66 @@ const repoRoot = path.join(here, "..");
 let win;
 let child;
 let startedServer = false;
+let logs = "";
 
 function hubDir() {
-  return app.isPackaged ? path.join(process.resourcesPath, "hub") : repoRoot;
+  const raw = app.isPackaged ? path.join(process.resourcesPath, "hub") : repoRoot;
+  return stageHub(raw);
+}
+
+function nodeName() {
+  return process.platform === "win32" ? "node.exe" : "node";
+}
+
+function nodeBin() {
+  const guessed = [
+    process.env.AGENT_HUB_NODE,
+    process.env.npm_node_execpath,
+  ];
+  const npmCli = process.env.npm_execpath;
+  if (npmCli) {
+    guessed.push(path.join(path.dirname(npmCli), nodeName()));
+    guessed.push(path.resolve(path.dirname(npmCli), "..", "..", "..", nodeName()));
+  }
+  if (process.platform === "win32") {
+    if (process.env.ProgramFiles) {
+      guessed.push(path.join(process.env.ProgramFiles, "nodejs", "node.exe"));
+    }
+    guessed.push("C:\\Program Files\\nodejs\\node.exe");
+    if (process.env.LOCALAPPDATA) {
+      guessed.push(path.join(process.env.LOCALAPPDATA, "Programs", "nodejs", "node.exe"));
+    }
+  }
+  for (const candidate of guessed) {
+    if (candidate && fs.existsSync(candidate)) return candidate;
+  }
+  return nodeName();
+}
+
+function nextBin(cwd) {
+  const starts = [path.join(cwd, "package.json"), fileURLToPath(import.meta.url)];
+  const errors = [];
+  for (const start of starts) {
+    try {
+      const req = createRequire(start);
+      const root = path.dirname(req.resolve("next/package.json"));
+      const bin = path.join(root, "dist", "bin", "next");
+      if (fs.existsSync(bin)) return bin;
+      errors.push(`Next em ${root}, mas falta dist/bin/next`);
+    } catch (error) {
+      errors.push(error instanceof Error ? error.message : String(error));
+    }
+  }
+  throw new Error(`Não achei o Next.js no pacote.\n${errors.join("\n")}`);
+}
+
+function withNodeOnPath(env, node) {
+  const next = { ...env };
+  if (!node || node === "node" || node === "node.exe") return next;
+  const dir = path.dirname(node);
+  const key = Object.keys(next).find((k) => k.toLowerCase() === "path") ?? "PATH";
+  next[key] = `${dir}${path.delimiter}${next[key] ?? ""}`;
+  return next;
 }
 
 function isUp() {
@@ -31,36 +91,60 @@ function isUp() {
   });
 }
 
-async function waitForHub() {
-  for (let i = 0; i < 120; i++) {
-    if (await isUp()) return;
-    await new Promise((r) => setTimeout(r, 250));
-  }
-  throw new Error(`O servidor do Agent Hub não subiu em ${HUB}`);
+function note(chunk) {
+  logs = (logs + chunk.toString()).slice(-8000);
 }
 
 function startServer() {
   const cwd = hubDir();
-  const env = { ...process.env, HOSTNAME: "127.0.0.1", PORT: String(PORT) };
-  if (app.isPackaged) {
-    const serverJs = path.join(cwd, "server.js");
-    const node = process.platform === "win32" ? "node.exe" : "node";
-    return spawn(node, [serverJs], {
-      cwd,
-      env,
-      stdio: "ignore",
+  const node = nodeBin();
+  const args = app.isPackaged
+    ? [path.join(cwd, "server.js")]
+    : [nextBin(cwd), "dev", "--webpack", "-H", "127.0.0.1", "-p", String(PORT)];
+  const env = withNodeOnPath(
+    { ...process.env, HOSTNAME: "127.0.0.1", PORT: String(PORT) },
+    node,
+  );
+  note(`\n${node} ${args.join(" ")}\n`);
+  const proc = spawn(node, args, {
+    cwd,
+    env,
+    stdio: ["ignore", "pipe", "pipe"],
+    windowsHide: true,
+    shell: false,
+  });
+  proc.stdout?.on("data", note);
+  proc.stderr?.on("data", note);
+  proc.on("error", (error) => note(`\n${error.message}\n`));
+  return proc;
+}
+
+function stopServer() {
+  if (!child || child.killed) return;
+  if (process.platform === "win32" && child.pid) {
+    spawn("taskkill", ["/pid", String(child.pid), "/t", "/f"], {
       windowsHide: true,
       shell: false,
+      stdio: "ignore",
     });
+    return;
   }
-  const npm = process.platform === "win32" ? "npm.cmd" : "npm";
-  return spawn(npm, ["run", "dev"], {
-    cwd,
-    env,
-    stdio: "inherit",
-    shell: process.platform === "win32",
-    windowsHide: false,
+  child.kill("SIGTERM");
+}
+
+async function waitForHub(proc) {
+  let exited;
+  proc?.once("exit", (code) => {
+    exited = code ?? 1;
   });
+  for (let i = 0; i < 180; i++) {
+    if (await isUp()) return;
+    if (exited !== undefined) {
+      throw new Error(`O servidor saiu com código ${exited}.\n${logs.trim() || "Sem log."}`);
+    }
+    await new Promise((r) => setTimeout(r, 500));
+  }
+  throw new Error(`O servidor não subiu em ${HUB}.\n${logs.trim() || "Sem log."}`);
 }
 
 function createWindow() {
@@ -110,23 +194,25 @@ app.whenReady().then(async () => {
     if (!(await isUp())) {
       child = startServer();
       startedServer = true;
-      child.on("error", (error) => {
-        void dialog.showErrorBox("Agent Hub", error.message);
-      });
     }
-    await waitForHub();
+    await waitForHub(startedServer ? child : null);
     createWindow();
   } catch (error) {
+    stopServer();
     const message = error instanceof Error ? error.message : String(error);
     await dialog.showErrorBox(
       "Agent Hub",
-      `${message}\n\nNo Windows empacotado, o Node.js 20+ precisa estar no PATH para subir o hub.`,
+      `${message}\n\nO app precisa do Node.js 20+ (o mesmo node do npx). Instale em https://nodejs.org/ e rode: npx --yes agent-hub-sdd@0.1.4`,
     );
     app.quit();
   }
 });
 
+app.on("before-quit", () => {
+  if (startedServer) stopServer();
+});
+
 app.on("window-all-closed", () => {
-  if (startedServer && child && !child.killed) child.kill();
+  if (startedServer) stopServer();
   app.quit();
 });

package/electron/stage-hub.mjs

@@ -0,0 +1,56 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+const COPY = ["src", "public", "next.config.ts", "tsconfig.json", "components.json", "package.json"];
+
+export function isNestedPackage(dir) {
+  return path.basename(path.dirname(path.resolve(dir))) === "node_modules";
+}
+
+export function hubHome() {
+  return process.env.AGENT_HUB_HOME || path.join(os.homedir(), ".agent-hub");
+}
+
+function unlinkQuiet(target) {
+  try {
+    const st = fs.lstatSync(target);
+    if (st.isSymbolicLink()) {
+      fs.unlinkSync(target);
+      return;
+    }
+  } catch {
+    return;
+  }
+  fs.rmSync(target, { recursive: true, force: true });
+}
+
+function linkModules(from, to) {
+  try {
+    if (fs.existsSync(to) && fs.realpathSync(to) === fs.realpathSync(from)) return;
+  } catch {
+    // broken link
+  }
+  unlinkQuiet(to);
+  fs.symlinkSync(from, to, process.platform === "win32" ? "junction" : "dir");
+}
+
+export function stageHub(srcDir, destDir) {
+  const src = path.resolve(srcDir);
+  if (!isNestedPackage(src)) return src;
+  const dest = path.resolve(destDir ?? path.join(hubHome(), "runtime"));
+  fs.mkdirSync(dest, { recursive: true });
+  const version = JSON.parse(fs.readFileSync(path.join(src, "package.json"), "utf8")).version;
+  const stamp = path.join(dest, ".hub-version");
+  const same = fs.existsSync(stamp) && fs.readFileSync(stamp, "utf8").trim() === version;
+  if (!same) {
+    for (const name of COPY) {
+      const from = path.join(src, name);
+      if (!fs.existsSync(from)) continue;
+      fs.cpSync(from, path.join(dest, name), { recursive: true, force: true });
+    }
+    fs.writeFileSync(stamp, `${version}\n`);
+  }
+  linkModules(path.join(src, ".."), path.join(dest, "node_modules"));
+  return dest;
+}

package/electron/stage-hub.test.ts

@@ -0,0 +1,33 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { afterEach, describe, expect, it } from "vitest";
+import { isNestedPackage, stageHub } from "./stage-hub.mjs";
+
+const temps: string[] = [];
+
+afterEach(() => {
+  for (const dir of temps.splice(0)) fs.rmSync(dir, { recursive: true, force: true });
+});
+
+describe("stageHub", () => {
+  it("leaves a git clone in place", () => {
+    expect(isNestedPackage("/workspace")).toBe(false);
+    expect(stageHub("/workspace")).toBe(path.resolve("/workspace"));
+  });
+
+  it("copies an npx install out of node_modules", () => {
+    const root = fs.mkdtempSync(path.join(os.tmpdir(), "hub-stage-"));
+    temps.push(root);
+    const pkg = path.join(root, "node_modules", "agent-hub-sdd");
+    fs.mkdirSync(path.join(pkg, "src", "components"), { recursive: true });
+    fs.writeFileSync(path.join(pkg, "package.json"), JSON.stringify({ name: "agent-hub-sdd", version: "0.1.4" }));
+    fs.writeFileSync(path.join(pkg, "src", "components", "desktop-chrome.tsx"), "export const DesktopChrome = () => null;\n");
+    fs.writeFileSync(path.join(root, "node_modules", "sentinel"), "ok");
+    const dest = path.join(root, "runtime");
+    expect(stageHub(pkg, dest)).toBe(dest);
+    expect(fs.readFileSync(path.join(dest, "src", "components", "desktop-chrome.tsx"), "utf8")).toContain("DesktopChrome");
+    expect(fs.readFileSync(path.join(dest, "node_modules", "sentinel"), "utf8")).toBe("ok");
+    expect(fs.realpathSync(path.join(dest, "src")).includes(`${path.sep}node_modules${path.sep}`)).toBe(false);
+  });
+});

package/next.config.ts

@@ -1,12 +1,34 @@
 import type { NextConfig } from "next";
+import path from "node:path";
+
+const projectRoot = process.cwd();
+const src = path.join(projectRoot, "src");
 
 const nextConfig: NextConfig = {
-  /* config options here */
   output: "standalone",
+  outputFileTracingRoot: projectRoot,
   // Cache Components rejects `runtime` / `dynamic` on route handlers. The hub
   // APIs stay Node and force-dynamic so the JSON store and SSE turns are not prerendered.
   cacheComponents: false,
   partialPrefetching: false,
+  agentRules: false,
+  // npx installs this app under node_modules. Next's tsconfig-paths plugin
+  // skips any importer in node_modules, so @/ would 404 without a webpack alias.
+  webpack: (config) => {
+    config.resolve ??= {};
+    const alias = config.resolve.alias;
+    if (Array.isArray(alias)) {
+      alias.push({ name: "@", alias: src });
+    } else {
+      config.resolve.alias = { ...alias, "@": src };
+    }
+    return config;
+  },
+  turbopack: {
+    resolveAlias: {
+      "@": src,
+    },
+  },
 };
 
 export default nextConfig;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-hub-sdd",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "private": false,
   "license": "MIT",
   "author": "Agent Hub",
@@ -59,12 +59,12 @@
     "shadcn": "^4.22.1",
     "tailwindcss": "^4",
     "tw-animate-css": "^1.4.0",
-    "typescript": "^5"
-  },
-  "devDependencies": {
+    "typescript": "^5",
     "@types/node": "^22.20.5",
     "@types/react": "^19",
-    "@types/react-dom": "^19",
+    "@types/react-dom": "^19"
+  },
+  "devDependencies": {
     "electron-builder": "^26.18.0",
     "eslint": "^9",
     "eslint-config-next": "16.4.3",

package/scripts/cli.cjs

@@ -1,4 +1,4 @@
-#!/usr/bin/env node
+#!/usr/bin/env node
 const { spawn } = require("node:child_process");
 const path = require("node:path");
 
@@ -11,12 +11,16 @@ try {
   process.exit(1);
 }
 
+const env = { ...process.env, AGENT_HUB_NODE: process.execPath };
+delete env.ELECTRON_RUN_AS_NODE;
+if (!env.npm_node_execpath) env.npm_node_execpath = process.execPath;
+
 const child = spawn(electron, [root], {
   cwd: root,
   stdio: "inherit",
-  env: process.env,
+  env,
   windowsHide: false,
-  shell: process.platform === "win32",
+  shell: false,
 });
 child.on("error", (error) => {
   console.error(error.message);