@cueloop/daemon 0.1.0-alpha.97 → 0.1.0-alpha.99

package/src/thread-review.ts

@@ -74,6 +74,7 @@ export async function resolveWorkspace(cwd = process.cwd()): Promise<WorkspaceKe
   const remote = nativeJjRoot ? null : gitRemote;
 
   const workspace: WorkspaceKey = { repoRoot, branch };
+
   // a repo with no commits (or a shallow clone) has no reliable root, so the thread stays standalone
   if (rootCommit) workspace.rootCommit = rootCommit;
   if (remote) workspace.remote = remote;

package/src/thread-subscription.test.ts

@@ -0,0 +1,174 @@
+import { expect, test } from "bun:test";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { DaemonServer } from "./server";
+import { DaemonClient } from "./client";
+import { subscribeThreadState, connectThreadObserver } from "./thread-subscription";
+
+import { createTestSignal } from "../../../test/helpers/test-signal";
+
+test("subscription refresh discards stale reads and disposal suppresses late callbacks", async () => {
+  const home = mkdtempSync(join(tmpdir(), "cueloop-subscription-"));
+  const server = new DaemonServer({ home, idleExitMs: 0 });
+
+  server.start();
+  const client = await DaemonClient.connect({ home });
+  const firstRead = createTestSignal<void>();
+  const releaseFirst = createTestSignal<void>();
+  const latest = createTestSignal<void>();
+  const values: string[] = [];
+  let reads = 0;
+  let dispose = () => {};
+
+  try {
+    const thread = await client.sessionCreate(
+      { repoRoot: home, branch: "main" },
+      { type: "plan", content: "Initial", meta: {} },
+    );
+
+    dispose = subscribeThreadState({
+      connect: connectThreadObserver({ home }),
+      matches: (event) => event.sessionId === thread.id,
+      read: async (api) => {
+        const state = await api.sessionGet(thread.id);
+
+        if (++reads === 1) {
+          firstRead.resolve();
+          await releaseFirst.promise;
+        }
+
+        return state;
+      },
+      onValue: (state) => {
+        values.push(state.artifact.meta.title ?? "Initial");
+        latest.resolve();
+      },
+      onError: (error) => latest.reject(error),
+    });
+    await firstRead.promise;
+    await client.sessionSetTitle(thread.id, "New");
+    await latest.promise;
+    releaseFirst.resolve();
+    await Promise.resolve();
+    expect(values).toEqual(["New"]);
+    dispose();
+    await client.sessionSetTitle(thread.id, "After disposal");
+    expect(values).toEqual(["New"]);
+  } finally {
+    dispose();
+    client.close();
+    server.stop();
+    rmSync(home, { recursive: true, force: true });
+  }
+});
+
+test("reconnect subscribes again and refreshes authoritative state even without a notification", async () => {
+  const home = mkdtempSync(join(tmpdir(), "cueloop-reconnect-"));
+  let server = new DaemonServer({ home, idleExitMs: 0 });
+
+  server.start();
+  const client = await DaemonClient.connect({ home });
+  const initial = createTestSignal<void>();
+  const recovered = createTestSignal<void>();
+  let connections = 0;
+  const values: string[] = [];
+  let dispose = () => {};
+
+  try {
+    const thread = await client.sessionCreate(
+      { repoRoot: home, branch: "main" },
+      { type: "plan", content: "Initial", meta: {} },
+    );
+
+    dispose = subscribeThreadState({
+      connect: connectThreadObserver({ home }),
+      reconnectMs: 1,
+      matches: (event) => event.sessionId === thread.id,
+      read: (api) => api.sessionGet(thread.id),
+      onConnect: () => {
+        connections++;
+      },
+      onValue: (state) => {
+        values.push(state.artifact.meta.title ?? "Initial");
+        if (connections === 1) initial.resolve();
+        else recovered.resolve();
+      },
+      onError() {},
+    });
+    await initial.promise;
+    server.stop();
+    server = new DaemonServer({ home, idleExitMs: 0 });
+    server.core.sessionSetTitle(thread.id, "Recovered");
+    server.start();
+    await recovered.promise;
+    expect(connections).toBe(2);
+    expect(values).toEqual(["Initial", "Recovered"]);
+  } finally {
+    dispose();
+    client.close();
+    server.stop();
+    rmSync(home, { recursive: true, force: true });
+  }
+});
+
+test("a malformed protocol frame stops the observer instead of reconnecting", async () => {
+  const { LineBuffer, parseRequestFrame } = await import("./protocol");
+  const { socketPath } = await import("./paths");
+  const { DAEMON_VERSION } = await import("./version");
+  const home = mkdtempSync(join(tmpdir(), "cueloop-subscription-protocol-"));
+  const failed = createTestSignal<void>();
+  const reads = new Map<object, InstanceType<typeof LineBuffer>>();
+  let connections = 0;
+  const server = Bun.listen({
+    unix: socketPath(home),
+    socket: {
+      open(socket) {
+        reads.set(socket, new LineBuffer());
+        connections++;
+        if (connections > 1) failed.reject(new Error("Unexpected reconnect"));
+      },
+      data(socket, bytes) {
+        reads.get(socket)!.push(bytes.toString(), (line) => {
+          const request = parseRequestFrame(line);
+
+          socket.write(
+            JSON.stringify({
+              id: request.id,
+              result:
+                request.method === "daemon.ping"
+                  ? { pid: process.pid, version: DAEMON_VERSION }
+                  : {},
+            }) + "\n",
+          );
+          if (request.method === "events.subscribe") socket.write("{broken\n");
+        });
+      },
+      close(socket) {
+        reads.delete(socket);
+      },
+    },
+  });
+  const dispose = subscribeThreadState({
+    connect: connectThreadObserver({ home }),
+    reconnectMs: 1,
+    matches: () => true,
+    read: (client) => client.ping(),
+    onValue() {},
+    onError: (error) => {
+      expect(error).toMatchObject({ kind: "protocol" });
+      failed.resolve();
+    },
+  });
+
+  try {
+    await failed.promise;
+    // A timer boundary proves no reconnect remains scheduled after the protocol closure.
+    await new Promise((resolve) => setTimeout(resolve, 20));
+    expect(connections).toBe(1);
+  } finally {
+    dispose();
+    server.stop(true);
+    rmSync(home, { recursive: true, force: true });
+  }
+});

