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

package/src/client.ts

@@ -57,7 +57,11 @@ import {
   PendingDeliverySchema,
 } from "./validate";
 import type { WorkingTreeDiff } from "./working-tree";
+import { DaemonTransportError, type DaemonRequestOptions } from "./client-errors";
+export { DaemonTransportError, type DaemonRequestOptions } from "./client-errors";
 import { DAEMON_VERSION } from "./version";
+import { ThreadAgentSchema } from "./thread-agent-validation";
+import type { AgentComment, ThreadAgentState, AgentPromptRequest } from "@cueloop/schema";
 
 export type { EventFrame } from "./protocol";
 
@@ -101,6 +105,8 @@ export interface ThreadClient {
   onEvent(listener: (event: EventFrame) => void): () => void;
   subscribe(): Promise<void>;
   sessionGet(id: string): Promise<Thread>;
+  /** Create a local owner Thread; shared clients omit this capability. */
+  sessionCreate?(workspace: WorkspaceKey, artifact: Artifact): Promise<Thread>;
   sessionList(filter?: { status?: "pending" | "resolved" }): Promise<Thread[]>;
   /** Add a comment; the primary annotate method. `sessionAnnotate` is the retained alias. */
   sessionComment(
@@ -222,7 +228,8 @@ export class DaemonClient implements ThreadClient {
   private daemonVersion: string | undefined;
   private nextId = 1;
   private eventListeners = new Set<(event: EventFrame) => void>();
-  private disconnectListeners = new Set<() => void>();
+  private disconnectListeners = new Set<(reason: DaemonTransportError) => void>();
+  private disconnectReason: DaemonTransportError | undefined;
   private closed = false;
   private role: DaemonRole = "owner";
   private author: string | undefined;
@@ -251,7 +258,15 @@ export class DaemonClient implements ThreadClient {
       if (!options.autostart || err instanceof DaemonClientError) {
         client.close();
 
-        throw err;
+        throw err instanceof DaemonClientError || err instanceof DaemonTransportError
+          ? err
+          : new DaemonTransportError(
+              "connection",
+              "Daemon connection failed",
+              "not_sent",
+              undefined,
+              { cause: err },
+            );
       }
     }
 
@@ -266,7 +281,9 @@ export class DaemonClient implements ThreadClient {
     this.writer = null;
     this.closed = false;
     for (const pendingRequest of this.pending.values())
-      pendingRequest.reject(new Error("daemon connection replaced"));
+      pendingRequest.reject(
+        new DaemonTransportError("connection", "daemon connection replaced", "unknown"),
+      );
     this.pending.clear();
   }
 
@@ -306,7 +323,11 @@ export class DaemonClient implements ThreadClient {
       const output = readFileSync(startupLogPath, "utf8").trim();
       const detail = output ? `\ndaemon startup output:\n${output.slice(-4_096)}` : "";
 
-      throw new Error(`daemon did not come up at ${path}: ${String(lastError)}${detail}`);
+      throw new DaemonTransportError(
+        "connection",
+        `Daemon startup failed at ${path}: ${String(lastError)}${detail}`,
+        "not_sent",
+      );
     } finally {
       rmSync(startupLogPath, { force: true });
     }
@@ -314,15 +335,23 @@ export class DaemonClient implements ThreadClient {
 
   private async dial(path: string): Promise<void> {
     const buffer = new LineBuffer();
+
+    this.disconnectReason = undefined;
     const epoch = ++this.connectionEpoch;
 
     const close = () => {
       if (this.connectionEpoch !== epoch) return;
       this.closed = true;
       for (const pendingRequest of this.pending.values())
-        pendingRequest.reject(new Error("daemon connection closed"));
+        pendingRequest.reject(
+          new DaemonTransportError("connection", "daemon connection closed", "unknown"),
+        );
       this.pending.clear();
-      for (const listener of this.disconnectListeners) listener();
+      const reason =
+        this.disconnectReason ??
+        new DaemonTransportError("connection", "daemon connection closed", "unknown");
+
+      for (const listener of this.disconnectListeners) listener(reason);
     };
 
     if (typeof Bun !== "undefined") {
@@ -395,7 +424,7 @@ export class DaemonClient implements ThreadClient {
   }
 
   /** Notify an adapter when its daemon socket closes so it can reconnect and replay Messages. */
-  onDisconnect(listener: () => void): () => void {
+  onDisconnect(listener: (reason: DaemonTransportError) => void): () => void {
     this.disconnectListeners.add(listener);
 
     return () => this.disconnectListeners.delete(listener);
@@ -406,7 +435,27 @@ export class DaemonClient implements ThreadClient {
 
     try {
       frame = parseInboundFrame(line);
-    } catch {
+    } catch (cause) {
+      this.disconnectReason = new DaemonTransportError(
+        "protocol",
+        "daemon sent a malformed frame",
+        "unknown",
+        undefined,
+        { cause },
+      );
+      for (const pendingRequest of this.pending.values())
+        pendingRequest.reject(
+          new DaemonTransportError(
+            "protocol",
+            "daemon sent a malformed frame",
+            "unknown",
+            undefined,
+            { cause },
+          ),
+        );
+      this.pending.clear();
+      this.close();
+
       return;
     }
     if ("event" in frame) {
@@ -427,37 +476,135 @@ export class DaemonClient implements ThreadClient {
     method: string,
     params: Request["params"],
     resultSchema: v.GenericSchema<unknown, TOutput>,
-    timeoutMs = 30_000,
+    options: number | DaemonRequestOptions = 30_000,
   ): Promise<TOutput> {
-    if (this.closed || !this.socket) return Promise.reject(new Error("not connected"));
+    const { timeoutMs = 30_000, signal } = v.is(v.number(), options)
+      ? { timeoutMs: options }
+      : options;
+
+    if (signal?.aborted)
+      return Promise.reject(
+        new DaemonTransportError("cancelled", `request ${method} cancelled`, "not_sent", method),
+      );
+    if (this.closed || !this.socket)
+      return Promise.reject(
+        new DaemonTransportError("connection", "not connected", "not_sent", method),
+      );
     const id = this.nextId++;
 
     return new Promise<TOutput>((resolve, reject) => {
-      const timer = setTimeout(() => {
+      const cleanup = () => {
+        clearTimeout(timer);
+        signal?.removeEventListener("abort", abort);
         this.pending.delete(id);
-        reject(new Error(`request ${method} timed out`));
+      };
+      const fail = (error: Error) => {
+        cleanup();
+        reject(error);
+      };
+      const abort = () =>
+        fail(
+          new DaemonTransportError("cancelled", `request ${method} cancelled`, "unknown", method),
+        );
+      const timer = setTimeout(() => {
+        fail(new DaemonTransportError("timeout", `request ${method} timed out`, "unknown", method));
       }, timeoutMs);
 
       this.pending.set(id, {
         resolve: (value) => {
-          clearTimeout(timer);
-          resolve(v.parse(resultSchema, value));
-        },
-        reject: (error) => {
-          clearTimeout(timer);
-          reject(error);
+          cleanup();
+          try {
+            const parsed = v.safeParse(resultSchema, value);
+
+            if (!parsed.success)
+              throw new DaemonTransportError(
+                "protocol",
+                `request ${method} returned an invalid result`,
+                "unknown",
+                method,
+                { cause: parsed.issues },
+              );
+            resolve(parsed.output);
+          } catch (cause) {
+            reject(
+              cause instanceof DaemonTransportError
+                ? cause
+                : new DaemonTransportError(
+                    "protocol",
+                    `request ${method} returned an invalid result`,
+                    "unknown",
+                    method,
+                    { cause },
+                  ),
+            );
+          }
         },
+        reject: fail,
       });
-      this.writer!.write(JSON.stringify({ id, method, params }) + "\n");
+      signal?.addEventListener("abort", abort, { once: true });
+      try {
+        this.writer!.write(JSON.stringify({ id, method, params }) + "\n");
+      } catch (cause) {
+        fail(
+          new DaemonTransportError(
+            "connection",
+            `request ${method} could not be written`,
+            "unknown",
+            method,
+            { cause },
+          ),
+        );
+      }
     });
   }
 
   close(): void {
     this.closed = true;
+    for (const pendingRequest of this.pending.values())
+      pendingRequest.reject(
+        new DaemonTransportError("connection", "daemon connection closed", "unknown"),
+      );
+    this.pending.clear();
     this.socket?.end();
   }
 
   // ── typed primitives ─────────────────────────────
+  /** Read the agent transcript without starting a model request. */
+  agentGet(id: string, options?: DaemonRequestOptions): Promise<ThreadAgentState> {
+    return this.request("agent.get", { id }, ThreadAgentSchema, options);
+  }
+  /** Submit a question and optional selected passage to the daemon-owned agent. */
+  agentPrompt(
+    params: AgentPromptRequest,
+    options?: DaemonRequestOptions,
+  ): Promise<ThreadAgentState> {
+    return this.request("agent.prompt", params, ThreadAgentSchema, options);
+  }
+  /** Cancel the active turn; the daemon retains partial output. */
+  agentCancel(id: string): Promise<ThreadAgentState> {
+    return this.request("agent.cancel", { id }, ThreadAgentSchema);
+  }
+  /** Save quote-primary feedback on a finalized agent answer. */
+  agentComment(params: { id: string; comment: AgentComment }): Promise<ThreadAgentState> {
+    return this.request("agent.comment", params, ThreadAgentSchema);
+  }
+  /** Configure only an option advertised by the current harness. */
+  agentConfigure(params: {
+    id: string;
+    configId?: string;
+    value?: string;
+  }): Promise<ThreadAgentState> {
+    return this.request("agent.configure", params, ThreadAgentSchema);
+  }
+
+  /** Select an option from the active agent permission card. */
+  agentPermission(params: {
+    id: string;
+    requestId: string;
+    optionId: string;
+  }): Promise<ThreadAgentState> {
+    return this.request("agent.permission", params, ThreadAgentSchema);
+  }
   ping(): Promise<{ pid: number }> {
     return this.request("daemon.ping", {}, PingResultSchema);
   }
@@ -639,11 +786,14 @@ export class DaemonClient implements ThreadClient {
     outcome: MessageOutcome,
     summary: string,
     actionBodies?: Record<string, string>,
+    operationId?: string,
+    options?: DaemonRequestOptions,
   ): Promise<Thread> {
     return this.request(
       "session.sendMessage",
-      { id, outcome, summary, actionBodies },
+      { id, outcome, summary, actionBodies, operationId },
       ThreadRecordSchema,
+      options,
     );
   }
   harnessBind(
@@ -722,6 +872,7 @@ export class DaemonClient implements ThreadClient {
 }
 
 export class DaemonClientError extends Error {
+  readonly _tag = "DaemonClientError";
   constructor(
     readonly code: string,
     message: string,
@@ -731,7 +882,7 @@ export class DaemonClientError extends Error {
 }
 
 // A compiled binary re-execs `cueloop daemon --autostart` (idle-exits like main.ts,
-// unlike the never-exiting foreground daemon); from source, bun runs main.ts. In
+// unlike the never-exiting foreground daemon); source also uses the CLI composition root. In
 // dev (CUELOOP_DEV_WATCH=1, source only) it runs under --watch so daemon-code edits
 // reload the daemon without a manual restart - the version handshake only catches
 // release upgrades, not same-version source changes.
@@ -739,14 +890,19 @@ export function daemonSpawnCommand(
   execPath: string,
   moduleUrl: string,
   devWatch = process.env.CUELOOP_DEV_WATCH === "1",
+  entry = process.env.CUELOOP_DAEMON_ENTRY,
 ): string[] {
   const compiled =
     moduleUrl.includes("$bunfs") || moduleUrl.includes("~BUN") || moduleUrl.includes("%7EBUN");
 
   if (compiled) return [execPath, "daemon", "--autostart"];
-  const mainPath = new URL("./main.ts", moduleUrl).pathname;
+  const mainPath = entry ?? new URL("./main.ts", moduleUrl).pathname;
+
+  const args = entry ? ["daemon", "--autostart"] : [];
 
-  return devWatch ? [execPath, "--watch", "run", mainPath] : [execPath, "run", mainPath];
+  return devWatch
+    ? [execPath, "--watch", "run", mainPath, ...args]
+    : [execPath, "run", mainPath, ...args];
 }
 
 function spawnDaemon(home: string): string {

package/src/daemon-sdk-effect.ts

@@ -0,0 +1,113 @@
+import { Context, Effect, Layer, Stream, Queue, Cause, type Scope } from "effect";
+import {
+  connectOwnerSdk,
+  normalizeSdkError,
+  type OwnerDaemonSdk,
+  type DaemonSdkError,
+  type SdkThread,
+  type SdkThreadId,
+} from "./daemon-sdk";
+import type { ConnectOptions } from "./client";
+import type { DaemonRequestOptions } from "./client-errors";
+
+type EffectMethods<Methods> = {
+  readonly [Key in keyof Methods]: Methods[Key] extends (
+    ...args: infer Arguments
+  ) => Promise<infer Result>
+    ? (...args: Arguments) => Effect.Effect<Result, DaemonSdkError>
+    : never;
+};
+
+/** The Effect service owns a scoped connection while daemon-owned work outlives local waits. */
+export class CueloopSdk extends Context.Service<
+  CueloopSdk,
+  {
+    readonly ids: OwnerDaemonSdk["ids"];
+    readonly threads: EffectMethods<OwnerDaemonSdk["threads"]> & {
+      watch(threadId: SdkThreadId): Stream.Stream<SdkThread, DaemonSdkError>;
+    };
+    readonly comments: EffectMethods<OwnerDaemonSdk["comments"]>;
+    readonly sessions: EffectMethods<OwnerDaemonSdk["sessions"]>;
+    readonly agents: EffectMethods<OwnerDaemonSdk["agents"]>;
+  }
+>()("@cueloop/daemon/CueloopSdk") {
+  static ownerLayer(
+    options: Omit<ConnectOptions, "role"> = {},
+  ): Layer.Layer<CueloopSdk, DaemonSdkError> {
+    return Layer.effect(CueloopSdk, acquireOwnerSdk(options).pipe(Effect.map(effectSdkService)));
+  }
+}
+
+function acquireOwnerSdk(
+  options: Omit<ConnectOptions, "role">,
+): Effect.Effect<OwnerDaemonSdk, DaemonSdkError, Scope.Scope> {
+  return Effect.acquireRelease(
+    Effect.tryPromise({ try: () => connectOwnerSdk(options), catch: normalizeSdkError }),
+    (sdk) => Effect.sync(() => sdk.close()),
+  );
+}
+
+function sdkEffect<Result>(
+  request: (options: DaemonRequestOptions) => Promise<Result>,
+  options?: DaemonRequestOptions,
+): Effect.Effect<Result, DaemonSdkError> {
+  return Effect.tryPromise({
+    try: (signal) =>
+      request({
+        ...options,
+        signal: options?.signal ? AbortSignal.any([signal, options.signal]) : signal,
+      }),
+    catch: normalizeSdkError,
+  });
+}
+
+function effectSdkService(sdk: OwnerDaemonSdk): CueloopSdk["Service"] {
+  return {
+    ids: sdk.ids,
+    threads: {
+      watch: (threadId) =>
+        Stream.callback<SdkThread, DaemonSdkError>(
+          Effect.fn(function* (queue) {
+            yield* Effect.acquireRelease(
+              Effect.sync(() =>
+                sdk.observeThread({
+                  threadId,
+                  onValue: (thread) => {
+                    Queue.offerUnsafe(queue, thread);
+                  },
+                  onError: (error) => {
+                    if (error._tag === "DaemonClientError" || error.kind === "protocol")
+                      Queue.failCauseUnsafe(queue, Cause.fail(error));
+                  },
+                }),
+              ),
+              (stop) => Effect.sync(stop),
+            );
+          }),
+          { bufferSize: 1, strategy: "sliding" },
+        ),
+      get: (id, options) => sdkEffect((request) => sdk.threads.get(id, request), options),
+      create: (input, options) =>
+        sdkEffect((request) => sdk.threads.create(input, request), options),
+    },
+    comments: {
+      add: (input, options) => sdkEffect((request) => sdk.comments.add(input, request), options),
+      list: (id, options) => sdkEffect((request) => sdk.comments.list(id, request), options),
+      reply: (input, options) =>
+        sdkEffect((request) => sdk.comments.reply(input, request), options),
+    },
+    sessions: {
+      sendMessage: (input, options) =>
+        sdkEffect((request) => sdk.sessions.sendMessage(input, request), options),
+    },
+    agents: {
+      get: (id, options) => sdkEffect((request) => sdk.agents.get(id, request), options),
+      prompt: (input, options) =>
+        sdkEffect((request) => sdk.agents.prompt(input, request), options),
+      replyToComment: (input, options) =>
+        sdkEffect((request) => sdk.agents.replyToComment(input, request), options),
+      wait: (input, options) => sdkEffect((request) => sdk.agents.wait(input, request), options),
+      cancel: (id, options) => sdkEffect((request) => sdk.agents.cancel(id, request), options),
+    },
+  };
+}