@saadnvd1/agent-os 0.3.507 → 0.3.509

package/lib/chat/events.ts

@@ -1,4 +1,4 @@
-import type { CallUsage } from "../usage/calls";
+import type { CallUsage } from "../usage/types";
 import type { SearchResult } from "./find";
 
 /**

package/lib/connect/heartbeat.ts

@@ -0,0 +1,88 @@
+/**
+ * Tells the Connect service this machine is alive: one signed beat when
+ * Connect starts, then one a minute. The answer can switch the machine off
+ * (the account disabled it) or say it is gone (removed from the account).
+ * Nothing here may throw: a rejection would take AgentOS down.
+ */
+
+import fs from "fs";
+import path from "path";
+import { ApiError, clean } from "./control-api";
+
+export const HEARTBEAT_MS = 60_000;
+
+export interface HeartbeatOptions {
+  beat: () => Promise<{ enabled: boolean }>;
+  /** The account disabled this machine: stop the tunnel. */
+  onDisabled: () => void;
+  /** The service no longer knows this machine. */
+  onGone: () => void;
+  log?: (line: string) => void;
+  intervalMs?: number;
+}
+
+export function startHeartbeat(opts: HeartbeatOptions) {
+  const log = opts.log ?? (() => {});
+  const every = opts.intervalMs ?? HEARTBEAT_MS;
+  let stopped = false;
+  let failing = false;
+  let timer: NodeJS.Timeout | null = null;
+
+  const stop = () => {
+    stopped = true;
+    if (timer) clearTimeout(timer);
+    timer = null;
+  };
+
+  const next = () => {
+    if (stopped) return;
+    timer = setTimeout(tick, every);
+    timer.unref?.();
+  };
+
+  const tick = async () => {
+    timer = null;
+    try {
+      const { enabled } = await opts.beat();
+      if (stopped) return;
+      failing = false;
+      if (enabled === false) {
+        stop();
+        log("connect: this machine was disabled in your account; tunnel off");
+        opts.onDisabled();
+        return;
+      }
+    } catch (err) {
+      if (stopped) return;
+      const status = err instanceof ApiError ? err.status : 0;
+      if (status === 401 || status === 404) {
+        stop();
+        log("connect: machine no longer linked, run agent-os connect");
+        opts.onGone();
+        return;
+      }
+      if (!failing) {
+        failing = true;
+        log(
+          `connect: heartbeat failed: ${clean((err as Error)?.message ?? String(err))}; retrying`
+        );
+      }
+    }
+    next();
+  };
+
+  void tick();
+  return { stop };
+}
+
+/** The running AgentOS version, from package.json. */
+export function appVersion(cwd = process.cwd()): string {
+  try {
+    const pkg = JSON.parse(
+      fs.readFileSync(path.join(cwd, "package.json"), "utf8")
+    ) as { version?: string };
+    return pkg.version ?? "unknown";
+  } catch {
+    return "unknown";
+  }
+}

package/lib/connect/serve.ts

@@ -28,7 +28,13 @@ import {
   type ConnectConfig,
 } from "./config";
 import { shouldStartConnect, takeConnectLock } from "./guard";
-import { checkApiUrl, requestTunnel, type Tunnel } from "./control-api";
+import {
+  checkApiUrl,
+  heartbeat as sendHeartbeat,
+  requestTunnel,
+  type Tunnel,
+} from "./control-api";
+import { appVersion, startHeartbeat } from "./heartbeat";
 import { ensureCloudflared } from "./cloudflared";
 import { superviseTunnel, type Spawn, type TunnelState } from "./supervise";
 
@@ -93,12 +99,15 @@ export interface ConnectDeps {
   ) => Promise<Tunnel>;
   spawn?: Spawn;
   delays?: Parameters<typeof superviseTunnel>[0]["delays"];
+  heartbeat?: typeof sendHeartbeat;
+  heartbeatMs?: number;
 }
 
 interface Running {
   server: http.Server;
   sockets: Set<Socket>;
   supervisor: ReturnType<typeof superviseTunnel>;
+  heartbeat: ReturnType<typeof startHeartbeat>;
   release: () => void;
 }
 
