@gethmy/agent 1.0.6 → 1.0.8

package/dist/__tests__/progress-tracker.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/progress-tracker.test.js

@@ -0,0 +1,246 @@
+import { EventEmitter } from "node:events";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+// Dynamic import so we can test the module without triggering side effects
+// from other imports (log, etc.)
+let ProgressTracker;
+// Minimal mock of HarmonyApiClient
+function makeMockClient() {
+    return {
+        updateAgentProgress: vi.fn().mockResolvedValue(undefined),
+        flushActivityLog: vi.fn().mockResolvedValue(undefined),
+        startAgentSession: vi.fn().mockResolvedValue(undefined),
+        endAgentSession: vi.fn().mockResolvedValue(undefined),
+    };
+}
+// Mock StreamParser — just an EventEmitter with the same typed interface
+class MockParser extends EventEmitter {
+    emitToolStart(name, input) {
+        this.emit("tool_start", name, input);
+    }
+    emitToolEnd(name, toolUseId, content) {
+        this.emit("tool_end", name, toolUseId, content);
+    }
+    emitText(content) {
+        this.emit("text", content);
+    }
+}
+// Access private fields via type cast
+function getPrivate(tracker) {
+    return tracker;
+}
+beforeEach(async () => {
+    // Reset module to get fresh class each test (avoids timer leakage between tests)
+    const mod = await import("../progress-tracker.js");
+    ProgressTracker = mod.ProgressTracker;
+});
+afterEach(() => {
+    vi.restoreAllMocks();
+});
+describe("ProgressTracker", () => {
+    describe("setSessionId", () => {
+        it("stores the session ID", () => {
+            const client = makeMockClient();
+            const tracker = new ProgressTracker(client, "card-1", 0, []);
+            tracker.stop(); // prevent heartbeat
+            expect(getPrivate(tracker).sessionId).toBeNull();
+            tracker.setSessionId("session-abc");
+            expect(getPrivate(tracker).sessionId).toBe("session-abc");
+        });
+        it("triggers flush with correct sessionId when sendUpdate is called", async () => {
+            const client = makeMockClient();
+            const tracker = new ProgressTracker(client, "card-1", 0, []);
+            tracker.stop();
+            tracker.setSessionId("session-xyz");
+            // Push an entry manually so flush has something to send
+            getPrivate(tracker).logBuffer.push({
+                phase: "exploring",
+                eventType: "tool_start",
+                toolName: "Read",
+                description: "Reading src/foo.ts",
+                metadata: {},
+                createdAt: new Date().toISOString(),
+            });
+            // Trigger sendUpdate by calling the private method indirectly
+            // (Force lastUpdateAt to 0 so throttle passes)
+            tracker.lastUpdateAt = 0;
+            tracker.sendUpdate("test task");
+            await vi.waitFor(() => {
+                expect(client.flushActivityLog).toHaveBeenCalledWith("card-1", expect.objectContaining({ sessionId: "session-xyz" }));
+            });
+        });
+    });
+    describe("tool_start events", () => {
+        it("creates a log entry in the buffer when tool has a description", () => {
+            const client = makeMockClient();
+            const tracker = new ProgressTracker(client, "card-2", 0, []);
+            tracker.stop();
+            const parser = new MockParser();
+            tracker.attach(parser);
+            parser.emitToolStart("Read", { file_path: "/src/foo.ts" });
+            const buf = getPrivate(tracker).logBuffer;
+            const entry = buf.find((e) => e.eventType === "tool_start");
+            expect(entry).toBeDefined();
+            expect(entry?.toolName).toBe("Read");
+            expect(entry?.description).toMatch(/Reading/);
+            expect(entry?.createdAt).toBeDefined();
+        });
+        it("does not create a log entry for tools with no description", () => {
+            const client = makeMockClient();
+            const tracker = new ProgressTracker(client, "card-2", 0, []);
+            tracker.stop();
+            const parser = new MockParser();
+            tracker.attach(parser);
+            // Unknown tool with no special description logic
+            parser.emitToolStart("SomeObscureUnknownTool", {});
+            const buf = getPrivate(tracker).logBuffer;
+            const entry = buf.find((e) => e.eventType === "tool_start" && e.toolName === "SomeObscureUnknownTool");
+            expect(entry).toBeUndefined();
+        });
+    });
+    describe("tool_end events", () => {
+        it("creates a log entry for every tool_end event", () => {
+            const client = makeMockClient();
+            const tracker = new ProgressTracker(client, "card-3", 0, []);
+            tracker.stop();
+            const parser = new MockParser();
+            tracker.attach(parser);
+            parser.emitToolEnd("Bash", "tool-use-1", "exit 0");
+            const buf = getPrivate(tracker).logBuffer;
+            const entry = buf.find((e) => e.eventType === "tool_end" && e.toolName === "Bash");
+            expect(entry).toBeDefined();
+            expect(entry?.description).toContain("Completed");
+        });
+    });
+    describe("buffer cap", () => {
+        it("caps buffer at 500 entries after pushing 510", () => {
+            const client = makeMockClient();
+            const tracker = new ProgressTracker(client, "card-4", 0, []);
+            tracker.stop();
+            const parser = new MockParser();
+            tracker.attach(parser);
+            // Emit 510 tool_end events (tool_end always creates an entry)
+            for (let i = 0; i < 510; i++) {
+                parser.emitToolEnd("Read", `id-${i}`, undefined);
+            }
+            const buf = getPrivate(tracker).logBuffer;
+            expect(buf.length).toBeLessThanOrEqual(500);
+        });
+        it("keeps the most recent entries when the buffer overflows", () => {
+            const client = makeMockClient();
+            const tracker = new ProgressTracker(client, "card-4b", 0, []);
+            tracker.stop();
+            const parser = new MockParser();
+            tracker.attach(parser);
+            for (let i = 0; i < 510; i++) {
+                parser.emitToolEnd(`Tool${i}`, `id-${i}`, undefined);
+            }
+            const buf = getPrivate(tracker).logBuffer;
+            // The oldest entries (0–9) should have been shifted out
+            expect(buf[0].toolName).not.toBe("Tool0");
+        });
+    });
+    describe("flushActivityLog", () => {
+        it("clears the buffer on successful flush", async () => {
+            const client = makeMockClient();
+            const tracker = new ProgressTracker(client, "card-5", 0, []);
+            tracker.stop();
+            tracker.setSessionId("session-flush");
+            getPrivate(tracker).logBuffer.push({
+                phase: "exploring",
+                eventType: "tool_end",
+                toolName: "Read",
+                description: "Completed: Read",
+                metadata: {},
+                createdAt: new Date().toISOString(),
+            });
+            // Invoke the private method
+            tracker.flushActivityLog();
+            // Wait for the async client call to resolve
+            await vi.waitFor(() => {
+                expect(client.flushActivityLog).toHaveBeenCalled();
+            });
+            // Buffer should be empty after successful flush
+            expect(getPrivate(tracker).logBuffer).toHaveLength(0);
+        });
+        it("retains buffer entries on flush error", async () => {
+            const client = makeMockClient();
+            client.flushActivityLog.mockRejectedValue(new Error("network error"));
+            const tracker = new ProgressTracker(client, "card-6", 0, []);
+            tracker.stop();
+            tracker.setSessionId("session-retry");
+            getPrivate(tracker).logBuffer.push({
+                phase: "exploring",
+                eventType: "tool_end",
+                toolName: "Read",
+                description: "Completed: Read",
+                metadata: {},
+                createdAt: new Date().toISOString(),
+            });
+            tracker.flushActivityLog();
+            await vi.waitFor(() => {
+                // After the rejected promise is caught, entries should be back in buffer
+                expect(getPrivate(tracker).logBuffer.length).toBeGreaterThan(0);
+            });
+        });
+        it("skips flush when no session ID is set", () => {
+            const client = makeMockClient();
+            const tracker = new ProgressTracker(client, "card-7", 0, []);
+            tracker.stop();
+            // No setSessionId called
+            getPrivate(tracker).logBuffer.push({
+                phase: "exploring",
+                eventType: "tool_end",
+                toolName: "Read",
+                description: "Completed: Read",
+                metadata: {},
+                createdAt: new Date().toISOString(),
+            });
+            tracker.flushActivityLog();
+            // Should not have called the client
+            expect(client.flushActivityLog).not.toHaveBeenCalled();
+            // Buffer should still contain the entry
+            expect(getPrivate(tracker).logBuffer).toHaveLength(1);
+        });
+        it("skips flush when buffer is empty", () => {
+            const client = makeMockClient();
+            const tracker = new ProgressTracker(client, "card-8", 0, []);
+            tracker.stop();
+            tracker.setSessionId("session-empty");
+            // logBuffer is empty by default
+            tracker.flushActivityLog();
+            expect(client.flushActivityLog).not.toHaveBeenCalled();
+        });
+    });
+    describe("sendUpdate payload", () => {
+        it("does not include recentActions in the updateAgentProgress payload", async () => {
+            const client = makeMockClient();
+            const tracker = new ProgressTracker(client, "card-9", 0, []);
+            tracker.stop();
+            tracker.lastUpdateAt = 0;
+            tracker.sendUpdate("doing stuff");
+            await vi.waitFor(() => {
+                expect(client.updateAgentProgress).toHaveBeenCalled();
+            });
+            const [, payload] = client.updateAgentProgress.mock.calls[0];
+            expect(payload).not.toHaveProperty("recentActions");
+        });
+        it("includes expected fields in updateAgentProgress payload", async () => {
+            const client = makeMockClient();
+            const tracker = new ProgressTracker(client, "card-10", 0, []);
+            tracker.stop();
+            tracker.lastUpdateAt = 0;
+            tracker.sendUpdate("building feature");
+            await vi.waitFor(() => {
+                expect(client.updateAgentProgress).toHaveBeenCalled();
+            });
+            const [cardId, payload] = client.updateAgentProgress.mock.calls[0];
+            expect(cardId).toBe("card-10");
+            expect(payload).toMatchObject({
+                status: "working",
+                currentTask: expect.any(String),
+                progressPercent: expect.any(Number),
+                phase: expect.any(String),
+            });
+        });
+    });
+});

