@commonlyai/cli 0.1.213 → 0.1.214

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@commonlyai/cli",
-  "version": "0.1.213",
+  "version": "0.1.214",
   "license": "Apache-2.0",
   "description": "The Commonly CLI — connect agents, manage pods, iterate fast",
   "type": "module",

package/src/commands/agent.js

@@ -1,6 +1,7 @@
 import { createOwnKeyResolver, createMachineReportClient } from '../lib/own-key-launch.js';
 import { foregroundDaemonHint } from '../lib/daemon-hint.js';
 import { loadDaemonRecord } from '../lib/daemon-store.js';
+import { daemonSeatLogPath, logSize, readAppended, readLogTail } from '../lib/daemon-logs.js';
 import { WALKED_HARNESSES } from '../lib/runtime-inventory.js';
 import { createRuntimeReporter } from '../lib/runtime-observation.js';
 /**
@@ -4374,38 +4375,85 @@ Use --local to find the name you'd pass to 'agent run' or 'agent detach'.
     });
 
   // ── logs ──────────────────────────────────────────────────────────────────
+  // Without --pod, the seat's local daemon log is read. With --pod, the owner
+  // login reads recent events and runs from the member-gated seat-activity
+  // route, whichever machine the seat runs on. The owner login is never sent to
+  // the agent-runtime routes, which only accept a seat's own token.
   agent
     .command('logs <name>')
-    .description('Stream recent events for an agent')
-    .option('--instance-id <id>', 'Instance ID', 'default')
-    .option('--follow', 'Keep polling for new events', false)
-    .option('--instance <url>', 'Target Commonly instance')
+    .description("Show a seat's recent log: local daemon log, or server activity with --pod")
+    .option('--pod <podId>', 'Read server-side events and runs for a pod you belong to')
+    .option('--instance-id <id>', 'Seat instance ID', 'default')
+    .option('--follow', 'Continue printing new output', false)
+    .option('--lines <n>', 'Number of trailing local lines to show', '50')
+    .option('--instance <url>', 'Target Commonly instance (with --pod)')
     .action(async (name, opts) => {
+      if (opts.follow && opts.pod) {
+        console.error('--follow needs a local seat log; server activity is a snapshot. Re-run without --follow.');
+        process.exit(1);
+      }
+      const lines = Number(opts.lines);
+      if (!Number.isInteger(lines) || lines < 1) {
+        console.error(`--lines must be a positive integer, got '${opts.lines}'`);
+        process.exit(1);
+      }
+      if (!opts.pod) {
+        const path = daemonSeatLogPath(name);
+        let output;
+        try {
+          output = readLogTail(path, lines);
+        } catch (err) {
+          console.error(`Cannot read ${path}: ${err.message}`);
+          process.exit(1);
+        }
+        if (output === null) {
+          console.error(`No local log for '${name}' at ${path}. Pass --pod <podId> to read its server-side activity.`);
+          process.exit(1);
+        }
+        if (output) console.log(output);
+        if (!opts.follow) return;
+        // Poll rather than fs.watch: a rename-rotated log would leave a watch
+        // on the old inode silent. Only appended bytes are printed.
+        let offset = logSize(path);
+        const timer = setInterval(() => {
+          try {
+            const next = readAppended(path, offset);
+            offset = next.offset;
+            if (next.text) process.stdout.write(next.text);
+          } catch (err) {
+            // Rotation can leave a gap with no file; wait for it to come back.
+            if (err?.code === 'ENOENT') return;
+            console.error(`Cannot follow ${path}: ${err.message}`);
+            process.exit(1);
+          }
+        }, 1000);
+        const close = () => { clearInterval(timer); process.exit(0); };
+        process.once('SIGINT', close);
+        process.once('SIGTERM', close);
+        return;
+      }
+
       const token = getToken(opts.instance);
       if (!token) { console.error('Not logged in. Run: commonly login'); process.exit(1); }
-
       const client = createClient({ instance: resolveInstanceUrl(opts.instance), token });
-
-      const fetchAndPrint = async () => {
-        const { events = [] } = await client.get('/api/agents/runtime/events', {
+      const printActivity = async () => {
+        const { events = [], runs = [] } = await client.get('/api/agents/seat-activity', {
+          podId: opts.pod,
           agentName: name,
           instanceId: opts.instanceId,
-          limit: 20,
         });
         events.forEach((e) => {
           const ts = new Date(e.createdAt).toTimeString().slice(0, 8);
-          const outcome = e.delivery?.outcome || e.status;
-          console.log(`[${ts}] ${e.type.padEnd(18)} → ${outcome}`);
+          console.log(`[${ts}] ${String(e.type).padEnd(18)} → ${e.outcome || e.status}`);
         });
-        return events;
+        runs.forEach((r) => {
+          const ts = new Date(r.startedAt).toTimeString().slice(0, 8);
+          console.log(`[${ts}] run ${String(r.trigger).padEnd(14)} → ${r.status} (${r.totalTokens} tokens)`);
+        });
+        if (events.length === 0 && runs.length === 0) console.log(`No recent activity for '${name}' in this pod.`);
       };
-
       try {
-        await fetchAndPrint();
-        if (opts.follow) {
-          console.log('Following... (Ctrl+C to stop)');
-          setInterval(fetchAndPrint, 5000);
-        }
+        await printActivity();
       } catch (err) {
         console.error(`Failed: ${err.message}`);
         process.exit(1);

package/src/lib/daemon-logs.js

@@ -1,4 +1,4 @@
-import { readFileSync } from 'node:fs';
+import { closeSync, openSync, readFileSync, readSync, statSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
 
@@ -23,3 +23,21 @@ export const readLogTail = (path, count = 50) => {
     throw error;
   }
 };
+
+export const logSize = (path) => statSync(path).size;
+
+// Bytes appended since `offset`, for `agent logs --follow`. A file that shrank
+// (rotated or truncated) is read from the start again.
+export const readAppended = (path, offset) => {
+  const size = logSize(path);
+  const start = size < offset ? 0 : offset;
+  if (size === start) return { text: '', offset: size };
+  const fd = openSync(path, 'r');
+  try {
+    const buffer = Buffer.alloc(size - start);
+    readSync(fd, buffer, 0, buffer.length, start);
+    return { text: buffer.toString('utf8'), offset: size };
+  } finally {
+    closeSync(fd);
+  }
+};