package/src/thread-subscription.ts

@@ -0,0 +1,127 @@
+import { DaemonClient, DaemonClientError, type ConnectOptions } from "./client";
+import { DaemonTransportError } from "./client-errors";
+import type { EventFrame } from "./protocol";
+
+/** Notifications are refresh hints; each connection starts with an authoritative read. */
+export interface ThreadSubscriptionOptions<Value> {
+  connect: () => Promise<DaemonClient>;
+  matches: (event: EventFrame) => boolean;
+  read: (client: DaemonClient, signal: AbortSignal) => Promise<Value>;
+  onValue: (value: Value, client: DaemonClient) => void;
+  // eslint-disable-next-line type-evidence/no-unknown-parameters -- Socket and read failures arrive from an untyped Promise rejection boundary.
+  onError: (error: unknown) => void;
+  onConnect?: (client: DaemonClient) => void;
+  reconnectMs?: number;
+}
+
+/** Dispose removes listeners, aborts local reads, and closes only the observation connection. */
+export function subscribeThreadState<Value>(options: ThreadSubscriptionOptions<Value>): () => void {
+  let stopped = false;
+  let generation = 0;
+  let connection: DaemonClient | undefined;
+  let detach: (() => void) | undefined;
+  let timer: ReturnType<typeof setTimeout> | undefined;
+  const reads = new Set<AbortController>();
+  const schedule = () => {
+    if (!stopped) timer = setTimeout(() => void connect(), options.reconnectMs ?? 250);
+  };
+  const connect = async () => {
+    const epoch = ++generation;
+    let request = 0;
+    let api: DaemonClient | undefined;
+
+    try {
+      api = await options.connect();
+      if (stopped || epoch !== generation) {
+        api.close();
+
+        return;
+      }
+      connection = api;
+      const current = api;
+      const refresh = async () => {
+        const version = ++request;
+
+        for (const read of reads) read.abort();
+        const controller = new AbortController();
+
+        reads.add(controller);
+        try {
+          const value = await options.read(current, controller.signal);
+
+          if (!stopped && epoch === generation && version === request)
+            options.onValue(value, current);
+        } catch (error) {
+          if (!stopped && epoch === generation && version === request) {
+            if (error instanceof Error && isFatalSubscriptionError(error)) {
+              stopped = true;
+              ++generation;
+              clearTimeout(timer);
+              detach?.();
+              current.close();
+            }
+            options.onError(error);
+          }
+        } finally {
+          reads.delete(controller);
+        }
+      };
+      const offEvent = api.onEvent((event) => {
+        if (options.matches(event)) void refresh();
+      });
+      const offDisconnect = api.onDisconnect((reason) => {
+        if (stopped || epoch !== generation) return;
+        ++generation;
+        detach?.();
+        for (const read of reads) read.abort();
+        connection = undefined;
+        current.close();
+        if (isFatalSubscriptionError(reason)) {
+          stopped = true;
+          options.onError(reason);
+        } else schedule();
+      });
+
+      detach = () => {
+        offEvent();
+        offDisconnect();
+      };
+      await api.subscribe();
+      if (stopped || epoch !== generation) return;
+      options.onConnect?.(api);
+      await refresh();
+    } catch (error) {
+      if (stopped || epoch !== generation) return;
+      ++generation;
+      detach?.();
+      api?.close();
+      connection = undefined;
+      options.onError(error);
+      if (!(error instanceof Error && isFatalSubscriptionError(error))) schedule();
+    }
+  };
+
+  void connect();
+
+  return () => {
+    stopped = true;
+    ++generation;
+    clearTimeout(timer);
+    detach?.();
+    for (const read of reads) read.abort();
+    reads.clear();
+    connection?.close();
+  };
+}
+
+/** Reconnect never replays writes, only subscribes and reads the latest Thread state. */
+export function connectThreadObserver(options: ConnectOptions): () => Promise<DaemonClient> {
+  return () => DaemonClient.connect(options);
+}
+
+function isFatalSubscriptionError(error: Error): boolean {
+  return (
+    error instanceof DaemonClientError ||
+    (error instanceof DaemonTransportError && error.kind === "protocol")
+  );
+}