package/dist/progress-tracker.d.ts

@@ -1,5 +1,13 @@
 import type { HarmonyApiClient } from "@gethmy/mcp/src/api-client.js";
 import type { CostUpdate, StreamParser } from "./stream-parser.js";
+export interface ActivityLogEntry {
+    phase: string | null;
+    eventType: "tool_start" | "tool_end" | "phase_change" | "error" | "summary";
+    toolName: string | null;
+    description: string;
+    metadata: Record<string, unknown>;
+    createdAt: string;
+}
 export declare class ProgressTracker {
     private client;
     private cardId;
@@ -20,10 +28,12 @@ export declare class ProgressTracker {
     private filesEdited;
     private filesRead;
     private lastCost;
-    private recentActions;
+    private logBuffer;
+    private sessionId;
     constructor(client: HarmonyApiClient, cardId: string, workerId: number, subtasks: {
         completed: boolean;
     }[]);
+    setSessionId(id: string): void;
     /**
      * Wire up the parser events and start the heartbeat.
      */
@@ -54,9 +64,12 @@ export declare class ProgressTracker {
      */
     private shortPath;
     private scheduleUpdate;
-    private pushRecentAction;
     private sendUpdate;
     private startHeartbeat;
+    flushFinal(): void;
+    private pushLogEntry;
+    private flushActivityLog;
+    private extractToolMetadata;
     /**
      * Safely extract a string property from an unknown tool input.
      */

package/dist/progress-tracker.js

@@ -4,7 +4,7 @@ const TAG = "progress-tracker";
 const THROTTLE_MS = 5_000;
 const HEARTBEAT_MS = 60_000;
 const MAX_TASK_LENGTH = 120;
-const MAX_RECENT_ACTIONS = 5;
+const MAX_LOG_BUFFER = 500;
 // Hoisted regexes — avoids recompilation on every call
 const SENTENCE_SPLIT = /\.\s|\n/;
 const ACTION_PREFIX = /^(Let me|I'll|I need to|Now|First|Next|Looking|Checking|Creating|Adding|Updating|Fixing|Refactoring|Moving|The |This )/i;
@@ -60,7 +60,8 @@ export class ProgressTracker {
     filesEdited = new Set();
     filesRead = new Set();
     lastCost = null;
-    recentActions = [];
+    logBuffer = [];
+    sessionId = null;
     constructor(client, cardId, workerId, subtasks) {
         this.client = client;
         this.cardId = cardId;
@@ -69,15 +70,35 @@ export class ProgressTracker {
         this.subtaskCompleted = subtasks.filter((s) => s.completed).length;
         this.subtaskMode = subtasks.length > 0;
     }
+    setSessionId(id) {
+        this.sessionId = id;
+    }
     /**
      * Wire up the parser events and start the heartbeat.
      */
     attach(parser) {
         parser.on("tool_start", (name, input) => {
             this.onToolStart(name, input);
+            const desc = this.describeToolAction(name, input);
+            if (desc) {
+                this.pushLogEntry({
+                    phase: this.phase,
+                    eventType: "tool_start",
+                    toolName: name,
+                    description: desc,
+                    metadata: this.extractToolMetadata(name, input),
+                });
+            }
         });
         parser.on("tool_end", (name, _id, content) => {
             this.onToolEnd(name, content);
+            this.pushLogEntry({
+                phase: this.phase,
+                eventType: "tool_end",
+                toolName: name,
+                description: `Completed: ${name}`,
+                metadata: {},
+            });
         });
         parser.on("text", (content) => {
             this.onText(content);
@@ -159,7 +180,6 @@ export class ProgressTracker {
         const action = this.describeToolAction(name, input);
         if (action) {
             this.lastAction = action;
-            this.pushRecentAction(action);
         }
         this.incrementProgress();
     }
@@ -202,6 +222,13 @@ export class ProgressTracker {
         this.progress = Math.max(this.progress, PHASES[newPhase].min);
         // Reset stale action from prior phase; new phase starts with its own label
         this.lastAction = "";
+        this.pushLogEntry({
+            phase: newPhase,
+            eventType: "phase_change",
+            toolName: null,
+            description: `Entering ${newPhase} phase`,
+            metadata: {},
+        });
         this.scheduleUpdate(PHASES[newPhase].label);
     }
     incrementProgress() {
@@ -307,15 +334,6 @@ export class ProgressTracker {
         }
         // If there's already a pending update, pendingTask is now updated — it will use the fresh value
     }
-    pushRecentAction(action) {
-        this.recentActions.push({
-            action,
-            ts: new Date().toISOString(),
-        });
-        if (this.recentActions.length > MAX_RECENT_ACTIONS) {
-            this.recentActions.shift();
-        }
-    }
     sendUpdate(currentTask) {
         this.lastUpdateAt = Date.now();
         log.debug(TAG, `Progress: ${this.progress}% — ${currentTask}`);
@@ -329,11 +347,11 @@ export class ProgressTracker {
             phase: this.phase,
             filesChanged: this.filesEdited.size,
             costCents: Math.round((this.lastCost?.totalCostUsd ?? 0) * 100),
-            recentActions: this.recentActions,
         })
             .catch((err) => {
             log.warn(TAG, `Failed to send progress update: ${err}`);
         });
+        this.flushActivityLog();
     }
     startHeartbeat() {
         if (this.heartbeatTimer) {
@@ -349,6 +367,57 @@ export class ProgressTracker {
             }
         }, HEARTBEAT_MS);
     }
+    flushFinal() {
+        this.flushActivityLog();
+    }
+    pushLogEntry(entry) {
+        this.logBuffer.push({
+            ...entry,
+            createdAt: new Date().toISOString(),
+        });
+        if (this.logBuffer.length > MAX_LOG_BUFFER) {
+            this.logBuffer.shift();
+        }
+    }
+    flushActivityLog() {
+        if (!this.sessionId || this.logBuffer.length === 0)
+            return;
+        const raw = [...this.logBuffer];
+        this.logBuffer = [];
+        this.client
+            .flushActivityLog(this.cardId, {
+            sessionId: this.sessionId,
+            entries: raw.map((e) => ({
+                ...e,
+                phase: e.phase ?? undefined,
+                toolName: e.toolName ?? undefined,
+            })),
+        })
+            .catch((err) => {
+            log.warn(TAG, `Failed to flush activity log: ${err}`);
+            // Put entries back at the front of the buffer for retry
+            this.logBuffer.unshift(...raw);
+            if (this.logBuffer.length > MAX_LOG_BUFFER) {
+                this.logBuffer.length = MAX_LOG_BUFFER;
+            }
+        });
+    }
+    extractToolMetadata(name, input) {
+        const meta = {};
+        const fp = this.extractString(input, "file_path");
+        if (fp)
+            meta.file_path = fp;
+        const cmd = this.extractString(input, "command");
+        if (cmd)
+            meta.command = cmd.split("\n")[0].slice(0, 200);
+        const pattern = this.extractString(input, "pattern");
+        if (pattern)
+            meta.pattern = pattern;
+        const desc = this.extractString(input, "description");
+        if (desc)
+            meta.description = desc;
+        return meta;
+    }
     /**
      * Safely extract a string property from an unknown tool input.
      */

package/dist/watcher.d.ts

@@ -20,7 +20,9 @@ export declare class Watcher {
     private onCardBroadcast;
     private onAgentCommand?;
     private channel;
+    private presenceChannel;
     private supabase;
+    private daemonId;
     constructor(credentials: RealtimeCredentials, projectId: string, onCardBroadcast: CardBroadcastHandler, onAgentCommand?: AgentCommandHandler | undefined);
     start(): Promise<void>;
     stop(): Promise<void>;

package/dist/watcher.js

@@ -1,3 +1,4 @@
+import { randomUUID } from "node:crypto";
 import { createClient } from "@supabase/supabase-js";
 import { log } from "./log.js";
 const TAG = "watcher";
@@ -12,7 +13,9 @@ export class Watcher {
     onCardBroadcast;
     onAgentCommand;
     channel = null;
+    presenceChannel = null;
     supabase = null;
+    daemonId = randomUUID();
     constructor(credentials, projectId, onCardBroadcast, onAgentCommand) {
         this.credentials = credentials;
         this.projectId = projectId;
@@ -22,6 +25,9 @@ export class Watcher {
     async start() {
         log.info(TAG, "Connecting to Supabase realtime (broadcast)...");
         this.supabase = createClient(this.credentials.supabaseUrl, this.credentials.supabaseAnonKey);
+        // Presence channel — separate from the broadcast channel to avoid
+        // conflicting with frontend BoardContext's board-{projectId} subscription
+        const presenceChannel = this.supabase.channel(`board-presence-${this.projectId}`);
         const channel = this.supabase
             .channel(`board-${this.projectId}`)
             .on("broadcast", { event: "card_update" }, (msg) => {
@@ -59,8 +65,27 @@ export class Watcher {
             }
         });
         this.channel = channel;
+        // Subscribe presence channel for daemon online indicator
+        presenceChannel
+            .on("presence", { event: "sync" }, () => {
+            log.debug(TAG, "Presence sync");
+        })
+            .subscribe(async (status) => {
+            if (status === "SUBSCRIBED") {
+                await presenceChannel.track({
+                    daemonId: this.daemonId,
+                    startedAt: new Date().toISOString(),
+                });
+                log.info(TAG, "Presence tracked on board-presence channel");
+            }
+        });
+        this.presenceChannel = presenceChannel;
     }
     async stop() {
+        if (this.presenceChannel) {
+            await this.supabase?.removeChannel(this.presenceChannel);
+            this.presenceChannel = null;
+        }
         if (this.channel) {
             await this.supabase?.removeChannel(this.channel);
             this.channel = null;

package/dist/worker.d.ts

@@ -18,6 +18,7 @@ export declare class Worker {
     private progressTracker;
     private lastSessionStats;
     private aborted;
+    private sessionId;
     constructor(id: number, config: AgentConfig, client: HarmonyApiClient, _userEmail: string, onDone: (worker: Worker) => void, workspaceId: string, projectId: string);
     get tag(): string;
     get isIdle(): boolean;

package/dist/worker.js

@@ -27,6 +27,7 @@ export class Worker {
     progressTracker = null;
     lastSessionStats;
     aborted = false;
+    sessionId = null;
     constructor(id, config, client, _userEmail, onDone, workspaceId, projectId) {
         this.config = config;
         this.client = client;
@@ -61,13 +62,20 @@ export class Worker {
             this.branchName = makeBranchName(card.short_id, card.title);
             log.info(this.tag, `Preparing #${card.short_id} "${card.title}"`);
             // Start agent session and make it visible on the board
-            await this.client.startAgentSession(card.id, {
+            const { session } = await this.client.startAgentSession(card.id, {
                 agentIdentifier: agentIdentifier(this.id),
                 agentName: AGENT_NAME,
                 status: "working",
                 currentTask: "Setting up worktree",
                 progressPercent: 5,
             });
+            const sid = session && typeof session === "object" && "id" in session
+                ? session.id
+                : null;
+            if (!sid) {
+                log.warn(TAG, "startAgentSession returned no session id");
+            }
+            this.sessionId = sid;
             // Move card to "In Progress" and add "agent" label so the board shows the progress ring
             const moved = await moveCardAndAddLabel(this.client, card, "In Progress", "agent");
             if (!moved) {
@@ -256,6 +264,9 @@ export class Worker {
             const parser = new StreamParser();
             // Progress tracker for phase-based updates
             this.progressTracker = new ProgressTracker(this.client, card.id, this.id, subtasks);
+            if (this.sessionId) {
+                this.progressTracker.setSessionId(this.sessionId);
+            }
             this.progressTracker.attach(parser);
             // Attach stdout to parser
             if (this.process.stdout) {
@@ -274,6 +285,7 @@ export class Worker {
             this.process.on("close", (code) => {
                 this.process = null;
                 this.lastSessionStats = this.progressTracker?.stats;
+                this.progressTracker?.flushFinal();
                 this.progressTracker?.stop();
                 this.progressTracker = null;
                 if (this.aborted) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gethmy/agent",
-  "version": "1.0.6",
+  "version": "1.0.8",
   "description": "Push-based agent daemon for Harmony — watches board assignments and spawns Claude CLI workers",
   "type": "module",
   "main": "dist/index.js",
@@ -40,7 +40,8 @@
     "prebuild": "cd ../harmony-shared && bun run build && cd ../memory && bun run build",
     "build": "tsc",
     "typecheck": "tsc --noEmit",
-    "prepublishOnly": "npm run build"
+    "prepublishOnly": "npm run build",
+    "test": "vitest run"
   },
   "dependencies": {
     "@supabase/supabase-js": "2.95.3",
@@ -49,6 +50,7 @@
   "devDependencies": {
     "@harmony/shared": "workspace:*",
     "@types/node": "^25.5.0",
-    "typescript": "^6.0.1"
+    "typescript": "^6.0.1",
+    "vitest": "^3.2.1"
   }
 }