@slock-ai/daemon 0.29.0 → 0.29.1-alpha.0

package/dist/index.js

@@ -6,30 +6,44 @@ import os2 from "os";
 import { createRequire } from "module";
 import { execSync as execSync2 } from "child_process";
 import { accessSync } from "fs";
+import { readFile as readFile2, readdir as readdir2, stat as stat2, mkdir as mkdir2, appendFile } from "fs/promises";
 import { fileURLToPath } from "url";
 
 // src/connection.ts
 import WebSocket from "ws";
+var systemClock = {
+  now: () => Date.now(),
+  setTimeout: (fn, ms) => setTimeout(fn, ms),
+  clearTimeout: (timer) => clearTimeout(timer)
+};
+var INBOUND_WATCHDOG_MS = 7e4;
 var DaemonConnection = class {
   ws = null;
   options;
+  clock;
   reconnectTimer = null;
-  reconnectDelay = 1e3;
+  watchdogTimer = null;
+  reconnectDelay;
   maxReconnectDelay = 3e4;
   shouldConnect = true;
   reconnectAttempt = 0;
   lastDroppedSendLogAt = 0;
   constructor(options) {
     this.options = options;
+    this.clock = options.clock ?? systemClock;
+    this.reconnectDelay = options.minReconnectDelayMs ?? 1e3;
   }
   connect() {
     this.shouldConnect = true;
+    if (this.reconnectTimer) return;
+    if (this.ws && this.ws.readyState !== WebSocket.CLOSED) return;
     this.doConnect();
   }
   disconnect() {
     this.shouldConnect = false;
+    this.clearWatchdog();
     if (this.reconnectTimer) {
-      clearTimeout(this.reconnectTimer);
+      this.clock.clearTimeout(this.reconnectTimer);
       this.reconnectTimer = null;
     }
     if (this.ws) {
@@ -43,7 +57,7 @@ var DaemonConnection = class {
       this.ws.send(JSON.stringify(msg));
       return;
     }
-    const now = Date.now();
+    const now = this.clock.now();
     if (now - this.lastDroppedSendLogAt > 5e3) {
       this.lastDroppedSendLogAt = now;
       console.warn(`[Daemon] Dropping outbound message while disconnected: ${msg.type}`);
@@ -54,16 +68,23 @@ var DaemonConnection = class {
   }
   doConnect() {
     if (!this.shouldConnect) return;
+    if (this.ws && this.ws.readyState !== WebSocket.CLOSED) return;
     const wsUrl = this.options.serverUrl.replace(/^http/, "ws") + `/daemon/connect?key=${this.options.apiKey}`;
     console.log(`[Daemon] Connecting to ${this.options.serverUrl}...`);
-    this.ws = new WebSocket(wsUrl);
-    this.ws.on("open", () => {
+    const ws = this.options.wsFactory ? this.options.wsFactory(wsUrl) : new WebSocket(wsUrl);
+    this.ws = ws;
+    ws.on("open", () => {
+      if (this.ws !== ws) return;
+      if (!this.shouldConnect) return;
       console.log("[Daemon] Connected to server");
       this.reconnectAttempt = 0;
-      this.reconnectDelay = 1e3;
+      this.reconnectDelay = this.options.minReconnectDelayMs ?? 1e3;
+      this.resetWatchdog();
       this.options.onConnect();
     });
-    this.ws.on("message", (data) => {
+    ws.on("message", (data) => {
+      if (this.ws !== ws) return;
+      this.resetWatchdog();
       try {
         const msg = JSON.parse(data.toString());
         this.options.onMessage(msg);
@@ -71,7 +92,10 @@ var DaemonConnection = class {
         console.error("[Daemon] Invalid message from server:", err);
       }
     });
-    this.ws.on("close", (code, reasonBuffer) => {
+    ws.on("close", (code, reasonBuffer) => {
+      if (this.ws !== ws) return;
+      this.ws = null;
+      this.clearWatchdog();
       const reason = reasonBuffer.toString("utf8");
       console.log(
         `[Daemon] Disconnected from server (code=${code}, reason=${JSON.stringify(reason)}, reconnecting=${this.shouldConnect})`
@@ -79,7 +103,8 @@ var DaemonConnection = class {
       this.options.onDisconnect();
       this.scheduleReconnect();
     });
-    this.ws.on("error", (err) => {
+    ws.on("error", (err) => {
+      if (this.ws !== ws) return;
       console.error("[Daemon] WebSocket error:", err.message);
     });
   }
@@ -88,12 +113,29 @@ var DaemonConnection = class {
     if (this.reconnectTimer) return;
     this.reconnectAttempt += 1;
     console.log(`[Daemon] Reconnecting to server in ${this.reconnectDelay}ms (attempt ${this.reconnectAttempt})`);
-    this.reconnectTimer = setTimeout(() => {
+    this.reconnectTimer = this.clock.setTimeout(() => {
       this.reconnectTimer = null;
       this.doConnect();
     }, this.reconnectDelay);
     this.reconnectDelay = Math.min(this.reconnectDelay * 2, this.maxReconnectDelay);
   }
+  resetWatchdog() {
+    this.clearWatchdog();
+    const ms = this.options.inboundWatchdogMs ?? INBOUND_WATCHDOG_MS;
+    this.watchdogTimer = this.clock.setTimeout(() => {
+      console.warn(`[Daemon] No inbound traffic for ${ms / 1e3}s \u2014 forcing reconnect`);
+      try {
+        this.ws?.terminate();
+      } catch {
+      }
+    }, ms);
+  }
+  clearWatchdog() {
+    if (this.watchdogTimer) {
+      this.clock.clearTimeout(this.watchdogTimer);
+      this.watchdogTimer = null;
+    }
+  }
 };
 
 // src/agentProcessManager.ts
@@ -1288,6 +1330,19 @@ Note: While you are busy, you may receive [System notification: ...] messages ab
   getRunningAgentIds() {
     return [...this.agents.keys()];
   }
+  getDataDir() {
+    return this.dataDir;
+  }
+  getAgentSessionId(agentId) {
+    return this.agents.get(agentId)?.sessionId ?? null;
+  }
+  getIdleAgentSessionIds() {
+    const result = [];
+    for (const [agentId, { sessionId }] of this.idleAgentConfigs) {
+      if (sessionId) result.push({ agentId, sessionId });
+    }
+    return result;
+  }
   // Machine-level workspace scanning
   async scanAllWorkspaces() {
     const results = [];
@@ -1532,6 +1587,11 @@ Note: While you are busy, you may receive [System notification: ...] messages ab
       case "session_init":
         if (ap) ap.sessionId = event.sessionId;
         this.sendToServer({ type: "agent:session", agentId, sessionId: event.sessionId });
+        writeFile(
+          path3.join(this.dataDir, agentId, "session-meta.json"),
+          JSON.stringify({ sessionId: event.sessionId, updatedAt: (/* @__PURE__ */ new Date()).toISOString() })
+        ).catch(() => {
+        });
         break;
       case "thinking": {
         const text = event.text.length > MAX_TRAJECTORY_TEXT ? event.text.slice(0, MAX_TRAJECTORY_TEXT) + "\u2026" : event.text;
@@ -1568,6 +1628,11 @@ Note: While you are busy, you may receive [System notification: ...] messages ab
         }
         if (event.sessionId) {
           this.sendToServer({ type: "agent:session", agentId, sessionId: event.sessionId });
+          writeFile(
+            path3.join(this.dataDir, agentId, "session-meta.json"),
+            JSON.stringify({ sessionId: event.sessionId, updatedAt: (/* @__PURE__ */ new Date()).toISOString() })
+          ).catch(() => {
+          });
         }
         break;
       case "error": {
@@ -1702,6 +1767,47 @@ var RUNTIMES = [
 // src/index.ts
 var require2 = createRequire(import.meta.url);
 var DAEMON_VERSION = require2("../package.json").version;
+var LOG_DIR = path4.join(os2.homedir(), ".slock", "logs");
+var LOG_FILE = path4.join(LOG_DIR, "daemon.log");
+var MAX_LOG_BYTES = 5 * 1024 * 1024;
+async function initLogFile() {
+  try {
+    await mkdir2(LOG_DIR, { recursive: true });
+    try {
+      const s = await stat2(LOG_FILE);
+      if (s.size > MAX_LOG_BYTES) {
+        const content = await readFile2(LOG_FILE, "utf-8");
+        const trimmed = content.slice(Math.floor(content.length / 2));
+        await appendFile(LOG_FILE, "");
+        const { writeFile: writeFile2 } = await import("fs/promises");
+        await writeFile2(LOG_FILE, trimmed);
+      }
+    } catch {
+    }
+  } catch {
+  }
+}
+function logLine(level, ...args2) {
+  const line = `${(/* @__PURE__ */ new Date()).toISOString()} [${level}] ${args2.map(String).join(" ")}
+`;
+  appendFile(LOG_FILE, line).catch(() => {
+  });
+}
+var _origLog = console.log.bind(console);
+var _origErr = console.error.bind(console);
+var _origWarn = console.warn.bind(console);
+console.log = (...args2) => {
+  _origLog(...args2);
+  logLine("INFO", ...args2);
+};
+console.error = (...args2) => {
+  _origErr(...args2);
+  logLine("ERROR", ...args2);
+};
+console.warn = (...args2) => {
+  _origWarn(...args2);
+  logLine("WARN", ...args2);
+};
 function formatChannelTarget(msg) {
   return msg.message.channel_type === "dm" ? `dm:@${msg.message.channel_name}` : `#${msg.message.channel_name}`;
 }
@@ -1723,6 +1829,8 @@ function summarizeIncomingMessage(msg) {
       return `(agent=${msg.agentId}, runtime=${msg.runtime || "auto"})`;
     case "machine:workspace:delete":
       return `(directory=${msg.directoryName})`;
+    case "machine:feedback:collect":
+      return `(reportId=${msg.reportId}, agents=${msg.agents.length})`;
     default:
       return "";
   }
@@ -1758,6 +1866,126 @@ try {
   chatBridgePath = path4.resolve(__dirname, "chat-bridge.ts");
 }
 var connection;
+async function collectAndUploadAgent(opts) {
+  const { agentId, reportAgentId, uploadUrl, authToken, timeRangeHours, includeSessionFiles, includeDaemonLogs, includeWorkspaceSnapshot, dataDir } = opts;
+  const sinceMs = Date.now() - timeRangeHours * 60 * 60 * 1e3;
+  let bytesUploaded = 0;
+  let anyUploadFailed = false;
+  try {
+    const agentDir = path4.join(dataDir, agentId);
+    let sessionId = opts.sessionId;
+    try {
+      const meta = JSON.parse(await readFile2(path4.join(agentDir, "session-meta.json"), "utf-8"));
+      if (meta.sessionId) sessionId = meta.sessionId;
+    } catch {
+    }
+    const filesToUpload = [];
+    if (includeSessionFiles && sessionId) {
+      const claudeProjectsDir = path4.join(os2.homedir(), ".claude", "projects");
+      try {
+        const projectDirs = await readdir2(claudeProjectsDir, { withFileTypes: true });
+        for (const pd of projectDirs) {
+          if (!pd.isDirectory()) continue;
+          const pdPath = path4.join(claudeProjectsDir, pd.name);
+          const files = await readdir2(pdPath, { withFileTypes: true });
+          for (const f of files) {
+            if (!f.isFile() || !f.name.endsWith(".jsonl")) continue;
+            if (!f.name.startsWith(sessionId)) continue;
+            const filePath = path4.join(pdPath, f.name);
+            const raw = await readFile2(filePath, "utf-8");
+            const filteredLines = raw.split("\n").filter((line) => {
+              if (!line.trim()) return false;
+              try {
+                const obj = JSON.parse(line);
+                if (!obj.timestamp) return true;
+                return new Date(obj.timestamp).getTime() >= sinceMs;
+              } catch {
+                return false;
+              }
+            }).join("\n");
+            if (!filteredLines.trim()) continue;
+            filesToUpload.push({ filename: f.name, data: Buffer.from(filteredLines), kind: "session_jsonl" });
+          }
+        }
+      } catch {
+      }
+    }
+    if (includeDaemonLogs) {
+      try {
+        const raw = await readFile2(LOG_FILE, "utf-8");
+        const filtered = raw.split("\n").filter((line) => {
+          if (!line.trim()) return false;
+          const ts = line.slice(0, 24);
+          return new Date(ts).getTime() >= sinceMs;
+        }).join("\n");
+        if (filtered.trim()) {
+          filesToUpload.push({ filename: "daemon.log", data: Buffer.from(filtered), kind: "daemon_log" });
+        }
+      } catch {
+      }
+    }
+    if (includeWorkspaceSnapshot) {
+      try {
+        const agentStat = await stat2(agentDir);
+        if (agentStat.isDirectory()) {
+          const files = await readdir2(agentDir, { withFileTypes: true });
+          for (const f of files) {
+            if (!f.isFile()) continue;
+            if (f.name === "session-meta.json") continue;
+            const filePath = path4.join(agentDir, f.name);
+            const s = await stat2(filePath);
+            if (s.size > 1024 * 1024) continue;
+            const data = await readFile2(filePath);
+            filesToUpload.push({ filename: f.name, data, kind: "runtime_log" });
+          }
+        }
+      } catch {
+      }
+    }
+    const manifest = {
+      reportAgentId,
+      agentId,
+      sessionId,
+      runtime: opts.runtime,
+      daemonVersion: DAEMON_VERSION,
+      hostname: os2.hostname(),
+      os: `${os2.platform()} ${os2.arch()}`,
+      collectedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      timeRangeHours,
+      includeSessionFiles,
+      includeDaemonLogs,
+      includeWorkspaceSnapshot,
+      artifactCount: filesToUpload.length
+    };
+    filesToUpload.unshift({ filename: "manifest.json", data: Buffer.from(JSON.stringify(manifest, null, 2)), kind: "manifest" });
+    for (const file of filesToUpload) {
+      const formData = new FormData();
+      formData.append("reportAgentId", reportAgentId);
+      formData.append("kind", file.kind);
+      formData.append("filename", file.filename);
+      formData.append("file", new Blob([new Uint8Array(file.data)]), file.filename);
+      const resp = await fetch(uploadUrl, {
+        method: "POST",
+        headers: { Authorization: `Bearer ${authToken}` },
+        body: formData
+      });
+      if (resp.ok) {
+        bytesUploaded += file.data.length;
+      } else {
+        console.warn(`[Feedback] Upload failed for ${file.filename}: ${resp.status}`);
+        anyUploadFailed = true;
+      }
+    }
+    if (anyUploadFailed) {
+      return { reportAgentId, status: "error", daemonVersion: DAEMON_VERSION, error: "One or more files failed to upload", bytesUploaded };
+    }
+    return { reportAgentId, status: "collected", daemonVersion: DAEMON_VERSION, bytesUploaded };
+  } catch (err) {
+    const error = err instanceof Error ? err.message : String(err);
+    console.error(`[Feedback] Collection failed for agent ${agentId}:`, error);
+    return { reportAgentId, status: "error", daemonVersion: DAEMON_VERSION, error };
+  }
+}
 var agentManager = new AgentProcessManager(chatBridgePath, (msg) => {
   connection.send(msg);
 }, apiKey);
@@ -1837,6 +2065,37 @@ connection = new DaemonConnection({
       case "ping":
         connection.send({ type: "pong" });
         break;
+      case "machine:feedback:collect": {
+        const { reportId, agents, timeRangeHours, includeSessionFiles, includeDaemonLogs, includeWorkspaceSnapshot, uploadUrl, authToken } = msg;
+        console.log(`[Daemon] Collecting feedback for report ${reportId} (${agents.length} agents)`);
+        const dataDir = agentManager.getDataDir();
+        Promise.all(agents.map(
+          (agent) => collectAndUploadAgent({
+            agentId: agent.agentId,
+            reportAgentId: agent.reportAgentId,
+            runtime: agent.runtime,
+            sessionId: agent.sessionId,
+            uploadUrl,
+            authToken,
+            timeRangeHours,
+            includeSessionFiles,
+            includeDaemonLogs,
+            includeWorkspaceSnapshot: includeWorkspaceSnapshot ?? false,
+            dataDir
+          })
+        )).then((agentResults) => {
+          connection.send({ type: "machine:feedback:result", reportId, agentResults });
+        }).catch((err) => {
+          console.error(`[Daemon] Feedback collection failed for report ${reportId}:`, err);
+          const agentResults = agents.map((a) => ({
+            reportAgentId: a.reportAgentId,
+            status: "error",
+            error: err instanceof Error ? err.message : String(err)
+          }));
+          connection.send({ type: "machine:feedback:result", reportId, agentResults });
+        });
+        break;
+      }
     }
   },
   onConnect: () => {
@@ -1851,11 +2110,22 @@ connection = new DaemonConnection({
       os: `${os2.platform()} ${os2.arch()}`,
       daemonVersion: DAEMON_VERSION
     });
+    for (const agentId of agentManager.getRunningAgentIds()) {
+      const sessionId = agentManager.getAgentSessionId(agentId);
+      if (sessionId) {
+        connection.send({ type: "agent:session", agentId, sessionId });
+      }
+    }
+    for (const { agentId, sessionId } of agentManager.getIdleAgentSessionIds()) {
+      connection.send({ type: "agent:session", agentId, sessionId });
+    }
   },
   onDisconnect: () => {
     console.log("[Daemon] Lost connection \u2014 agents continue running locally");
   }
 });
+initLogFile().catch(() => {
+});
 console.log("[Slock Daemon] Starting...");
 connection.connect();
 var shutdown = async () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@slock-ai/daemon",
-  "version": "0.29.0",
+  "version": "0.29.1-alpha.0",
   "type": "module",
   "bin": {
     "slock-daemon": "dist/index.js"
@@ -32,7 +32,7 @@
     "dev": "tsx watch src/index.ts",
     "start": "tsx src/index.ts",
     "build": "tsup",
-    "test": "node --import tsx --test src/**/*.test.ts",
+    "test": "node --import tsx --test --test-force-exit 'src/**/*.test.ts'",
     "typecheck": "tsc --noEmit",
     "release:patch": "npm version patch --no-git-tag-version && cd ../.. && pnpm install --lockfile-only && git add packages/daemon/package.json pnpm-lock.yaml && git commit -m \"chore: bump @slock-ai/daemon to v$(node -p \"require('./packages/daemon/package.json').version\")\" && git tag daemon-v$(node -p \"require('./packages/daemon/package.json').version\") && git push && git push --tags",
     "release:minor": "npm version minor --no-git-tag-version && cd ../.. && pnpm install --lockfile-only && git add packages/daemon/package.json pnpm-lock.yaml && git commit -m \"chore: bump @slock-ai/daemon to v$(node -p \"require('./packages/daemon/package.json').version\")\" && git tag daemon-v$(node -p \"require('./packages/daemon/package.json').version\") && git push && git push --tags",