agent-hub-sdd 0.1.2 → 0.1.6

package/README.md

@@ -12,13 +12,30 @@ 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@0.1.6
 ```
 
-Isso abre a janela do app. Na primeira vez o npm baixa o Electron e o Next.
+Na primeira abertura a janela diz que está compilando. O **N** no canto é o Next.js em modo dev, não o app. Sem `@0.1.6`, o Windows pode reusar cache antigo.
+
+Se ainda abrir a 0.1.2, ou se o npm disser `EBUSY` / `resource busy or locked`, o Next da tentativa antiga ainda está com o cache aberto. O `Stop-Process electron` não mata esse `node`:
+
+```powershell
+Get-CimInstance Win32_Process | Where-Object {
+  $_.CommandLine -and ($_.CommandLine -match 'agent-hub|_npx|next dev|43147')
+} | ForEach-Object { Stop-Process -Id $_.ProcessId -Force -ErrorAction SilentlyContinue }
+Remove-Item -Recurse -Force "$env:LOCALAPPDATA\npm-cache\_npx" -ErrorAction SilentlyContinue
+npx --yes agent-hub-sdd@0.1.6
+```
+
+Instalar global evita o rename do `npx` nessa pasta:
+
+```powershell
+npm install -g agent-hub-sdd@0.1.6
+agent-hub-sdd
+```
 
 ## App no Windows (a partir do código)
 

package/electron/main.mjs

@@ -1,66 +1,170 @@
 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}`;
 const here = path.dirname(fileURLToPath(import.meta.url));
 const repoRoot = path.join(here, "..");
+const VERSION = JSON.parse(fs.readFileSync(path.join(repoRoot, "package.json"), "utf8")).version;
 
 let win;
 let child;
 let startedServer = false;
+let logs = "";
 
 function hubDir() {
-  return app.isPackaged ? path.join(process.resourcesPath, "hub") : repoRoot;
+  if (app.isPackaged) return path.join(process.resourcesPath, "hub");
+  const dist = path.join(repoRoot, "dist-hub");
+  if (fs.existsSync(path.join(dist, "server.js"))) return dist;
+  return stageHub(repoRoot);
 }
 
