pudu-ai 0.2.15 → 0.2.16

package/dist/cli/index.js

@@ -1,4 +1,178 @@
 #!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res, err) => function __init() {
+  if (err) throw err[0];
+  try {
+    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+  } catch (e) {
+    throw err = [e], e;
+  }
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/shared/process.ts
+import { execa } from "execa";
+function installSignalHandlers() {
+  if (installed) return;
+  installed = true;
+  const stop = () => {
+    void killAll("SIGTERM");
+  };
+  process.once("SIGINT", stop);
+  process.once("SIGTERM", stop);
+}
+function spawnTracked(file, args2 = [], options = {}) {
+  installSignalHandlers();
+  const subprocess = execa(file, args2, {
+    reject: false,
+    timeout: options.timeout ?? 3e4,
+    ...options
+  });
+  children.add(subprocess);
+  void subprocess.finally(() => {
+    children.delete(subprocess);
+  });
+  return subprocess;
+}
+function toText(value) {
+  if (typeof value === "string") return value;
+  if (value instanceof Uint8Array) return Buffer.from(value).toString("utf8");
+  if (Array.isArray(value)) return value.map(String).join("\n");
+  if (value == null) return "";
+  return String(value);
+}
+async function runCommand(file, args2 = [], options = {}) {
+  const result = await spawnTracked(file, args2, options);
+  return {
+    stdout: toText(result.stdout),
+    stderr: toText(result.stderr),
+    exitCode: result.exitCode,
+    timedOut: Boolean(result.timedOut)
+  };
+}
+async function killAll(signal = "SIGTERM") {
+  for (const child of [...children]) {
+    child.kill(signal);
+  }
+}
+var children, installed;
+var init_process = __esm({
+  "src/shared/process.ts"() {
+    "use strict";
+    children = /* @__PURE__ */ new Set();
+    installed = false;
+  }
+});
+
+// src/shared/which.ts
+import { access } from "node:fs/promises";
+import { constants } from "node:fs";
+import path2 from "node:path";
+async function commandExists(name) {
+  if (name.includes("/") || name.includes("\\")) {
+    try {
+      await access(name, constants.X_OK);
+      return name;
+    } catch {
+      return void 0;
+    }
+  }
+  const pathEnv = process.env.PATH ?? "";
+  const parts = pathEnv.split(path2.delimiter);
+  for (const dir of parts) {
+    const candidate = path2.join(dir, name);
+    try {
+      await access(candidate, constants.X_OK);
+      return candidate;
+    } catch {
+      continue;
+    }
+  }
+  return void 0;
+}
+var init_which = __esm({
+  "src/shared/which.ts"() {
+    "use strict";
+  }
+});
+
+// src/integrations/brew.ts
+var brew_exports = {};
+__export(brew_exports, {
+  brewInstallCask: () => brewInstallCask,
+  dockerReady: () => dockerReady,
+  ensureBrew: () => ensureBrew,
+  resolveBrew: () => resolveBrew,
+  startDockerDesktop: () => startDockerDesktop,
+  waitForDocker: () => waitForDocker
+});
+async function resolveBrew() {
+  for (const bin of BREW_CANDIDATES) {
+    const found = await commandExists(bin);
+    if (found) return found;
+  }
+  return void 0;
+}
+async function dockerReady() {
+  const docker = await commandExists("docker");
+  if (!docker) return false;
+  const info = await runCommand("docker", ["info"], { timeout: 8e3 });
+  return info.exitCode === 0;
+}
+async function ensureBrew() {
+  const existing = await resolveBrew();
+  if (existing) return { ok: true, brew: existing, log: existing };
+  const install = await runCommand(
+    "/bin/bash",
+    ["-c", 'NONINTERACTIVE=1 /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"'],
+    { timeout: 15 * 6e4 }
+  );
+  const after = await resolveBrew();
+  if (after) return { ok: true, brew: after, log: after };
+  return {
+    ok: false,
+    log: install.stderr || "Homebrew missing. Install: https://brew.sh"
+  };
+}
+async function brewInstallCask(name) {
+  const brew = await resolveBrew();
+  if (!brew) {
+    const ensured = await ensureBrew();
+    if (!ensured.ok || !ensured.brew) return { ok: false, log: ensured.log };
+    const result2 = await runCommand(ensured.brew, ["install", "--cask", name], { timeout: 15 * 6e4 });
+    return { ok: result2.exitCode === 0, log: result2.stderr || result2.stdout };
+  }
+  const result = await runCommand(brew, ["install", "--cask", name], { timeout: 15 * 6e4 });
+  if (result.exitCode === 0) return { ok: true, log: result.stdout };
+  const formula = await runCommand(brew, ["install", name], { timeout: 15 * 6e4 });
+  return { ok: formula.exitCode === 0, log: formula.stderr || formula.stdout };
+}
+async function startDockerDesktop() {
+  if (process.platform === "darwin") {
+    await runCommand("open", ["-a", "Docker"], { timeout: 15e3 });
+  }
+}
+async function waitForDocker(ms = 9e4) {
+  const start = Date.now();
+  while (Date.now() - start < ms) {
+    if (await dockerReady()) return true;
+    await new Promise((resolve) => setTimeout(resolve, 2500));
+  }
+  return dockerReady();
+}
+var BREW_CANDIDATES;
+var init_brew = __esm({
+  "src/integrations/brew.ts"() {
+    "use strict";
+    init_which();
+    init_process();
+    BREW_CANDIDATES = ["/opt/homebrew/bin/brew", "/usr/local/bin/brew", "brew"];
+  }
+});
 
 // src/cli/parse-args.ts
 function parseArgs(argv) {
@@ -118,56 +292,9 @@ async function addModelPath(dir) {
 import os5 from "node:os";
 
 // src/platform/macos/hardware.ts
+init_process();
 import os2 from "node:os";
 
-// src/shared/process.ts
-import { execa } from "execa";
-var children = /* @__PURE__ */ new Set();
-var installed = false;
-function installSignalHandlers() {
-  if (installed) return;
-  installed = true;
-  const stop = () => {
-    void killAll("SIGTERM");
-  };
-  process.once("SIGINT", stop);
-  process.once("SIGTERM", stop);
-}
-function spawnTracked(file, args2 = [], options = {}) {
-  installSignalHandlers();
-  const subprocess = execa(file, args2, {
-    reject: false,
-    timeout: options.timeout ?? 3e4,
-    ...options
-  });
-  children.add(subprocess);
-  void subprocess.finally(() => {
-    children.delete(subprocess);
-  });
-  return subprocess;
-}
-function toText(value) {
-  if (typeof value === "string") return value;
-  if (value instanceof Uint8Array) return Buffer.from(value).toString("utf8");
-  if (Array.isArray(value)) return value.map(String).join("\n");
-  if (value == null) return "";
-  return String(value);
-}
-async function runCommand(file, args2 = [], options = {}) {
-  const result = await spawnTracked(file, args2, options);
-  return {
-    stdout: toText(result.stdout),
-    stderr: toText(result.stderr),
-    exitCode: result.exitCode,
-    timedOut: Boolean(result.timedOut)
-  };
-}
-async function killAll(signal = "SIGTERM") {
-  for (const child of [...children]) {
-    child.kill(signal);
-  }
-}
-
 // src/shared/bytes.ts
 var GiB = 1024 ** 3;
 var MiB = 1024 ** 2;
@@ -377,32 +504,9 @@ async function detectHardware() {
 import os7 from "node:os";
 import path5 from "node:path";
 
-// src/shared/which.ts
-import { access } from "node:fs/promises";
-import { constants } from "node:fs";
-import path2 from "node:path";
-async function commandExists(name) {
-  if (name.includes("/") || name.includes("\\")) {
-    try {
-      await access(name, constants.X_OK);
-      return name;
-    } catch {
-      return void 0;
-    }
-  }
-  const pathEnv = process.env.PATH ?? "";
-  const parts = pathEnv.split(path2.delimiter);
-  for (const dir of parts) {
-    const candidate = path2.join(dir, name);
-    try {
-      await access(candidate, constants.X_OK);
-      return candidate;
-    } catch {
-      continue;
-    }
-  }
-  return void 0;
-}
+// src/adapters/ollama/index.ts
+init_process();
+init_which();
 
 // src/adapters/ollama/parse.ts
 function parseOllamaList(output) {
@@ -485,6 +589,7 @@ import path4 from "node:path";
 import { access as access2 } from "node:fs/promises";
 
 // src/adapters/llamacpp/index.ts
+init_which();
 import { readdir, stat } from "node:fs/promises";
 import path3 from "node:path";
 var BINARIES = ["llama-bench", "llama-cli", "llama-server"];
@@ -623,6 +728,7 @@ async function discoverLocalModels() {
 }
 
 // src/adapters/mlx/index.ts
+init_which();
 var mlxAdapter = {
   id: "mlx",
   label: "MLX",
@@ -644,6 +750,7 @@ var mlxAdapter = {
 };
 
 // src/runtimes/registry.ts
+init_which();
 var runtimes = [ollamaAdapter, llamaCppAdapter, lmStudioAdapter, mlxAdapter];
 async function detectRuntimes() {
   const llamaBench = Boolean(await commandExists("llama-bench"));
@@ -849,7 +956,9 @@ var en = {
   dockerHint: "press 4 to run ollama/ollama in Docker",
   dockerStarting: "Starting ollama/ollama container\u2026",
   dockerRunOk: "Docker Ollama is up on port 11434 (name: pudu-ollama).",
-  dockerRunFail: "docker run failed. Is Docker Desktop running?",
+  dockerRunFail: "Docker daemon is not running. Open Docker Desktop, wait until it is idle, press 4 again.",
+  dockerBrewInstall: "Installing Docker with Homebrew (brew install --cask docker)\u2026",
+  dockerDesktopWait: "Starting Docker Desktop and waiting for the daemon\u2026",
   aboutHistory: "Shows local benchmark files in ~/.pudu-ai/benchmarks. Use it to replay what this machine actually did.",
   aboutDoctor: "Checks Node, Apple Silicon/Metal, Ollama, llama-bench, and the CanIRun API. Use it to see what is missing before a bench or launch.",
   aboutReport: "Writes the latest measured run as Markdown. Use it to paste results into GitHub or notes.",
@@ -1043,7 +1152,9 @@ var es = {
   dockerHint: "pulsa 4 para correr ollama/ollama en Docker",
   dockerStarting: "Arrancando contenedor ollama/ollama\u2026",
   dockerRunOk: "Ollama en Docker est\xE1 en el puerto 11434 (nombre: pudu-ollama).",
-  dockerRunFail: "fall\xF3 docker run. \xBFDocker Desktop est\xE1 abierto?",
+  dockerRunFail: "El daemon de Docker no corre. Abre Docker Desktop, espera a que est\xE9 listo y pulsa 4 otra vez.",
+  dockerBrewInstall: "Instalando Docker con Homebrew (brew install --cask docker)\u2026",
+  dockerDesktopWait: "Arrancando Docker Desktop y esperando al daemon\u2026",
   aboutHistory: "Muestra los JSON locales en ~/.pudu-ai/benchmarks. Sirve para ver qu\xE9 hizo realmente esta m\xE1quina.",
   aboutDoctor: "Revisa Node, Apple Silicon/Metal, Ollama, llama-bench y la API de CanIRun. Sirve para ver qu\xE9 falta antes de un bench o un launch.",
   aboutReport: "Exporta la \xFAltima corrida medida en Markdown. Sirve para pegar resultados en GitHub o notas.",
@@ -1462,7 +1573,11 @@ async function listBenchmarks() {
   return records;
 }
 
+// src/session/load.ts
+init_which();
+
 // src/integrations/agents.ts
+init_which();
 var AGENTS = [
   {
     id: "opencode",
@@ -1531,7 +1646,12 @@ async function loadSession(options) {
   };
 }
 
+// src/benchmark/engine.ts
+init_process();
+init_which();
+
 // src/telemetry/macos.ts
+init_process();
 import os9 from "node:os";
 
 // src/telemetry/fallback.ts
@@ -2017,6 +2137,9 @@ function resourceFields(resources) {
   };
 }
 
+// src/cli/run.ts
+init_process();
+
 // src/shared/logger.ts
 var level = "info";
 function setLogLevel(next) {
@@ -2572,6 +2695,7 @@ function parseIntegration(raw) {
 }
 
 // src/integrations/execute.ts
+init_process();
 async function executeLaunch(decision) {
   if (!decision.eligible || !decision.ollamaTag) {
     return { ok: false, log: t("launchBlocked") };
@@ -2602,6 +2726,23 @@ ${launched.stderr || launched.stdout || t("launchExecFail")}`
 ${launched.stdout}`.trim() };
 }
 async function executeDockerOllama() {
+  const { brewInstallCask: brewInstallCask2, dockerReady: dockerReady2, startDockerDesktop: startDockerDesktop2, waitForDocker: waitForDocker2 } = await Promise.resolve().then(() => (init_brew(), brew_exports));
+  const notes = [];
+  if (!await dockerReady2()) {
+    notes.push(t("dockerBrewInstall"));
+    const installed2 = await brewInstallCask2("docker");
+    if (!installed2.ok) {
+      return { ok: false, log: `${t("reqDocker")}
+${installed2.log}` };
+    }
+    notes.push(t("dockerDesktopWait"));
+    await startDockerDesktop2();
+    const up = await waitForDocker2();
+    if (!up) return { ok: false, log: `${notes.join("\n")}
+${t("dockerRunFail")}` };
+  }
+  const start = await runCommand("docker", ["start", "pudu-ollama"], { timeout: 3e4 });
+  if (start.exitCode === 0) return { ok: true, log: t("dockerRunOk") };
   const args2 = DOCKER_OLLAMA.split(" ").slice(1);
   const result = await runCommand("docker", args2, { timeout: 10 * 6e4 });
   if (result.exitCode !== 0) {
@@ -2611,6 +2752,7 @@ async function executeDockerOllama() {
 }
 
 // src/integrations/pull.ts
+init_process();
 var INSTALLABLE = ["S", "A", "B"];
 function canInstallGrade(grade) {
   return Boolean(grade && INSTALLABLE.includes(grade));
@@ -2659,11 +2801,6 @@ function SetupView({ session }) {
       });
     }
     if (input === "4") {
-      const docker = session.runtimes.find((r) => r.id === "docker")?.detected;
-      if (!docker) {
-        setLog(t("reqDocker"));
-        return;
-      }
       setBusy(true);
       setLog(t("dockerStarting"));
       void executeDockerOllama().then((result) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pudu-ai",
-  "version": "0.2.15",
+  "version": "0.2.16",
   "description": "Pudu-AI — local AI hardware & benchmark lab for the terminal",
   "keywords": [
     "ai",