npm - @tekyzinc/gsd-t - Versions diffs - 3.15.10 → 3.16.11 - Mend

@tekyzinc/gsd-t 3.15.10 → 3.16.11

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (17) hide show

package/bin/gsd-t-orchestrator-worker.cjs +35 -3
package/bin/gsd-t-token-capture.cjs +24 -3
package/bin/gsd-t-token-regenerate-log.cjs +129 -0
package/bin/gsd-t-transcript-tee.cjs +246 -0
package/bin/gsd-t-unattended-heartbeat.cjs +188 -0
package/bin/gsd-t-unattended-platform.cjs +191 -27
package/bin/gsd-t-unattended-safety.cjs +8 -1
package/bin/gsd-t-unattended.cjs +192 -31
package/bin/gsd-t.js +15 -1
package/bin/supervisor-pid-fingerprint.cjs +126 -0
package/commands/gsd-t-resume.md +18 -4
package/docs/architecture.md +16 -0
package/package.json +1 -1
package/scripts/gsd-t-dashboard-server.js +291 -4
package/scripts/gsd-t-dashboard.html +31 -1
package/scripts/gsd-t-transcript.html +422 -0
package/scripts/hooks/gsd-t-in-session-probe.js +62 -0

package/scripts/gsd-t-dashboard-server.js CHANGED Viewed

@@ -8,8 +8,38 @@ const fs = require("fs");
 const path = require("path");
 const { spawn } = require("child_process");
+// Base port — the effective default is project-hashed (see
+// projectScopedDefaultPort). Explicit --port N always overrides.
 const DEFAULT_PORT = 7433;
 const MAX_EVENTS = 500;
+/**
+ * Deterministic project-scoped default port so two projects running
+ * `gsd-t visualize` simultaneously don't collide on 7433. Hashes the
+ * resolved project directory (djb2) and maps into [7433, 7532].
+ *
+ * @param {string} projectDir — any path-like string; resolved internally.
+ * @returns {number} port in [DEFAULT_PORT, DEFAULT_PORT + 99].
+ */
+function projectScopedDefaultPort(projectDir) {
+  const resolved = path.resolve(projectDir || ".");
+  let hash = 5381;
+  for (let i = 0; i < resolved.length; i++) {
+    hash = ((hash * 33) ^ resolved.charCodeAt(i)) >>> 0;
+  }
+  return DEFAULT_PORT + (hash % 100);
+}
+/**
+ * Pure helper so callers (and tests) can resolve the effective port from a
+ * parsed --port argument + projectDir. Explicit argPort always wins.
+ */
+function resolvePort({ argPort, projectDir }) {
+  if (argPort != null && argPort !== "" && !Number.isNaN(parseInt(argPort, 10))) {
+    return parseInt(argPort, 10);
+  }
+  return projectScopedDefaultPort(projectDir);
+}
 const KEEPALIVE_MS = 15000;
 const SSE_HEADERS = { "Content-Type": "text/event-stream", "Cache-Control": "no-cache", "Connection": "keep-alive", "Access-Control-Allow-Origin": "*" };
@@ -124,8 +154,235 @@ function handleMetrics(req, res, projectDir) {
   res.end(JSON.stringify(data));
 }
