zugzbot 1.1.6 → 1.2.0

package/.opencode/tools/sdd_network.ts

@@ -1,6 +1,7 @@
 import { tool } from "@opencode-ai/plugin"
 import fs from "fs"
 import path from "path"
+import crypto from "crypto"
 import { execSync, spawn } from "child_process"
 
 // Helper to safely resolve root directory (avoiding OpenCode bug where worktree is '/' in non-git repos)
@@ -20,7 +21,7 @@ const getTargetDir = (root: string): string => {
       if (data && data.targetDir) return data.targetDir
     }
   } catch (e) {}
-  
+
   try {
     const statePath = path.resolve(root, ".openspec/sdd_state.json")
     if (fs.existsSync(statePath)) {
@@ -32,9 +33,68 @@ const getTargetDir = (root: string): string => {
   return "."
 }
 
-// Helper to get PID file path
+// ============================================================================
+// Unix-style PID/PGID storage in /tmp (bugfix sesion 1176: servidor caia al
+// cerrar subagente; ademas chocaba entre proyectos zugzbot simultaneos).
+//
+// Esquema:
+//   /tmp/zugzbot-dev-server-<hash8>        -> PID (referencia principal)
+//   /tmp/zugzbot-dev-server-<hash8>.pgid   -> PGID (para kill -SIGTERM -PGID)
+//
+// hash8 = primeros 8 chars de md5(root) para evitar colisiones entre
+// distintos proyectos zugzbot abiertos en paralelo.
+// ============================================================================
+
+const projectHash = (root: string): string => {
+  return crypto.createHash("md5").update(root).digest("hex").slice(0, 8)
+}
+
 const getPidFilePath = (root: string) => {
-  return path.resolve(root, ".openspec/dev_server.pid")
+  return `/tmp/zugzbot-dev-server-${projectHash(root)}`
+}
+const getPgidFilePath = (root: string) => {
+  return `/tmp/zugzbot-dev-server-${projectHash(root)}.pgid`
+}
+
+const readPidFiles = (root: string): { pid: number | null; pgid: number | null } => {
+  let pid: number | null = null
+  let pgid: number | null = null
+  try {
+    if (fs.existsSync(getPidFilePath(root))) {
+      pid = parseInt(fs.readFileSync(getPidFilePath(root), "utf8").trim(), 10)
+      if (!Number.isFinite(pid)) pid = null
+    }
+  } catch (e) {}
+  try {
+    if (fs.existsSync(getPgidFilePath(root))) {
+      pgid = parseInt(fs.readFileSync(getPgidFilePath(root), "utf8").trim(), 10)
+      if (!Number.isFinite(pgid)) pgid = null
+    }
+  } catch (e) {}
+  return { pid, pgid }
+}
+
+const clearPidFiles = (root: string) => {
+  try { fs.unlinkSync(getPidFilePath(root)) } catch (e) {}
+  try { fs.unlinkSync(getPgidFilePath(root)) } catch (e) {}
+}
+
+const killProcessGroup = (pgid: number, signal: NodeJS.Signals = "SIGTERM"): boolean => {
+  try {
+    process.kill(-pgid, signal)
+    return true
+  } catch (e) {
+    return false
+  }
+}
+
+const isPidAlive = (pid: number): boolean => {
+  try {
+    process.kill(pid, 0)
+    return true
+  } catch (e) {
+    return false
+  }
 }
 
 // Tool: sdd_free_port
@@ -68,8 +128,17 @@ export const free_port = tool({
 })
 
 // Tool: sdd_start_server
+//
+// Bugfix sesion 1176: el dev server caia al cerrar el subagente coder porque
+// el proceso hijo hereda el process group del opencode padre y moría con él.
+// Solucion: envolver el spawn con `setsid` (disponible en macOS/Linux) para
+// crear un nuevo session leader completamente independiente, y guardar tanto
+// el PID como el PGID en /tmp para poder matar todo el grupo limpiamente.
 export const start_server = tool({
-  description: "Inicia un servidor en segundo plano y registra su PID.",
+  description:
+    "Inicia un servidor en segundo plano y registra su PID/PGID en /tmp. " +
+    "El proceso se desacopla del opencode padre con `setsid`, de modo que " +
+    "sobrevive al cierre del subagente que lo lanzó (bugfix sesion 1176).",
   args: {
     command: tool.schema.string().describe("Comando para iniciar el servidor (ej. 'yarn dev' o 'npm run dev')"),
     port: tool.schema.number().optional().default(3000).describe("Puerto esperado del servidor (default: 3000)"),
@@ -80,21 +149,45 @@ export const start_server = tool({
     const targetDir = getTargetDir(root)
     const targetCwd = args.cwd ? path.resolve(root, args.cwd) : (targetDir === "." ? root : path.resolve(root, targetDir))
     const pidFile = getPidFilePath(root)
+    const pgidFile = getPgidFilePath(root)
 
+    // Liberar puerto si esta ocupado (limpieza previa)
     try {
       const existingPid = execSync(`lsof -t -i :${args.port}`).toString().trim()
       if (existingPid) {
         execSync(`kill -9 ${existingPid.split('\n').join(' ')}`)
       }
     } catch (e) {
-      // ignore
+      // ignore: puerto libre
     }
 
+    // Si hay un PID previo registrado, intentar matarlo limpiamente primero
+    const prev = readPidFiles(root)
+    if (prev.pgid && isPidAlive(prev.pgid)) {
+      killProcessGroup(prev.pgid, "SIGTERM")
+      await new Promise(r => setTimeout(r, 500))
+      if (isPidAlive(prev.pgid)) {
+        killProcessGroup(prev.pgid, "SIGKILL")
+      }
+    } else if (prev.pid && isPidAlive(prev.pid)) {
+      try { process.kill(prev.pid, "SIGKILL") } catch (e) {}
+    }
+    clearPidFiles(root)
+
     const parts = args.command.split(" ")
     const cmd = parts[0]
     const cmdArgs = parts.slice(1)
 
-    const child = spawn(cmd, cmdArgs, {
+    // Usar setsid para crear un nuevo session leader. Asi, cuando el subagente
+    // coder termine, el dev server no es killed por SIGTERM en cascada.
+    // setsid existe en macOS (coreutils) y Linux por defecto.
+    const useSetsid = process.platform !== "win32"
+
+    const spawnArgs = useSetsid
+      ? { cmd: "setsid", cmdArgs: [cmd, ...cmdArgs] }
+      : { cmd, cmdArgs }
+
+    const child = spawn(spawnArgs.cmd, spawnArgs.cmdArgs, {
       cwd: targetCwd,
       detached: true,
       stdio: "ignore",
@@ -104,22 +197,37 @@ export const start_server = tool({
       }
     })
 
-    child.unref()
+    // CRITICO: NO usar child.unref() — necesitamos mantener la referencia
+    // para que el proceso no sea reaped inmediatamente y para tener el PGID
+    // disponible. Sin embargo, el spawn fue `detached: true` con setsid, asi
+    // que el proceso ya esta en su propio session group.
+    //
+    // El handler exit solo borra los PID files si el proceso muere solo.
+    child.on('exit', () => {
+      clearPidFiles(root)
+    })
+    child.on('error', () => {
+      clearPidFiles(root)
+    })
 
     const pid = child.pid
     if (pid) {
-      const dir = path.dirname(pidFile)
-      if (!fs.existsSync(dir)) {
-        fs.mkdirSync(dir, { recursive: true })
-      }
+      // En setsid, el PID del proceso spawned es el PGID del nuevo grupo
+      const pgid = pid
       fs.writeFileSync(pidFile, String(pid), "utf8")
+      fs.writeFileSync(pgidFile, String(pgid), "utf8")
 
+      // Esperar a que arranque
       await new Promise(resolve => setTimeout(resolve, 3000))
 
       return JSON.stringify({
         status: "SUCCESS",
-        message: `Servidor iniciado con PID ${pid} ejecutando '${args.command}' en puerto ${args.port}`,
-        pid
+        message: `Servidor iniciado con PID ${pid} (PGID ${pgid}) ejecutando '${args.command}' en puerto ${args.port}. PID file: ${pidFile}`,
+        pid,
+        pgid,
+        pid_file: pidFile,
+        pgid_file: pgidFile,
+        detached_via: useSetsid ? "setsid" : "none"
       }, null, 2)
     }
 
@@ -131,44 +239,101 @@ export const start_server = tool({
 })
 
 // Tool: sdd_stop_server
+//
+// Mata el grupo de procesos completo (SIGTERM graceful, luego SIGKILL si
+// no responde en 2s). Esto libera el puerto automaticamente.
 export const stop_server = tool({
-  description: "Detiene el servidor en segundo plano registrado.",
+  description:
+    "Detiene el servidor en segundo plano registrado. Mata el process group " +
+    "completo (SIGTERM, fallback SIGKILL tras 2s) usando el PGID guardado en /tmp.",
   args: {},
   async execute(args, context) {
     const root = getRoot(context)
-    const pidFile = getPidFilePath(root)
+    const { pid, pgid } = readPidFiles(root)
+
+    if (!pid && !pgid) {
+      return JSON.stringify({
+        status: "SUCCESS",
+        message: "No hay ningún servidor registrado activo"
+      }, null, 2)
+    }
 
-    if (fs.existsSync(pidFile)) {
-      try {
-        const pidStr = fs.readFileSync(pidFile, "utf8").trim()
-        const pid = parseInt(pidStr, 10)
-        if (!isNaN(pid)) {
-          try {
-            process.kill(-pid, "SIGKILL")
-          } catch (err) {
-            try {
-              process.kill(pid, "SIGKILL")
-            } catch (err2) {
-              // ignore
-            }
-          }
-          fs.unlinkSync(pidFile)
-          return JSON.stringify({
-            status: "SUCCESS",
-            message: `Servidor con PID ${pid} terminado exitosamente`
-          }, null, 2)
+    let killed = false
+    let signal_used: string | null = null
+
+    if (pgid && isPidAlive(pgid)) {
+      // SIGTERM graceful primero
+      if (killProcessGroup(pgid, "SIGTERM")) {
+        signal_used = "SIGTERM"
+        killed = true
+      }
+      // Esperar hasta 2s
+      await new Promise(r => setTimeout(r, 2000))
+      // Si sigue vivo, SIGKILL
+      if (isPidAlive(pgid)) {
+        if (killProcessGroup(pgid, "SIGKILL")) {
+          signal_used = signal_used ? `${signal_used}+SIGKILL` : "SIGKILL"
         }
-      } catch (e) {
-        return JSON.stringify({
-          status: "ERROR",
-          message: `Error al intentar detener el servidor: ${(e as Error).message}`
-        }, null, 2)
+      }
+    } else if (pid && isPidAlive(pid)) {
+      // Fallback: matar solo el PID
+      try { process.kill(pid, "SIGTERM"); signal_used = "SIGTERM"; killed = true } catch (e) {}
+      await new Promise(r => setTimeout(r, 2000))
+      if (isPidAlive(pid)) {
+        try { process.kill(pid, "SIGKILL"); signal_used = "SIGKILL" } catch (e) {}
       }
     }
 
+    clearPidFiles(root)
+
     return JSON.stringify({
-      status: "SUCCESS",
-      message: "No hay ningún servidor registrado activo"
+      status: killed ? "SUCCESS" : "WARNING",
+      message: killed
+        ? `Servidor (PID ${pid}, PGID ${pgid}) terminado via ${signal_used}`
+        : `PID/PGID ${pid}/${pgid} no estaba vivo (limpieza de archivos)`,
+      pid,
+      pgid,
+      signal_used
     }, null, 2)
   }
 })
+
+// Tool: sdd_server_status (utilidad: NUEVO)
+//
+// Inspecciona si el dev server sigue vivo leyendo /tmp.
+export const server_status = tool({
+  description:
+    "Verifica si el dev server registrado sigue vivo. Lee los archivos PID/PGID " +
+    "de /tmp y consulta el puerto objetivo.",
+  args: {
+    port: tool.schema.number().optional().default(3000).describe("Puerto esperado del servidor (default: 3000)")
+  },
+  async execute(args, context) {
+    const root = getRoot(context)
+    const { pid, pgid } = readPidFiles(root)
+    const pidAlive = pid ? isPidAlive(pid) : false
+    const pgidAlive = pgid ? isPidAlive(pgid) : false
+
+    let portListening = false
+    try {
+      const out = execSync(`lsof -i :${args.port} -sTCP:LISTEN -t 2>/dev/null`).toString().trim()
+      portListening = !!out
+    } catch (e) {
+      portListening = false
+    }
+
+    return JSON.stringify({
+      status: portListening ? "RUNNING" : "STOPPED",
+      message: portListening
+        ? `Dev server respondiendo en puerto ${args.port}`
+        : `No hay dev server activo en puerto ${args.port}`,
+      pid_file: getPidFilePath(root),
+      pgid_file: getPgidFilePath(root),
+      pid,
+      pgid,
+      pid_alive: pidAlive,
+      pgid_alive: pgidAlive,
+      port_listening: portListening
+    }, null, 2)
+  }
+})

package/.opencode/tools/sdd_testing.ts

@@ -248,9 +248,14 @@ export const shift_left_verify = tool({
       }, null, 2)
     }
 
-    const result: { tsc: { status: string, errors?: any[] }, eslint: { status: string, errors?: any[] } } = {
+    const result: {
+      tsc: { status: string, errors?: any[] }
+      eslint: { status: string, errors?: any[] }
+      lintCharts: { status: string, violations?: any[], summary?: string }
+    } = {
       tsc: { status: "SUCCESS" },
-      eslint: { status: "SUCCESS" }
+      eslint: { status: "SUCCESS" },
+      lintCharts: { status: "SUCCESS" }
     }
 
     // 1. Run tsc --noEmit
@@ -265,6 +270,59 @@ export const shift_left_verify = tool({
       }
     }
 
+    // 1.5 Run lint-charts (bugfix sesion 1176: detectar hsl(var(--chart-N)) en
+    // chartConfig que es CSS invalido cuando --chart-N esta definido en OKLCH).
+    // BLOQUEANTE: cualquier violacion hace fallar shift-left.
+    try {
+      const linterScript = path.resolve(root, ".opencode/scripts/lint-charts.js")
+      if (fs.existsSync(linterScript)) {
+        const lintOut = execSync(`node "${linterScript}" --json`, {
+          cwd: targetPath,
+          encoding: "utf8",
+          timeout: 30000
+        })
+        try {
+          const parsed = JSON.parse(lintOut)
+          if (parsed.status === "FAIL") {
+            result.lintCharts = {
+              status: "FAIL",
+              violations: parsed.violations || [],
+              summary: parsed.summary || "violaciones detectadas"
+            }
+          } else {
+            result.lintCharts = {
+              status: "SUCCESS",
+              summary: parsed.summary || "ok"
+            }
+          }
+        } catch (parseErr) {
+          result.lintCharts = {
+            status: "WARN",
+            summary: "no se pudo parsear salida del linter: " + lintOut.slice(0, 200)
+          }
+        }
+      }
+    } catch (e: any) {
+      // execSync lanza si exit code != 0 (linter encontro violaciones)
+      const rawOutput = e.stdout?.toString() || e.stderr?.toString() || ""
+      try {
+        const parsed = JSON.parse(rawOutput)
+        if (parsed.status === "FAIL") {
+          result.lintCharts = {
+            status: "FAIL",
+            violations: parsed.violations || [],
+            summary: parsed.summary || "violaciones detectadas"
+          }
+        }
+      } catch (parseErr) {
+        result.lintCharts = {
+          status: "FAIL",
+          violations: [{ raw: rawOutput.slice(0, 1000) }],
+          summary: "linter ejecuto con codigo no-cero y salida no parseable"
+        }
+      }
+    }
+
     // 2. Run eslint targeting modified files dynamically
     let eslintFiles = "src/"
     try {
@@ -311,16 +369,83 @@ export const shift_left_verify = tool({
       }
     }
 
-    const overallSuccess = result.tsc.status === "SUCCESS" && result.eslint.status === "SUCCESS"
+    const overallSuccess =
+      result.tsc.status === "SUCCESS" &&
+      result.eslint.status === "SUCCESS" &&
+      result.lintCharts.status === "SUCCESS"
 
     return JSON.stringify({
       status: overallSuccess ? "SUCCESS" : "FAIL",
-      message: overallSuccess ? "Shift-Left Verification exitosa: Cero errores de compilación y cero errores de lint." : "Validación fallida: Se encontraron errores estáticos.",
+      message: overallSuccess
+        ? "Shift-Left Verification exitosa: Cero errores de compilación, lint y lint-charts."
+        : "Validación fallida: Se encontraron errores estáticos.",
       verification: result
     }, null, 2)
   }
 })
 
+// Tool: sdd_lint_charts
+//
+// Linter BLOQUEANTE independiente para invocación directa (debugging o
+// pre-commit). Detecta uso incorrecto de `hsl(var(--chart-N))` cuando
+// `--chart-N` esta definido en OKLCH en globals.css (sesion 1176).
+export const lint_charts = tool({
+  description:
+    "Ejecuta el linter BLOQUEANTE de chartConfigs Recharts. Detecta " +
+    "'hsl(var(--chart-N))' y patrones similares que producen CSS invalido " +
+    "cuando --chart-N esta definido en OKLCH. Usar desde F3 antes de " +
+    "transicionar a F4 o como pre-commit hook.",
+  args: {
+    json: tool.schema
+      .boolean()
+      .optional()
+      .default(false)
+      .describe("Si true, devuelve la salida en formato JSON estructurado."),
+    paths: tool.schema
+      .array(tool.schema.string())
+      .optional()
+      .describe("Paths adicionales a escanear (default: src/ y app/).")
+  },
+  async execute(args, context) {
+    const root = getRoot(context)
+    const linterScript = path.resolve(root, ".opencode/scripts/lint-charts.js")
+    if (!fs.existsSync(linterScript)) {
+      return JSON.stringify({
+        status: "ERROR",
+        message: `Linter no encontrado en ${linterScript}. Verifica que .opencode/scripts/lint-charts.js existe.`
+      }, null, 2)
+    }
+
+    const targetDir = getTargetDir(root)
+    const targetPath = targetDir === "." ? root : path.resolve(root, targetDir)
+
+    const extraArgs: string[] = []
+    if (args.json) extraArgs.push("--json")
+    if (args.paths && args.paths.length > 0) extraArgs.push(...args.paths)
+
+    try {
+      const out = execSync(`node "${linterScript}" ${extraArgs.join(" ")}`, {
+        cwd: targetPath,
+        encoding: "utf8",
+        timeout: 30000
+      })
+      return JSON.stringify({
+        status: "PASS",
+        message: out.trim() || "lint-charts PASS",
+        raw_output: out
+      }, null, 2)
+    } catch (e: any) {
+      const out = e.stdout?.toString() || e.stderr?.toString() || ""
+      return JSON.stringify({
+        status: "FAIL",
+        message: "lint-charts detecto violaciones.",
+        raw_output: out,
+        exit_code: e.status
+      }, null, 2)
+    }
+  }
+})
+
 // Tool: sdd_generate_tests
 export const generate_tests = tool({
   description: "Autogenera plantillas de pruebas a partir de los escenarios del contrato activo.",

package/.utils/export_opencode_session.py

@@ -9,7 +9,7 @@ DB_PATH = "/Users/wavesbyte/.local/share/opencode/opencode.db"
 
 # Escribe aquí el ID de la sesión que deseas exportar (ejemplo: "ses_1234...")
 # Si se deja vacío, el script requerirá el ID como argumento al ejecutarlo
-TARGET_SESSION_ID = "ses_1180"
+TARGET_SESSION_ID = "ses_1174"
 
 
 def format_timestamp(ts):

package/opencode.json

@@ -1,10 +1,18 @@
 {
   "$schema": "https://opencode.ai/config.json",
   "agent": {
+    "sdd-orchestrator": {
+      "permission": {
+        "edit": "deny",
+        "write": "deny",
+        "bash": "deny"
+      },
+      "model": "deepseek/deepseek-v4-flash"
+    },
     "sdd-spec-writer": {
       "mode": "subagent",
       "permission": {
-        "webfetch": "deny"
+        "webfetch": "allow"
       },
       "model": "deepseek/deepseek-v4-flash"
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zugzbot",
-  "version": "1.1.6",
+  "version": "1.2.0",
   "description": "Fácil instalador del arnés SDD de Zugzbot para proyectos OpenCode",
   "type": "module",
   "bin": {
@@ -18,6 +18,7 @@
     ".opencode/skills/",
     ".opencode/templates/",
     ".opencode/tools/",
+    ".opencode/scripts/",
     ".opencode/contract-schema.json",
     ".opencode/oh-my-design/design-md/",
     ".opencode/oh-my-design/packages/mcp/dist/",