@@ -115,6 +124,9 @@ export function startConnect(
   let base: ConnectStatus = { state: "off" };
   let hostname = "";
   let running: Running | null = null;
+  // Set when the service disabled or dropped this machine; sync() leaves it
+  // off until connect.json is turned off or relinked.
+  let halted: string | null = null;
   // Set while the tunnel listener can't bind; it keeps trying.
   let bindError: string | undefined;
   g.__agentosConnect = () => {
@@ -140,6 +152,7 @@ export function startConnect(
   const down = (why: string) => {
     if (!running) return;
     bindError = undefined;
+    running.heartbeat.stop();
     running.supervisor.stop();
     running.sockets.forEach((s) => s.destroy());
     running.server.close();
@@ -162,6 +175,14 @@ export function startConnect(
     hostname = config.hostname;
     base = { state: "off", enrolled: true, hostname: hostname || undefined };
     if (!read.enabled) return;
+    if (halted) {
+      base = {
+        ...base,
+        state: "off",
+        reason: "stopped by the Connect service",
+      };
+      return;
+    }
     try {
       checkApiUrl(config.apiUrl, env.AGENTOS_CONNECT_OPERATOR === "1");
     } catch (err) {
@@ -225,7 +246,22 @@ export function startConnect(
         return { bin, token: tunnel.token };
       },
     });
-    running = { server, sockets, supervisor, release: lock.release };
+    const beat = deps.heartbeat ?? sendHeartbeat;
+    const version = appVersion();
+    const heartbeat = startHeartbeat({
+      beat: () => beat(config, machineKey, version),
+      log,
+      intervalMs: deps.heartbeatMs,
+      onDisabled: () => {
+        halted = config.machineId;
+        down("disabled in your account");
+      },
+      onGone: () => {
+        halted = config.machineId;
+        down("machine no longer linked");
+      },
+    });
+    running = { server, sockets, supervisor, heartbeat, release: lock.release };
     server.listen(tunnelPort, "127.0.0.1");
   };
 
@@ -233,7 +269,12 @@ export function startConnect(
   const sync = () => {
     try {
       const read = readConnect(dir);
-      const want = read.ok && read.enabled;
+      if (
+        halted &&
+        (!read.ok || !read.enabled || read.files.config.machineId !== halted)
+      )
+        halted = null;
+      const want = read.ok && read.enabled && !halted;
       if (running && !want) down(read.ok ? "turned off" : read.reason);
       else if (!running && want) up();
       else if (!running) up(); // refreshes what the status shows

package/lib/usage/calls.ts

@@ -8,46 +8,9 @@
 import { db } from "../db";
 import { ANTHROPIC, sessionRole } from "../models/roles";
 import { ctxOf, weighted, type TokenRow } from "./weights";
+import type { CallKind, CallRow, CallSource, CallUsage } from "./types";
 
-export type CallKind = "main" | "sub" | "review" | "gate" | "helper";
-export type CallSource = "live" | "transcript" | "check_run" | "helper";
-
-export interface CallRow {
-  callKey: string;
-  at: number;
-  sessionId: string | null;
-  taskId: string | null;
-  workspaceId: string | null;
-  projectId: string | null;
-  sessionName: string | null;
-  role: string | null;
-  kind: CallKind;
-  agentType: string | null;
-  model: string | null;
-  provider: string;
-  input: number;
-  cacheRead: number;
-  cacheWrite5m: number;
-  cacheWrite1h: number;
-  output: number;
-  ctx: number | null;
-  source: CallSource;
-}
-
-// What a driver reports for one response, before it's tied to a session.
-export type CallUsage = Pick<
-  CallRow,
-  | "callKey"
-  | "at"
-  | "kind"
-  | "agentType"
-  | "model"
-  | "input"
-  | "cacheRead"
-  | "cacheWrite5m"
-  | "cacheWrite1h"
-  | "output"
->;
+export type { CallKind, CallRow, CallSource, CallUsage };
 
 interface RawUsage {
   input_tokens?: number;

package/lib/usage/types.ts

@@ -0,0 +1,41 @@
+/** Pure usage-ledger types, shared with the mobile app: no imports, nothing server-only. */
+
+export type CallKind = "main" | "sub" | "review" | "gate" | "helper";
+export type CallSource = "live" | "transcript" | "check_run" | "helper";
+
+export interface CallRow {
+  callKey: string;
+  at: number;
+  sessionId: string | null;
+  taskId: string | null;
+  workspaceId: string | null;
+  projectId: string | null;
+  sessionName: string | null;
+  role: string | null;
+  kind: CallKind;
+  agentType: string | null;
+  model: string | null;
+  provider: string;
+  input: number;
+  cacheRead: number;
+  cacheWrite5m: number;
+  cacheWrite1h: number;
+  output: number;
+  ctx: number | null;
+  source: CallSource;
+}
+
+// What a driver reports for one response, before it's tied to a session.
+export type CallUsage = Pick<
+  CallRow,
+  | "callKey"
+  | "at"
+  | "kind"
+  | "agentType"
+  | "model"
+  | "input"
+  | "cacheRead"
+  | "cacheWrite5m"
+  | "cacheWrite1h"
+  | "output"
+>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@saadnvd1/agent-os",
-  "version": "0.3.507",
+  "version": "0.3.509",
   "description": "Self-hosted web UI for managing Claude Code sessions",
   "bin": {
     "agent-os": "scripts/agent-os"