-function startServer(port, eventsDir, htmlPath, projectDir) {
+// ── M42 D2 — per-spawn transcript routes ──────────────────────────────────────
+const TRANSCRIPTS_SUBDIR = path.join(".gsd-t", "transcripts");
+function transcriptsDir(projectDir) {
+  return path.join(projectDir, TRANSCRIPTS_SUBDIR);
+}
+function readTranscriptsIndex(projectDir) {
+  const p = path.join(transcriptsDir(projectDir), ".index.json");
+  try {
+    const raw = fs.readFileSync(p, "utf8");
+    const parsed = JSON.parse(raw);
+    if (parsed && Array.isArray(parsed.spawns)) return parsed;
+  } catch { /* no index yet */ }
+  return { spawns: [] };
+}
+function isValidSpawnId(id) {
+  return typeof id === "string" && /^[a-zA-Z0-9._-]+$/.test(id) && id.length <= 200;
+}
+function handleTranscriptsList(req, res, projectDir) {
+  const idx = readTranscriptsIndex(projectDir);
+  const sorted = idx.spawns
+    .slice()
+    .sort((a, b) => (Date.parse(b.startedAt) || 0) - (Date.parse(a.startedAt) || 0));
+  res.writeHead(200, { "Content-Type": "application/json" });
+  res.end(JSON.stringify({ spawns: sorted }));
+}
+function handleTranscriptPage(req, res, spawnId, transcriptHtmlPath) {
+  if (!isValidSpawnId(spawnId)) { res.writeHead(400); res.end("Invalid spawn id"); return; }
+  fs.readFile(transcriptHtmlPath, (err, data) => {
+    if (err) { res.writeHead(404); res.end("Transcript UI not found"); return; }
+    // Inject the spawn-id as a data attribute on <body> by string replacement;
+    // the HTML ships with a placeholder `data-spawn-id="__SPAWN_ID__"`.
+    const html = data.toString("utf8").replace(/__SPAWN_ID__/g, spawnId);
+    res.writeHead(200, { "Content-Type": "text/html" });
+    res.end(html);
+  });
+}
+function tailTranscriptFile(filePath, callback) {
+  let offset = 0;
+  let buf = "";
+  function processNewData() {
+    let stat;
+    try { stat = fs.statSync(filePath); } catch { return; }
+    if (stat.size <= offset) return;
+    const fd = fs.openSync(filePath, "r");
+    try {
+      const b = Buffer.alloc(stat.size - offset);
+      fs.readSync(fd, b, 0, b.length, offset);
+      buf += b.toString("utf8");
+      offset = stat.size;
+    } finally { fs.closeSync(fd); }
+    let nl;
+    while ((nl = buf.indexOf("\n")) >= 0) {
+      const line = buf.slice(0, nl);
+      buf = buf.slice(nl + 1);
+      if (line.length > 0) callback(line);
+    }
+  }
+  fs.watchFile(filePath, { interval: 500, persistent: true }, processNewData);
+  return () => fs.unwatchFile(filePath, processNewData);
+}
+// ── M42 D3 — kill per-spawn ────────────────────────────────────────────────
+function writeTranscriptsIndex(projectDir, idx) {
+  const p = path.join(transcriptsDir(projectDir), ".index.json");
+  const tmp = p + ".tmp";
+  try { fs.mkdirSync(path.dirname(p), { recursive: true }); } catch { /* exists */ }
+  fs.writeFileSync(tmp, JSON.stringify(idx, null, 2));
+  fs.renameSync(tmp, p);
+}
+function handleTranscriptKill(req, res, spawnId, projectDir) {
+  if (!isValidSpawnId(spawnId)) { res.writeHead(400); res.end("Invalid spawn id"); return; }
+  const idx = readTranscriptsIndex(projectDir);
+  const i = idx.spawns.findIndex((s) => s.spawnId === spawnId);
+  if (i < 0) { res.writeHead(404, { "Content-Type": "application/json" }); res.end(JSON.stringify({ error: "unknown_spawn" })); return; }
+  const entry = idx.spawns[i];
+  const pid = entry.workerPid;
+  if (!pid || typeof pid !== "number") {
+    res.writeHead(409, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ error: "no_pid_recorded" }));
+    return;
+  }
+  try {
+    process.kill(pid, "SIGTERM");
+    idx.spawns[i].status = "stopped";
+    idx.spawns[i].endedAt = idx.spawns[i].endedAt || new Date().toISOString();
+    writeTranscriptsIndex(projectDir, idx);
+    res.writeHead(200, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ status: "stopped", pid }));
+  } catch (err) {
+    if (err.code === "ESRCH") {
+      // Process already gone — treat as success and mark ended
+      idx.spawns[i].status = idx.spawns[i].status === "running" ? "stopped" : idx.spawns[i].status;
+      idx.spawns[i].endedAt = idx.spawns[i].endedAt || new Date().toISOString();
+      writeTranscriptsIndex(projectDir, idx);
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ status: "already_stopped", pid }));
+      return;
+    }
+    if (err.code === "EPERM") {
+      res.writeHead(403, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: "permission_denied", pid }));
+      return;
+    }
+    res.writeHead(500, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ error: String(err.message || err) }));
+  }
+}
+/**
+ * Find the transcripts-index entry for a spawn-id, or null when the index
+ * is missing / the id isn't recorded. Used by handleTranscriptStream to
+ * detect already-finished spawns so the SSE stream can emit `event: end`
+ * and close instead of tailing indefinitely.
+ */
+function readIndexEntry(projectDir, spawnId) {
+  const idx = readTranscriptsIndex(projectDir);
+  if (!idx || !Array.isArray(idx.spawns)) return null;
+  return idx.spawns.find((s) => s && s.spawnId === spawnId) || null;
+}
+function handleTranscriptStream(req, res, spawnId, projectDir) {
+  if (!isValidSpawnId(spawnId)) { res.writeHead(400); res.end("Invalid spawn id"); return; }
+  const filePath = path.join(transcriptsDir(projectDir), `${spawnId}.ndjson`);
+  let exists = true;
+  let fileSize = 0;
+  try { fileSize = fs.statSync(filePath).size; } catch { exists = false; }
+  res.writeHead(200, SSE_HEADERS);
+  // Consult the transcripts index — if the spawn is already finished we
+  // replay and close instead of attaching a live tail.
+  const entry = readIndexEntry(projectDir, spawnId);
+  const finishedStatuses = ["done", "failed", "stopped"];
+  const isFinished = !!(entry && entry.status && finishedStatuses.includes(entry.status));
+  // Replay: read the full file from byte 0 and send each line.
+  let replayedBytes = 0;
+  if (exists) {
+    try {
+      const full = fs.readFileSync(filePath, "utf8");
+      replayedBytes = Buffer.byteLength(full, "utf8");
+      full.split("\n").forEach((line) => {
+        if (line.length > 0) {
+          try { res.write("data: " + line + "\n\n"); } catch { /* gone */ }
+        }
+      });
+    } catch { /* empty transcript */ }
+  }
+  // Finished spawn → emit end event and close the stream. No tail, no keepalive.
+  if (isFinished) {
+    const endPayload = JSON.stringify({
+      status: entry.status,
+      endedAt: entry.endedAt || null,
+    });
+    try { res.write("event: end\ndata: " + endPayload + "\n\n"); } catch { /* gone */ }
+    try { res.end(); } catch { /* gone */ }
+    return;
+  }
+  // Missing file — tell the viewer the stream is live but empty. fs.watchFile
+  // needs the file to exist, so we skip the tail here. A running producer
+  // will have created the file already (the finished-spawn branch above
+  // catches the post-hoc teed case via index status).
+  if (!exists) {
+    const waitingPayload = JSON.stringify({
+      status: "waiting",
+      reason: "no transcript file yet",
+    });
+    try { res.write("event: status\ndata: " + waitingPayload + "\n\n"); } catch { /* gone */ }
+    const timer = setInterval(() => { try { res.write(": keepalive\n\n"); } catch { clearInterval(timer); } }, KEEPALIVE_MS);
+    req.on("close", () => { clearInterval(timer); });
+    return;
+  }
+  // Empty file — producer hasn't written anything yet. Emit a status frame
+  // so the viewer knows the stream is live but the file is 0 bytes, then
+  // attach the live tail so we pick up writes as they arrive.
+  if (fileSize === 0) {
+    const emptyPayload = JSON.stringify({
+      status: "empty",
+      reason: "transcript file exists but is empty",
+    });
+    try { res.write("event: status\ndata: " + emptyPayload + "\n\n"); } catch { /* gone */ }
+  }
+  // Tail: from replayedBytes onward. We reuse the tailer, but seed offset
+  // with what we already replayed so we don't double-send.
+  let offset = replayedBytes;
+  let buf = "";
+  const processNewData = () => {
+    let stat;
+    try { stat = fs.statSync(filePath); } catch { return; }
+    if (stat.size <= offset) return;
+    const fd = fs.openSync(filePath, "r");
+    try {
+      const b = Buffer.alloc(stat.size - offset);
+      fs.readSync(fd, b, 0, b.length, offset);
+      buf += b.toString("utf8");
+      offset = stat.size;
+    } finally { fs.closeSync(fd); }
+    let nl;
+    while ((nl = buf.indexOf("\n")) >= 0) {
+      const line = buf.slice(0, nl);
+      buf = buf.slice(nl + 1);
+      if (line.length > 0) {
+        try { res.write("data: " + line + "\n\n"); } catch { /* gone */ }
+      }
+    }
+  };
+  fs.watchFile(filePath, { interval: 500, persistent: true }, processNewData);
+  const unwatchFile = () => fs.unwatchFile(filePath, processNewData);
+  const timer = setInterval(() => { try { res.write(": keepalive\n\n"); } catch { clearInterval(timer); } }, KEEPALIVE_MS);
+  req.on("close", () => { clearInterval(timer); if (unwatchFile) unwatchFile(); });
+}
+function startServer(port, eventsDir, htmlPath, projectDir, transcriptHtmlPath) {
   const projDir = projectDir || path.resolve(eventsDir, "..", "..");
+  const tHtmlPath = transcriptHtmlPath || path.join(path.dirname(htmlPath), "gsd-t-transcript.html");
   const server = http.createServer((req, res) => {
     const url = req.url.split("?")[0];
     if (url === "/" || url === "") return handleRoot(req, res, htmlPath);
@@ -133,23 +390,53 @@ function startServer(port, eventsDir, htmlPath, projectDir) {
     if (url === "/metrics") return handleMetrics(req, res, projDir);
     if (url === "/ping") return handlePing(req, res, port);
     if (url === "/stop") return handleStop(req, res, server);
+    if (url === "/transcripts") return handleTranscriptsList(req, res, projDir);
+    // POST /transcript/:spawnId/kill — SIGTERM the recorded workerPid
+    const killMatch = url.match(/^\/transcript\/([^/]+)\/kill$/);
+    if (killMatch && req.method === "POST") return handleTranscriptKill(req, res, decodeURIComponent(killMatch[1]), projDir);
+    // /transcript/:spawnId/stream — SSE tail of per-spawn ndjson
+    const streamMatch = url.match(/^\/transcript\/([^/]+)\/stream$/);
+    if (streamMatch) return handleTranscriptStream(req, res, decodeURIComponent(streamMatch[1]), projDir);
+    // /transcript/:spawnId — HTML viewer page
+    const pageMatch = url.match(/^\/transcript\/([^/]+)$/);
+    if (pageMatch) return handleTranscriptPage(req, res, decodeURIComponent(pageMatch[1]), tHtmlPath);
     res.writeHead(404); res.end("Not found");
   });
   server.listen(port);
   return { server, url: `http://localhost:${port}` };
 }
-module.exports = { startServer, tailEventsFile, readExistingEvents, parseEventLine, findEventsDir, readMetricsData };
+module.exports = {
+  startServer,
+  tailEventsFile,
+  readExistingEvents,
+  parseEventLine,
+  findEventsDir,
+  readMetricsData,
+  readTranscriptsIndex,
+  writeTranscriptsIndex,
+  readIndexEntry,
+  isValidSpawnId,
+  handleTranscriptsList,
+  handleTranscriptStream,
+  handleTranscriptPage,
+  handleTranscriptKill,
+  transcriptsDir,
+  DEFAULT_PORT,
+  projectScopedDefaultPort,
+  resolvePort,
+};
 if (require.main === module) {
   const argv = process.argv.slice(2);
   const getArg = (flag) => { const i = argv.indexOf(flag); return i >= 0 ? argv[i + 1] : null; };
   const hasFlag = (f) => argv.includes(f);
-  const port = parseInt(getArg("--port") || DEFAULT_PORT, 10);
   const projectDir = process.env.GSD_T_PROJECT_DIR || process.cwd();
+  const port = resolvePort({ argPort: getArg("--port"), projectDir });
   const eventsDir = getArg("--events") || findEventsDir(projectDir);
   const pidFile = path.join(projectDir, ".gsd-t", "dashboard.pid");
   const htmlPath = path.join(__dirname, "gsd-t-dashboard.html");
+  const transcriptHtmlPath = path.join(__dirname, "gsd-t-transcript.html");
   if (hasFlag("--stop")) {
     try { const pid = parseInt(fs.readFileSync(pidFile, "utf8").trim(), 10); process.kill(pid); fs.unlinkSync(pidFile); }
@@ -163,7 +450,7 @@ if (require.main === module) {
     fs.writeFileSync(pidFile, String(child.pid));
     process.exit(0);
   }
-  const { server, url } = startServer(port, eventsDir, htmlPath);
+  const { server, url } = startServer(port, eventsDir, htmlPath, projectDir, transcriptHtmlPath);
   process.stdout.write("GSD-T Dashboard: " + url + "\n");
   function cleanup() { try { fs.unlinkSync(pidFile); } catch { /* ok */ } server.close(() => process.exit(0)); }
   process.on("SIGTERM", cleanup);

package/scripts/gsd-t-dashboard.html CHANGED Viewed

@@ -26,6 +26,11 @@ body{background:var(--bg);color:var(--text);font-family:var(--font);font-size:12
 .status.wait{background:var(--yellow-bg);border-color:var(--yellow);color:var(--yellow);}
 .dot{width:6px;height:6px;border-radius:50%;background:currentColor;animation:pdot 1.5s ease-in-out infinite;}
 @keyframes pdot{0%,100%{opacity:1}50%{opacity:.3}}
+.livestream-btn{display:inline-flex;align-items:center;gap:5px;padding:3px 10px;border-radius:4px;
+  background:var(--blue-bg);border:1px solid var(--blue);color:var(--blue);text-decoration:none;
+  font-size:10px;font-weight:500;font-family:var(--font);cursor:pointer;transition:opacity .15s;}
+.livestream-btn:hover{opacity:.85;}
+.livestream-btn.disabled{background:transparent;border-color:var(--border);color:var(--muted);cursor:not-allowed;pointer-events:none;}
 .hright{margin-left:auto;color:var(--muted);font-size:11px;}.main{display:flex;flex:1;overflow:hidden;}
 .garea{flex:1;position:relative;background:var(--bg);}.rfwrap{width:100%;height:100%;}
 .react-flow__background{background:var(--bg);}.react-flow__node{font-family:var(--font);font-size:11px;}
@@ -66,6 +71,7 @@ body{background:var(--bg);color:var(--text);font-family:var(--font);font-size:12
 <div class="hdr">
   <span class="logo">GSD-T Agent Dashboard</span>
   <div id="status" class="status wait"><span class="dot"></span><span id="status-txt">Connecting...</span></div>
+  <a id="livestream-btn" class="livestream-btn disabled" href="#" title="Open the latest live spawn transcript">▶ Live Stream</a>
   <div class="hright"><span id="ev-count">0 events</span></div>
 </div>
 <div class="main">
@@ -91,7 +97,7 @@ const {useState,useEffect,useCallback,useRef}=React;
 const {ReactFlow,useNodesState,useEdgesState,Background,Controls,MarkerType}=window.ReactFlow||{};
 const dagre=window.dagre;
 const params=new URLSearchParams(location.search);
-const PORT=params.get('port')||'7433';
+const PORT=params.get('port')||location.port||'7433';
 const MAX_EVENTS=200;
 const GRAPH_W=160,GRAPH_H=60;
@@ -257,6 +263,30 @@ ReactDOM.render(React.createElement(Dashboard),document.getElementById('rf-root'
   }
   fetchMetrics();setInterval(fetchMetrics,30000);
 })();
+(function(){
+  const btn=document.getElementById('livestream-btn');
+  if(!btn)return;
+  function pickLatest(spawns){
+    if(!Array.isArray(spawns)||spawns.length===0)return null;
+    const live=spawns.filter(s=>s.status&&!['done','stopped','failed','crashed'].includes(s.status));
+    const pool=live.length?live:spawns;
+    return pool.slice().sort((a,b)=>(Date.parse(b.startedAt)||0)-(Date.parse(a.startedAt)||0))[0];
+  }
+  function refresh(){
+    fetch(`http://localhost:${PORT}/transcripts`,{cache:'no-store'}).then(r=>r.ok?r.json():null).then(d=>{
+      const latest=d&&pickLatest(d.spawns);
+      if(latest){
+        btn.href=`/transcript/${encodeURIComponent(latest.spawnId)}`;
+        btn.classList.remove('disabled');
+        const live=latest.status&&!['done','stopped','failed','crashed'].includes(latest.status);
+        btn.textContent=(live?'▶ Live Stream':'▶ Latest Transcript')+` · ${latest.spawnId.slice(0,10)}`;
+      }else{
+        btn.href='#';btn.classList.add('disabled');btn.textContent='▶ Live Stream (no spawns yet)';
+      }
+    }).catch(()=>{});
+  }
+  refresh();setInterval(refresh,10000);
+})();
 </script>
 </body>
 </html>