donkicode 0.1.1 → 0.1.3

package/bin/donkicode

@@ -35,6 +35,43 @@ import { fileURLToPath } from "node:url"
 
 const __filename = fileURLToPath(import.meta.url)
 
+// Localiza el bundle del frontend (`<pkg>/dist/index.html`) que `build.ts` deja
+// junto al binario. Robusto ante el cache `.donkicode` del postinstall: si el
+// binario que arranca es un hard-link/copia dentro del META (cuyo path NO trae
+// `dist/`), cae a buscar el paquete de plataforma `donkicode-*` en node_modules.
+function resolveStaticDir(target) {
+  // 1) Hermano del binario REAL — binario de plataforma directo, o un symlink
+  //    que `realpath` resuelve al paquete de plataforma.
+  try {
+    const real = fs.realpathSync(target)
+    const sibling = path.join(path.dirname(path.dirname(real)), "dist")
+    if (fs.existsSync(path.join(sibling, "index.html"))) return sibling
+  } catch {
+    /* ignore */
+  }
+  // 2) Fallback: el frontend vive en el paquete de plataforma. Subimos por
+  //    node_modules buscando cualquier `donkicode-*/dist/index.html`.
+  try {
+    let current = path.dirname(fs.realpathSync(__filename))
+    for (;;) {
+      const modules = path.join(current, "node_modules")
+      if (fs.existsSync(modules)) {
+        for (const entry of fs.readdirSync(modules)) {
+          if (!entry.startsWith("donkicode-")) continue
+          const guess = path.join(modules, entry, "dist")
+          if (fs.existsSync(path.join(guess, "index.html"))) return guess
+        }
+      }
+      const parent = path.dirname(current)
+      if (parent === current) break
+      current = parent
+    }
+  } catch {
+    /* ignore */
+  }
+  return undefined
+}
+
 function run(target, args) {
   // DEC-041 (T-238b / Cabo 5) — si al lado del binario nativo vive un bundle
   // de frontend estático (`<pkg-dir>/dist/index.html`), el shim exporta
@@ -44,11 +81,8 @@ function run(target, args) {
   // definió la env var, no la sobreescribimos.
   const env = { ...process.env }
   if (!env.DONKICODE_STATIC_DIR) {
-    const pkgDir = path.dirname(path.dirname(fs.realpathSync(target)))
-    const staticDir = path.join(pkgDir, "dist")
-    if (fs.existsSync(path.join(staticDir, "index.html"))) {
-      env.DONKICODE_STATIC_DIR = staticDir
-    }
+    const staticDir = resolveStaticDir(target)
+    if (staticDir) env.DONKICODE_STATIC_DIR = staticDir
   }
   const result = childProcess.spawnSync(target, args, {
     stdio: "inherit",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "donkicode",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "DonkiCode — el estudio de agentes con memoria memodonki.",
   "bin": {
     "donkicode": "./bin/donkicode"
@@ -10,16 +10,16 @@
   },
   "license": "UNLICENSED",
   "optionalDependencies": {
-    "donkicode-linux-arm64": "0.1.1",
-    "donkicode-linux-x64-baseline": "0.1.1",
-    "donkicode-linux-x64-baseline-musl": "0.1.1",
-    "donkicode-windows-x64": "0.1.1",
-    "donkicode-windows-x64-baseline": "0.1.1",
-    "donkicode-darwin-arm64": "0.1.1",
-    "donkicode-linux-x64-musl": "0.1.1",
-    "donkicode-linux-arm64-musl": "0.1.1",
-    "donkicode-darwin-x64-baseline": "0.1.1",
-    "donkicode-linux-x64": "0.1.1",
-    "donkicode-darwin-x64": "0.1.1"
+    "donkicode-linux-x64-baseline": "0.1.3",
+    "donkicode-linux-x64": "0.1.3",
+    "donkicode-linux-arm64": "0.1.3",
+    "donkicode-darwin-x64-baseline": "0.1.3",
+    "donkicode-linux-x64-musl": "0.1.3",
+    "donkicode-linux-arm64-musl": "0.1.3",
+    "donkicode-windows-x64": "0.1.3",
+    "donkicode-linux-x64-baseline-musl": "0.1.3",
+    "donkicode-windows-x64-baseline": "0.1.3",
+    "donkicode-darwin-x64": "0.1.3",
+    "donkicode-darwin-arm64": "0.1.3"
   }
 }

package/postinstall.mjs

@@ -118,12 +118,24 @@ async function main() {
     // cache con el nombre viejo; ahora es el que el shim espera.
     const target = path.join(__dirname, "bin", ".donkicode")
     if (fs.existsSync(target)) fs.unlinkSync(target)
+    // SYMLINK, no hard link (bug 404 del 2026-07-24): el shim deriva la carpeta
+    // del frontend estático del PATH del binario que arranca. Un hard link
+    // comparte el inode pero su path sigue siendo `<meta>/bin/.donkicode`, y el
+    // meta NO trae `dist/` → el shim buscaba la UI en `<meta>/dist` (inexistente)
+    // y servía 404. Un symlink hace que `fs.realpathSync` resuelva al paquete de
+    // plataforma (`donkicode-<plat>-<arch>/bin/donkicode`), cuyo hermano `dist/`
+    // SÍ es el frontend. Fallbacks (hard link / copia) los cubre el shim, que
+    // además localiza el bundle en el paquete de plataforma por su cuenta.
     try {
-      fs.linkSync(binaryPath, target)
+      fs.symlinkSync(binaryPath, target)
     } catch {
-      fs.copyFileSync(binaryPath, target)
+      try {
+        fs.linkSync(binaryPath, target)
+      } catch {
+        fs.copyFileSync(binaryPath, target)
+      }
     }
-    fs.chmodSync(target, 0o755)
+    if (!fs.lstatSync(target).isSymbolicLink()) fs.chmodSync(target, 0o755)
     console.log(`donkicode: binario nativo enlazado (${binaryPath})`)
   } catch (error) {
     console.error("No pude preparar el binario de donkicode:", error.message)