-function isUp() {
+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 hubHtml() {
   return new Promise((resolve) => {
     const req = http.get(HUB, (res) => {
-      res.resume();
-      resolve(true);
+      const chunks = [];
+      res.on("data", (chunk) => {
+        chunks.push(chunk);
+        if (Buffer.concat(chunks).length > 40000) res.destroy();
+      });
+      res.on("end", () => {
+        resolve({ status: res.statusCode ?? 0, body: Buffer.concat(chunks).toString("utf8") });
+      });
     });
-    req.on("error", () => resolve(false));
-    req.setTimeout(800, () => {
+    req.on("error", () => resolve(null));
+    req.setTimeout(20000, () => {
       req.destroy();
-      resolve(false);
+      resolve(null);
     });
   });
 }
 
-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 pageReady(html) {
+  if (!html) return false;
+  if (/Can't resolve|Module not found|Module parse failed/.test(html.body)) return false;
+  return html.status === 200 && /Agent Hub|Carregando o hub/.test(html.body);
+}
+
+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 serverJs = path.join(cwd, "server.js");
+  const args = fs.existsSync(serverJs)
+    ? [serverJs]
+    : [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 < 24; i++) {
+    const html = await hubHtml();
+    if (pageReady(html)) return;
+    if (html?.body && /Can't resolve|Module not found|Module parse failed/.test(html.body)) {
+      throw new Error(`Falha ao compilar o hub.\n${html.body.slice(0, 1500)}`);
+    }
+    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() {
@@ -88,7 +192,17 @@ function createWindow() {
     },
   });
   win.once("ready-to-show", () => win.show());
-  win.loadURL(HUB);
+  void win.loadURL(
+    `data:text/html;charset=utf-8,${encodeURIComponent(`<!doctype html>
+<html lang="pt-BR">
+<body style="margin:0;background:#000;color:#e4e4e7;font-family:'Segoe UI',sans-serif;display:flex;min-height:100vh;align-items:center;justify-content:center">
+  <div style="text-align:center;max-width:28rem;padding:1.5rem">
+    <p style="font-size:1.15rem;margin:0 0 .75rem">Agent Hub ${VERSION}</p>
+    <p style="color:#a1a1aa;line-height:1.6;margin:0">Primeira abertura compila o hub. Pode levar alguns minutos. Não feche a janela.</p>
+  </div>
+</body>
+</html>`)}`,
+  );
   win.webContents.setWindowOpenHandler(({ url }) => {
     void shell.openExternal(url);
     return { action: "deny" };
@@ -107,26 +221,30 @@ ipcMain.handle("pick-folder", async () => {
 
 app.whenReady().then(async () => {
   try {
-    if (!(await isUp())) {
+    createWindow();
+    const html = await hubHtml();
+    if (!pageReady(html)) {
       child = startServer();
       startedServer = true;
-      child.on("error", (error) => {
-        void dialog.showErrorBox("Agent Hub", error.message);
-      });
+      await waitForHub(child);
     }
-    await waitForHub();
-    createWindow();
+    await win.loadURL(HUB);
   } 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\nAgent Hub ${VERSION}. O app precisa do Node.js 20+ (o mesmo node do npx).\nRode: npx --yes agent-hub-sdd@${VERSION}`,
     );
     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.6" }));
+    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,35 @@
 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,
+  devIndicators: 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.6",
   "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,8 +1,10 @@
-#!/usr/bin/env node
+#!/usr/bin/env node
 const { spawn } = require("node:child_process");
 const path = require("node:path");
 
 const root = path.join(__dirname, "..");
+const pkg = require(path.join(root, "package.json"));
+console.log(`Agent Hub ${pkg.version}`);
 let electron;
 try {
   electron = require("electron");
@@ -11,12 +13,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);

package/scripts/kill-hub.ps1

@@ -0,0 +1,11 @@
+$ErrorActionPreference = "SilentlyContinue"
+Get-CimInstance Win32_Process |
+  Where-Object {
+    $_.CommandLine -and
+    ($_.CommandLine -match "agent-hub|_npx|next dev|43147")
+  } |
+  ForEach-Object { Stop-Process -Id $_.ProcessId -Force }
+Stop-Process -Name electron -Force
+$npx = Join-Path $env:LOCALAPPDATA "npm-cache\_npx"
+if (Test-Path $npx) { Remove-Item -Recurse -Force $npx }
+Write-Host "Cache do npx limpo. Rode: npx --yes agent-hub-sdd@0.1.6"

package/src/app/globals.css

@@ -7,8 +7,8 @@
 @theme inline {
   --color-background: var(--background);
   --color-foreground: var(--foreground);
-  --font-sans: var(--font-geist-sans);
-  --font-mono: var(--font-geist-mono);
+  --font-sans: "Segoe UI", ui-sans-serif, system-ui, sans-serif;
+  --font-mono: "Cascadia Mono", Consolas, ui-monospace, monospace;
   --font-heading: var(--font-sans);
   --color-sidebar-ring: var(--sidebar-ring);
   --color-sidebar-border: var(--sidebar-border);

package/src/app/layout.tsx

@@ -1,19 +1,8 @@
 import type { Metadata } from "next";
-import { Geist, Geist_Mono } from "next/font/google";
 import { DesktopChrome } from "@/components/desktop-chrome";
 import { TooltipProvider } from "@/components/ui/tooltip";
 import "./globals.css";
 
-const geistSans = Geist({
-  variable: "--font-geist-sans",
-  subsets: ["latin"],
-});
-
-const geistMono = Geist_Mono({
-  variable: "--font-geist-mono",
-  subsets: ["latin"],
-});
-
 export const metadata: Metadata = {
   title: "Agent Hub",
   description: "Harness visual local para agentes do SDLC",
@@ -21,10 +10,7 @@ export const metadata: Metadata = {
 
 export default function RootLayout({ children }: LayoutProps<"/">) {
   return (
-    <html
-      lang="pt-BR"
-      className={`${geistSans.variable} ${geistMono.variable} dark h-full antialiased`}
-    >
+    <html lang="pt-BR" className="dark h-full antialiased">
       <body className="flex min-h-dvh flex-col bg-black text-zinc-100">
         <TooltipProvider>
           <DesktopChrome />