@simplr-ai/connect 0.7.2 → 0.7.3

package/dist/index.js

@@ -130,9 +130,11 @@ var SIMPLR_MCP_VERSION = "2.3.0";
 var SIMPLR_MCP_CONFIGURATION_VERSION = `operations@${SIMPLR_MCP_VERSION}`;
 var managedProcesses = /* @__PURE__ */ new Map();
 var hermesRuns = /* @__PURE__ */ new Map();
-var hermesApprovalStreams = /* @__PURE__ */ new Map();
+var hermesRunStreams = /* @__PURE__ */ new Map();
+var hermesRunApprovals = /* @__PURE__ */ new Map();
 var activeCommandIds = /* @__PURE__ */ new Set();
 var commandJournalMutation = Promise.resolve();
+var hermesTraceMutation = Promise.resolve();
 var serviceExecutableSnapshot;
 function stateDirectory() {
   if (platform() === "darwin")
@@ -165,6 +167,9 @@ function encryptedHermesCredentialPath() {
 function commandJournalPath() {
   return join2(stateDirectory(), "commands.json");
 }
+function hermesTracePath() {
+  return join2(stateDirectory(), "hermes-traces.json");
+}
 function serviceLogPath() {
   return join2(stateDirectory(), "connect.log");
 }
@@ -818,6 +823,62 @@ async function removeCommandJournalEntry(commandId) {
   commandJournalMutation = mutation.catch(() => void 0);
   await mutation;
 }
+async function loadHermesTraces() {
+  try {
+    return JSON.parse(await readFile(hermesTracePath(), "utf8"));
+  } catch {
+    return {};
+  }
+}
+async function saveHermesTraces(traces) {
+  await mkdir(stateDirectory(), { recursive: true, mode: 448 });
+  const retained = Object.fromEntries(Object.entries(traces).sort(([, left], [, right]) => Date.parse(right.last_event_at) - Date.parse(left.last_event_at)).slice(0, 25));
+  const temporaryPath = `${hermesTracePath()}.${process.pid}.tmp`;
+  await writeFile(temporaryPath, `${JSON.stringify(retained, null, 2)}
+`, { encoding: "utf8", mode: 384 });
+  if (platform() !== "win32") await chmod(temporaryPath, 384);
+  await rename(temporaryPath, hermesTracePath());
+}
+async function updateHermesTrace(command, state, runId, update, event) {
+  const mutation = hermesTraceMutation.then(async () => {
+    const traces = await loadHermesTraces();
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const existing = traces[command.id];
+    const events = event ? [...existing?.events || [], event].slice(-40) : existing?.events || [];
+    traces[command.id] = {
+      ...existing,
+      ...update,
+      command_id: command.id,
+      organization_id: state.organization_id,
+      workstation_id: state.workstation_id,
+      run_id: runId,
+      status: update.status || existing?.status || "running",
+      current_action: update.current_action || existing?.current_action || "Starting Hermes",
+      next_step: update.next_step || existing?.next_step || "Waiting for the first local activity",
+      last_event_at: event?.created_at || update.last_event_at || existing?.last_event_at || now,
+      supported: update.supported ?? existing?.supported ?? true,
+      events
+    };
+    await saveHermesTraces(traces);
+  });
+  hermesTraceMutation = mutation.catch(() => void 0);
+  await mutation;
+}
+function localTraceText(value, maximumLength = 500) {
+  if (typeof value !== "string") return "";
+  return value.replace(/[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f]/g, " ").replace(/\s+/g, " ").trim().slice(0, maximumLength);
+}
+function hermesTraceEvent(runId, sequence, type, title, detail, timestamp, durationMs) {
+  const seconds = typeof timestamp === "number" && Number.isFinite(timestamp) && timestamp > 0 && timestamp < 864e10 ? timestamp : Date.now() / 1e3;
+  return {
+    id: `${runId}:${sequence}`,
+    type,
+    title: localTraceText(title, 160),
+    ...detail ? { detail: localTraceText(detail) } : {},
+    created_at: new Date(seconds * 1e3).toISOString(),
+    ...durationMs === void 0 ? {} : { duration_ms: durationMs }
+  };
+}
 function credentialService(workstationId) {
   return `simplr-connect:${workstationId}`;
 }
@@ -1188,76 +1249,94 @@ async function hermesRequest(state, path, options = {}) {
     throw new Error(`Hermes request failed (${response.status})`);
   return await response.json();
 }
-async function readHermesApproval(state, runId) {
-  let stream = hermesApprovalStreams.get(runId);
-  if (!stream) {
-    const token = await loadHermesCredential(state);
-    const controller = new AbortController();
-    const startupTimeout = setTimeout(() => controller.abort(), 5e3);
-    const response = await fetch(
-      `http://127.0.0.1:8642/p/${hermesProfile(state.organization_id)}/v1/runs/${encodeURIComponent(runId)}/events`,
-      {
-        headers: {
-          Authorization: `Bearer ${token}`,
-          Accept: "text/event-stream"
-        },
-        signal: controller.signal
-      }
-    );
-    if (!response.ok || !response.body) {
-      clearTimeout(startupTimeout);
-      controller.abort();
-      return {};
-    }
-    stream = {
-      controller,
-      reader: response.body.getReader(),
-      decoder: new TextDecoder(),
-      buffered: "",
-      startup_timeout: startupTimeout
-    };
-    hermesApprovalStreams.set(runId, stream);
+async function streamHermesRunEvents(state, command, runId) {
+  const controller = new AbortController();
+  hermesRunStreams.set(runId, controller);
+  const token = await loadHermesCredential(state);
+  const response = await fetch(
+    `http://127.0.0.1:8642/p/${hermesProfile(state.organization_id)}/v1/runs/${encodeURIComponent(runId)}/events`,
+    { headers: { Authorization: `Bearer ${token}`, Accept: "text/event-stream" }, signal: controller.signal }
+  );
+  if (!response.ok || !response.body) {
+    await updateHermesTrace(command, state, runId, { supported: false, current_action: "Hermes is running", next_step: "Live detail is unavailable; local status polling remains active" });
+    return;
   }
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder();
+  let buffered = "";
+  let sequence = 0;
   try {
     while (true) {
-      const boundary = stream.buffered.indexOf("\n\n");
-      if (boundary < 0) {
-        const chunk = await stream.reader.read();
-        if (chunk.done) return {};
-        stream.buffered += stream.decoder.decode(chunk.value, { stream: true });
-        continue;
+      const chunk = await reader.read();
+      if (chunk.done) break;
+      buffered += decoder.decode(chunk.value, { stream: true }).replace(/\r\n/g, "\n");
+      let boundary = buffered.indexOf("\n\n");
+      while (boundary >= 0) {
+        const record = buffered.slice(0, boundary);
+        buffered = buffered.slice(boundary + 2);
+        boundary = buffered.indexOf("\n\n");
+        const data = record.split("\n").filter((line) => line.startsWith("data:")).map((line) => line.slice(5).trim()).join("\n");
+        if (!data) continue;
+        let raw;
+        try {
+          const parsed = JSON.parse(data);
+          if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) continue;
+          raw = parsed;
+        } catch {
+          continue;
+        }
+        const eventType = localTraceText(raw.event, 80);
+        const rawTool = localTraceText(raw.tool, 100);
+        const tool = /^[a-zA-Z0-9_.:-]{1,100}$/.test(rawTool) ? rawTool : "Hermes tool";
+        sequence += 1;
+        if (eventType === "reasoning.available") {
+          const detail = localTraceText(raw.text);
+          if (!detail) continue;
+          await updateHermesTrace(command, state, runId, { current_action: "Reviewing the plan", next_step: detail, blocker: void 0 }, hermesTraceEvent(runId, sequence, "reasoning", "Reasoning summary", detail, raw.timestamp));
+        } else if (eventType === "tool.started") {
+          const preview = localTraceText(raw.preview);
+          await updateHermesTrace(command, state, runId, { current_action: `Running ${tool}`, next_step: `Waiting for ${tool} to finish`, blocker: void 0 }, hermesTraceEvent(runId, sequence, "tool", `Started ${tool}`, preview || void 0, raw.timestamp));
+        } else if (eventType === "tool.completed") {
+          const duration = typeof raw.duration === "number" && Number.isFinite(raw.duration) ? Math.max(0, Math.round(raw.duration * 1e3)) : void 0;
+          const failed = raw.error === true;
+          await updateHermesTrace(command, state, runId, { current_action: failed ? `${tool} reported an error` : `Finished ${tool}`, next_step: "Hermes is deciding the next action", ...failed ? { blocker: `${tool} reported an error` } : { blocker: void 0 } }, hermesTraceEvent(runId, sequence, failed ? "error" : "tool", failed ? `${tool} failed` : `Finished ${tool}`, void 0, raw.timestamp, duration));
+        } else if (eventType === "approval.request") {
+          const approvalCommand = localTraceText(raw.command, 1e3);
+          if (approvalCommand) {
+            hermesRunApprovals.set(runId, {
+              approval_command: approvalCommand,
+              approval_tool: tool,
+              approval_fingerprint: createHash("sha256").update(JSON.stringify({ run_id: runId, tool, command: approvalCommand })).digest("hex"),
+              approval_policy_decision: "approval_required"
+            });
+          }
+          await updateHermesTrace(command, state, runId, { status: "waiting_approval", current_action: "Waiting for your approval", next_step: `Approve or reject ${tool}`, blocker: "Human approval is required" }, hermesTraceEvent(runId, sequence, "approval", "Approval required", approvalCommand || tool, raw.timestamp));
+        } else if (["run.completed", "run.failed", "run.cancelled"].includes(eventType)) {
+          const failed = eventType === "run.failed";
+          const cancelled = eventType === "run.cancelled";
+          const status = failed ? "failed" : cancelled ? "cancelled" : "completed";
+          const title = failed ? "Hermes run failed" : cancelled ? "Hermes run stopped" : "Hermes run completed";
+          await updateHermesTrace(command, state, runId, { status, current_action: title, next_step: failed ? "Review the failure and decide whether to retry" : cancelled ? "Continue in Chat or start a new run" : "Review the result and pull request", ...failed ? { blocker: localTraceText(raw.error, 300) || "Hermes reported a failure" } : { blocker: void 0 } }, hermesTraceEvent(runId, sequence, failed ? "error" : "success", title, failed ? localTraceText(raw.error, 300) : void 0, raw.timestamp));
+        }
       }
-      const record = stream.buffered.slice(0, boundary);
-      stream.buffered = stream.buffered.slice(boundary + 2);
-      const data = record.split("\n").filter((line) => line.startsWith("data:")).map((line) => line.slice(5).trim()).join("\n");
-      if (!data) continue;
-      const event = JSON.parse(data);
-      if (event.event !== "approval.request") continue;
-      clearTimeout(stream.startup_timeout);
-      const tool = typeof event.tool === "string" && /^[a-zA-Z0-9_.:-]{1,100}$/.test(event.tool) ? event.tool : "protected tool";
-      const command = typeof event.command === "string" ? event.command.trim().slice(0, 1e3) : "";
-      if (!command) return {};
-      const fingerprint = createHash("sha256").update(JSON.stringify({ run_id: runId, tool, command })).digest("hex");
-      return {
-        approval_command: command,
-        approval_tool: tool,
-        approval_fingerprint: fingerprint,
-        approval_policy_decision: "approval_required"
-      };
     }
-  } catch {
-    clearTimeout(stream.startup_timeout);
-    hermesApprovalStreams.delete(runId);
-    return {};
+  } finally {
+    await reader.cancel().catch(() => void 0);
+    if (hermesRunStreams.get(runId) === controller) hermesRunStreams.delete(runId);
   }
 }
-function closeHermesApprovalStream(runId) {
-  const stream = hermesApprovalStreams.get(runId);
-  if (!stream) return;
-  clearTimeout(stream.startup_timeout);
-  stream.controller.abort();
-  void stream.reader.cancel().catch(() => void 0);
-  hermesApprovalStreams.delete(runId);
+async function readHermesApproval(runId) {
+  for (let attempt = 0; attempt < 20; attempt += 1) {
+    const approval = hermesRunApprovals.get(runId);
+    if (approval) return approval;
+    await new Promise((resolve) => setTimeout(resolve, 250));
+  }
+  return {};
+}
+function closeHermesRunStream(runId) {
+  hermesRunStreams.get(runId)?.abort();
+  hermesRunStreams.delete(runId);
+  hermesRunApprovals.delete(runId);
 }
 async function waitForProcess(child) {
   return new Promise((resolve, reject) => {
@@ -2038,6 +2117,22 @@ async function monitorHermesRun(state, command, runId, startedAt) {
     started_at: startedAt
   };
   hermesRuns.set(runId, run);
+  await updateHermesTrace(command, state, runId, {
+    status: "running",
+    current_action: "Starting Hermes",
+    next_step: "Waiting for the first local activity",
+    blocker: void 0,
+    supported: true
+  }, hermesTraceEvent(runId, 0, "status", "Hermes run started", void 0, Date.now() / 1e3));
+  const traceStream = streamHermesRunEvents(state, command, runId).catch(async () => {
+    if (hermesRunStreams.has(runId)) {
+      await updateHermesTrace(command, state, runId, {
+        supported: false,
+        current_action: "Hermes is running",
+        next_step: "Live detail is unavailable; local status polling remains active"
+      });
+    }
+  });
   let lastReportedStatus;
   let consecutivePollFailures = 0;
   try {
@@ -2061,6 +2156,13 @@ async function monitorHermesRun(state, command, runId, startedAt) {
       }
       if (status.status === "completed") {
         const output = status.output || "Hermes completed the task";
+        await updateHermesTrace(command, state, runId, {
+          status: "completed",
+          current_action: "Hermes run completed",
+          next_step: "Review the result and pull request",
+          blocker: void 0,
+          last_event_at: (/* @__PURE__ */ new Date()).toISOString()
+        });
         await updateCommandJournal({
           command_id: command.id,
           type: command.type,
@@ -2089,7 +2191,7 @@ async function monitorHermesRun(state, command, runId, startedAt) {
           started_at: startedAt,
           updated_at: (/* @__PURE__ */ new Date()).toISOString()
         });
-        const approval = run.status === "waiting_approval" ? await readHermesApproval(state, runId).catch(() => ({})) : {};
+        const approval = run.status === "waiting_approval" ? await readHermesApproval(runId).catch(() => ({})) : {};
         if (run.status === "waiting_approval" && approval.approval_fingerprint) {
           await updateCommandJournal({
             command_id: command.id,
@@ -2132,8 +2234,19 @@ async function monitorHermesRun(state, command, runId, startedAt) {
     throw new Error(
       "Hermes run exceeded the 30 minute monitoring window and was stopped"
     );
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Hermes run failed";
+    const cancelled = /cancelled|stopped/i.test(message);
+    await updateHermesTrace(command, state, runId, {
+      status: cancelled ? "cancelled" : "failed",
+      current_action: cancelled ? "Hermes run stopped" : "Hermes run failed",
+      next_step: cancelled ? "Continue in Chat or start a new run" : "Review the failure and decide whether to retry",
+      ...cancelled ? { blocker: void 0 } : { blocker: localTraceText(message, 300) }
+    }, hermesTraceEvent(runId, Date.now(), cancelled ? "status" : "error", cancelled ? "Hermes run stopped" : "Hermes run failed", cancelled ? void 0 : message, Date.now() / 1e3));
+    throw error;
   } finally {
-    closeHermesApprovalStream(runId);
+    closeHermesRunStream(runId);
+    await traceStream;
     hermesRuns.delete(runId);
   }
 }
@@ -2517,7 +2630,7 @@ function dispatchCommand(state, command, inventoryAlreadySynced) {
     );
     if (run) {
       void (async () => {
-        const approval = run.status === "waiting_approval" ? await readHermesApproval(state, run.id).catch(() => ({})) : {};
+        const approval = run.status === "waiting_approval" ? await readHermesApproval(run.id).catch(() => ({})) : {};
         await reportCommandProgress(
           state,
           command.id,
@@ -3361,6 +3474,19 @@ async function main() {
       token
     );
     process.stdout.write(`${JSON.stringify(overview)}
+`);
+    return;
+  }
+  if (command === "work-order-traces") {
+    const organizationId = argument("--organization-id");
+    if (!isUuid(organizationId))
+      throw new Error("Use: simplr-connect work-order-traces --organization-id <uuid>");
+    const state = await loadState();
+    const connection = state.connections.find((item) => item.organization_id === organizationId);
+    if (!connection) throw new Error("Organization is not connected");
+    await hermesTraceMutation;
+    const traces = Object.values(await loadHermesTraces()).filter((trace) => trace.organization_id === connection.organization_id && trace.workstation_id === connection.workstation_id).sort((left, right) => Date.parse(right.last_event_at) - Date.parse(left.last_event_at));
+    process.stdout.write(`${JSON.stringify({ traces, updated_at: (/* @__PURE__ */ new Date()).toISOString() })}
 `);
     return;
   }
@@ -3466,7 +3592,7 @@ async function main() {
     return;
   }
   process.stdout.write(
-    "Simplr Connect\n\nCommands:\n  wizard\n  enroll --api-url <url> --code <code> [--setup-hermes] [--install-service]\n  hermes-setup\n  status\n  service-install\n  repair\n  update-check\n  update\n  sync\n  watch\n  run -- <ai-command> [arguments]\n"
+    "Simplr Connect\n\nCommands:\n  wizard\n  enroll --api-url <url> --code <code> [--setup-hermes] [--install-service]\n  hermes-setup\n  status\n  overview --organization-id <uuid>\n  work-order-traces --organization-id <uuid>\n  service-install\n  repair\n  update-check\n  update\n  sync\n  watch\n  run -- <ai-command> [arguments]\n"
   );
 }
 main().catch(async (error) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@simplr-ai/connect",
-  "version": "0.7.2",
+  "version": "0.7.3",
   "description": "Simplr Connect workstation enrollment and AI tool inventory companion",
   "type": "module",
   "main": "dist/index.js",