package/src/validate.test.ts

@@ -330,6 +330,7 @@ describe("wire pins", () => {
     workingCopy: "# ",
     textCuts: [{ start: 2, end: 3, quote: "P" }],
     viewedPaths: ["src/a.ts"],
+    messageOperations: [{ operationId: "operation", fingerprint: "hash", result: fullMessage }],
     message: fullMessage,
     status: "pending",
     createdAt: "now",

package/src/validate.ts

@@ -41,6 +41,7 @@ import {
 } from "@cueloop/schema";
 import { DaemonError } from "./errors";
 import type { Request } from "./protocol";
+import { AgentCommentSchema } from "./thread-agent-validation";
 
 /**
  * Drift guard for every hand-mirrored shape below. v.object strips keys it
@@ -211,6 +212,27 @@ export const DeliverySchema = v.object({
 } satisfies EntriesOf<Delivery>);
 
 export const Params = {
+  "agent.configure": v.object({
+    id: SessionId,
+    configId: v.optional(NonEmpty),
+    value: v.optional(NonEmpty),
+  }),
+  "agent.get": v.object({ id: SessionId }),
+  "agent.prompt": v.object({
+    id: SessionId,
+    text: v.pipe(v.string(), v.maxLength(65_536)),
+    context: v.optional(v.pipe(v.string(), v.maxLength(32_768))),
+    retry: v.optional(NonEmpty),
+    operationId: v.optional(v.pipe(NonEmpty, v.maxLength(128))),
+  }),
+  "agent.reply": v.object({
+    id: SessionId,
+    commentId: NonEmpty,
+    body: v.pipe(NonEmpty, v.maxLength(32_768)),
+  }),
+  "agent.cancel": v.object({ id: SessionId }),
+  "agent.comment": v.object({ id: SessionId, comment: AgentCommentSchema }),
+  "agent.permission": v.object({ id: SessionId, requestId: NonEmpty, optionId: NonEmpty }),
   "session.create": v.object({ workspace: WorkspaceSchema, artifact: ArtifactSchema }),
   "session.get": v.object({ id: SessionId }),
   "session.list": v.object({
@@ -306,6 +328,7 @@ export const Params = {
     outcome: v.picklist(MESSAGE_OUTCOMES),
     summary: v.optional(v.string(), ""),
     actionBodies: v.optional(v.record(v.string(), v.string())),
+    operationId: v.optional(v.pipe(NonEmpty, v.maxLength(128))),
   }),
   "harness.bind": v.object({
     threadId: SessionId,
@@ -481,6 +504,9 @@ export const ThreadRecordSchema = v.pipe(
     workingCopy: v.optional(v.string()),
     textCuts: v.optional(TextCutsSchema),
     viewedPaths: v.optional(v.array(v.string())),
+    messageOperations: v.optional(
+      v.array(v.object({ operationId: NonEmpty, fingerprint: NonEmpty, result: MessageSchema })),
+    ),
     message: v.nullable(MessageSchema),
     status: v.picklist(["pending", "resolved"]),
     createdAt: v.string(),

package/src/vcs-source.ts

@@ -114,6 +114,7 @@ export class VcsSourceManager {
 
     for (const path of paths) {
       const absolute = isAbsolute(path) ? path : resolve(dirname(this.userConfigPath), path);
+
       await this.loadAdapterExtension(absolute);
     }
     const discovery = discoverInstalledExtensionPackages(this.installRoot);

package/src/working-tree.ts

@@ -15,6 +15,7 @@ async function git(args: string[], cwd: string): Promise<string | null> {
 /** Map a `git diff --name-status` letter to a diff status; renames/copies read as modified. */
 function statusFromCode(code: string): DiffFileStatus {
   const letter = code.charAt(0);
+
   if (letter === "D") return "deleted";
   if (letter === "A") return "added";
 
@@ -35,6 +36,7 @@ export async function workingChangeList(
   for (const line of tracked.split("\n")) {
     if (line.trim().length === 0) continue;
     const parts = line.split("\t");
+
     // a rename is "R100<tab>old<tab>new"; the new path (last field) is what the reviewer opens
     changes.push({ path: parts[parts.length - 1]!, status: statusFromCode(parts[0]!) });
   }