@cueloop/daemon 0.1.0-alpha.59 → 0.1.0-alpha.60

package/src/server.ts

@@ -73,16 +73,20 @@ export class DaemonServer {
   private acquireLock(): boolean {
     if (HELD_HOMES.has(this.home)) return false; // another instance here owns it
     const path = lockPath(this.home);
+
     for (let attempt = 0; attempt < 3; attempt++) {
       try {
         // "wx" fails when the file exists - the atomic part of the handshake
         const fd = openSync(path, "wx");
+
         writeFileSync(fd, String(process.pid));
         this.lockFd = fd;
         HELD_HOMES.add(this.home);
+
         return true;
       } catch {
         let ownerPid = 0;
+
         try {
           ownerPid = Number(readFileSync(path, "utf8").trim());
         } catch {
@@ -92,6 +96,7 @@ export class DaemonServer {
         if (ownerPid && ownerPid !== process.pid) {
           try {
             process.kill(ownerPid, 0); // throws when the pid is gone
+
             return false; // a live daemon owns this home
           } catch {
             // stale lock from a crashed daemon
@@ -106,6 +111,7 @@ export class DaemonServer {
         }
       }
     }
+
     return false;
   }
 
@@ -129,6 +135,7 @@ export class DaemonServer {
   start(): string | null {
     if (!this.acquireLock()) return null;
     const path = socketPath(this.home);
+
     // safe now: holding the lock means no live daemon owns this home, so any
     // socket file left behind is stale
     if (existsSync(path)) rmSync(path, { force: true });
@@ -146,6 +153,7 @@ export class DaemonServer {
             subscribed: false,
             role: "owner",
           };
+
           socket.data = { buffer: new LineBuffer(), connection, writer };
           this.connections.add(connection);
           this.scheduleIdleCheck();
@@ -170,6 +178,7 @@ export class DaemonServer {
     chmodSync(path, 0o600);
     writeFileSync(pidPath(this.home), String(process.pid));
     this.scheduleIdleCheck();
+
     return path;
   }
 
@@ -185,6 +194,7 @@ export class DaemonServer {
 
   private broadcast(event: DaemonEvent): void {
     const frame = JSON.stringify(event) + "\n";
+
     for (const connection of this.connections) if (connection.subscribed) connection.write(frame);
     this.scheduleIdleCheck();
   }
@@ -205,6 +215,7 @@ export class DaemonServer {
 
   private async respondToRequestLine(connection: Connection, line: string): Promise<void> {
     let request: Request;
+
     try {
       request = JSON.parse(line) as Request;
     } catch {
@@ -212,14 +223,17 @@ export class DaemonServer {
         JSON.stringify({ id: -1, error: { code: "bad_json", message: "unparseable request" } }) +
           "\n",
       );
+
       return;
     }
     try {
       const result = await this.dispatch(connection, request);
+
       connection.write(JSON.stringify({ id: request.id, result }) + "\n");
     } catch (err) {
       const code = err instanceof DaemonError ? err.code : "internal";
       const message = err instanceof Error ? err.message : String(err);
+
       connection.write(JSON.stringify({ id: request.id, error: { code, message } }) + "\n");
     }
   }
@@ -228,6 +242,7 @@ export class DaemonServer {
     "daemon.ping": () => ({ pid: process.pid }),
     "daemon.hello": (connection, request) => {
       connection.role = parseParams("daemon.hello", request.params).role;
+
       return {};
     },
     "daemon.shutdown": () => {
@@ -235,14 +250,17 @@ export class DaemonServer {
         this.stop();
         this.onIdleExit();
       }, 10);
+
       return {};
     },
     "events.subscribe": (connection) => {
       connection.subscribed = true;
+
       return {};
     },
     "session.create": (_connection, request) => {
       const params = parseParams("session.create", request.params);
+
       return this.core.sessionCreate({ workspace: params.workspace, artifact: params.artifact });
     },
     "session.get": (_connection, request) =>
@@ -251,38 +269,47 @@ export class DaemonServer {
       this.core.sessionList(parseParams("session.list", request.params).filter),
     "session.wait": (_connection, request) => {
       const params = parseParams("session.wait", request.params);
+
       return this.core.sessionWait(params.id, params.timeoutMs);
     },
     "session.annotate": (_connection, request) => {
       const params = parseParams("session.annotate", request.params);
+
       return this.core.sessionAnnotate(params.id, params.annotation, params.authorName);
     },
     "session.removeAnnotation": (_connection, request) => {
       const params = parseParams("session.removeAnnotation", request.params);
+
       return this.core.sessionRemoveAnnotation(params.id, params.annotationId);
     },
     "session.setWorkingCopy": (_connection, request) => {
       const params = parseParams("session.setWorkingCopy", request.params);
+
       return this.core.sessionSetWorkingCopy(params.id, params.workingCopy);
     },
     "session.setViewed": (_connection, request) => {
       const params = parseParams("session.setViewed", request.params);
+
       return this.core.sessionSetViewed(params.id, params.viewedPaths);
     },
     "session.refreshDiff": (_connection, request) => {
       const params = parseParams("session.refreshDiff", request.params);
+
       return this.core.sessionRefreshDiff(params.id);
     },
     "session.setShareId": (_connection, request) => {
       const params = parseParams("session.setShareId", request.params);
+
       return this.core.sessionSetShareId(params.id, params.shareId);
     },
     "session.delete": (_connection, request) => {
       this.core.sessionDelete(parseParams("session.delete", request.params).id);
+
       return {};
     },
     "session.mergeShared": (_connection, request) => {
       const params = parseParams("session.mergeShared", request.params);
+
       return this.core.sessionMergeShared(params.id, {
         annotations: params.annotations,
         participants: params.participants,
@@ -290,10 +317,12 @@ export class DaemonServer {
     },
     "session.resolve": (_connection, request) => {
       const params = parseParams("session.resolve", request.params);
+
       return this.core.sessionResolve(params.id, params.verdictKind, params.summary);
     },
     "session.submitRevision": (_connection, request) => {
       const params = parseParams("session.submitRevision", request.params);
+
       return this.core.sessionSubmitRevision(
         params.id,
         params.content,
@@ -304,7 +333,9 @@ export class DaemonServer {
       this.core.herdrGetTab(parseParams("herdr.getTab", request.params).id),
     "herdr.setTab": (_connection, request) => {
       const params = parseParams("herdr.setTab", request.params);
+
       this.core.herdrSetTab(params.id, { tabId: params.tabId, paneId: params.paneId });
+
       return {};
     },
   };
@@ -322,6 +353,7 @@ export class DaemonServer {
     if (!Object.hasOwn(this.handlers, request.method)) {
       throw new DaemonError("unknown_method", `unknown method ${request.method}`);
     }
+
     return this.handlers[request.method](connection, request);
   }
 }

package/src/share-blob.ts

@@ -31,6 +31,7 @@ export function packSessionBlob(session: ReviewSession): Buffer {
 /** Decompress + validate an uploaded blob, or throw a precise reason. */
 export function unpackSessionBlob(bytes: Uint8Array): ReviewSession {
   let json: string;
+
   try {
     json = gunzipSync(bytes, { maxOutputLength: MAX_BLOB_BYTES }).toString("utf8");
   } catch (err) {
@@ -40,12 +41,15 @@ export function unpackSessionBlob(bytes: Uint8Array): ReviewSession {
     );
   }
   let raw: unknown;
+
   try {
     raw = JSON.parse(json);
   } catch {
     throw new Error("blob is not valid JSON");
   }
   const parsed = validateSessionRecord(raw);
+
   if (!parsed.ok) throw new Error(`blob is not a valid session: ${parsed.error}`);
+
   return parsed.value as ReviewSession;
 }

package/src/single-instance.test.ts

@@ -29,7 +29,9 @@ afterEach(() => {
 
 function server(): DaemonServer {
   const daemonServer = new DaemonServer({ home, idleExitMs: 0 });
+
   servers.push(daemonServer);
+
   return daemonServer;
 }
 
@@ -38,6 +40,7 @@ describe("one daemon per home", () => {
     // Arrange
     const first = server();
     const path = first.start();
+
     expect(path).toBe(socketPath(home));
     const second = server();
 
@@ -50,8 +53,10 @@ describe("one daemon per home", () => {
   test("clients keep talking to the one live daemon after a refused start", async () => {
     // Arrange
     const first = server();
+
     first.start();
     const created = first.core.sessionCreate({ workspace: WS, artifact: PLAN });
+
     server().start(); // refused
     const client = await DaemonClient.connect({ home });
 
@@ -79,6 +84,7 @@ describe("one daemon per home", () => {
   test("stopping releases the lock so a restart works", () => {
     // Arrange
     const first = server();
+
     first.start();
 
     // Act
@@ -87,6 +93,7 @@ describe("one daemon per home", () => {
     // Assert
     expect(existsSync(lockPath(home))).toBe(false);
     const second = server();
+
     expect(second.start()).toBe(socketPath(home));
   });
 
@@ -103,14 +110,17 @@ describe("one daemon per home", () => {
     try {
       const pids = await Promise.all(clients.map((client) => client.ping()));
       const unique = new Set(pids.map((ping) => ping.pid));
+
       expect(unique.size).toBe(1);
       // and state is shared: one client's session is visible to the others
       const session = await clients[0]!.sessionCreate(WS, PLAN);
+
       expect((await clients[2]!.sessionGet(session.id)).id).toBe(session.id);
     } finally {
       for (const c of clients) c.close();
       // the autostarted daemon is not one of `servers` - shut it down
       const admin = await DaemonClient.connect({ home });
+
       await admin.shutdown();
       admin.close();
     }

package/src/store.ts

@@ -28,19 +28,23 @@ export class SessionStore {
   /** Read-only scan of the state directory; called once on boot. */
   recover(): RecoveryReport {
     const report: RecoveryReport = { recovered: [], skipped: [] };
+
     for (const file of readdirSync(this.dir)) {
       if (!file.endsWith(".json")) continue;
       try {
         const raw = readFileSync(join(this.dir, file), "utf8");
         const parsed = validateSessionRecord(JSON.parse(raw));
+
         if (!parsed.ok) throw new Error(`invalid record - ${parsed.error}`);
         const session = parsed.value as ReviewSession;
+
         this.sessions.set(session.id, session);
         report.recovered.push(session.id);
       } catch (err) {
         report.skipped.push({ file, error: err instanceof Error ? err.message : String(err) });
       }
     }
+
     return report;
   }
 
@@ -58,6 +62,7 @@ export class SessionStore {
     this.sessions.set(session.id, session);
     const path = join(this.dir, `${session.id}.json`);
     const tempPath = path + ".tmp";
+
     writeFileSync(tempPath, JSON.stringify(session, null, 2));
     renameSync(tempPath, path);
   }
@@ -65,6 +70,7 @@ export class SessionStore {
   delete(id: string): boolean {
     if (!this.sessions.delete(id)) return false;
     rmSync(join(this.dir, `${id}.json`), { force: true });
+
     return true;
   }
 }

package/src/validate.test.ts

@@ -61,6 +61,15 @@ describe("parseParams", () => {
     }
   });
 
+  test("accepts the reply artifact type", () => {
+    const params = parseParams("session.create", {
+      workspace: { repoRoot: "/repo", branch: "main" },
+      artifact: { type: "reply", content: "# R" },
+    });
+
+    expect(params.artifact.type).toBe("reply");
+  });
+
   test("rejects an unknown artifact type", () => {
     expect(() =>
       parseParams("session.create", {
@@ -236,6 +245,7 @@ describe("wire pins", () => {
     expect(entryKeys(AnchorSchema)).toEqual(keys(fullAnchor));
     // wire annotations arrive without createdAt; the daemon stamps it
     const { createdAt: _stamped, ...wireAnnotation } = fullAnnotation;
+
     expect(entryKeys(AnnotationSchema)).toEqual(keys(wireAnnotation));
     expect(entryKeys(RevisionSchema)).toEqual(keys(fullRevision));
     expect(entryKeys(VerdictSchema)).toEqual(keys(fullVerdict));
@@ -243,11 +253,13 @@ describe("wire pins", () => {
     expect(entryKeys(SessionRecordSchema)).toEqual(keys(fullSession));
     // persisted annotations carry the stamped createdAt
     const stored = SessionRecordSchema.entries.annotations.item;
+
     expect(entryKeys(stored)).toEqual(keys(fullAnnotation));
   });
 
   test("a fully-populated meta survives validation and DaemonCore unchanged", () => {
     const home = mkdtempSync(join(tmpdir(), "cueloop-val-"));
+
     try {
       // Arrange
       const params = parseParams("session.create", {

package/src/validate.ts

@@ -60,7 +60,7 @@ export const DiffFileContentsSchema = v.object({
 } satisfies EntriesOf<DiffFileContents>);
 
 export const ArtifactSchema = v.object({
-  type: v.picklist(["plan", "diff", "prototype"]),
+  type: v.picklist(["plan", "diff", "prototype", "reply"]),
   content: v.string(),
   meta: v.optional(ArtifactMetaSchema, {}),
   files: v.optional(v.array(DiffFileContentsSchema)),
@@ -175,14 +175,17 @@ export function parseParams<M extends MethodName>(
   params: unknown,
 ): v.InferOutput<(typeof Params)[M]> {
   const result = v.safeParse(Params[method], params ?? {});
+
   if (!result.success) {
     const issue = result.issues[0]!;
     const path = issue.path?.map((pathSegment) => String(pathSegment.key)).join(".") ?? "";
+
     throw new DaemonError(
       "invalid_params",
       `${method}: ${path ? path + " - " : ""}${issue.message}`,
     );
   }
+
   return result.output;
 }
 
@@ -221,8 +224,10 @@ export function validateSessionRecord(
   raw: unknown,
 ): { ok: true; value: v.InferOutput<typeof SessionRecordSchema> } | { ok: false; error: string } {
   const result = v.safeParse(SessionRecordSchema, raw);
+
   if (result.success) return { ok: true, value: result.output };
   const issue = result.issues[0]!;
   const path = issue.path?.map((pathSegment) => String(pathSegment.key)).join(".") ?? "";
+
   return { ok: false, error: `${path ? path + ": " : ""}${issue.message}` };
 }

package/src/working-tree.ts

@@ -6,7 +6,9 @@ import type { DiffFileContents } from "@cueloop/schema";
 async function git(args: string[], cwd: string): Promise<string | null> {
   const gitProcess = Bun.spawn(["git", ...args], { cwd, stdout: "pipe", stderr: "ignore" });
   const stdout = await new Response(gitProcess.stdout).text();
+
   if ((await gitProcess.exited) !== 0) return null;
+
   return stdout.trim();
 }
 
@@ -18,6 +20,7 @@ async function headContents(path: string, cwd: string): Promise<string> {
     stderr: "ignore",
   });
   const stdout = await new Response(gitProcess.stdout).text();
+
   return (await gitProcess.exited) === 0 ? stdout : "";
 }
 
@@ -35,6 +38,7 @@ function looksBinary(text: string): boolean {
   for (let index = 0; index < text.length; index++) {
     if (text.charCodeAt(index) === 0) return true;
   }
+
   return false;
 }
 
@@ -51,8 +55,10 @@ async function trackedFileContents(cwd: string): Promise<DiffFileContents[]> {
   const tokens = nameStatus.split("\0").filter((token) => token.length > 0);
   const files: DiffFileContents[] = [];
   let cursor = 0;
+
   while (cursor < tokens.length) {
     const code = tokens[cursor++]![0];
+
     if (code === "R" || code === "C") {
       cursor += 2;
       continue;
@@ -60,10 +66,13 @@ async function trackedFileContents(cwd: string): Promise<DiffFileContents[]> {
     const path = tokens[cursor++]!;
     const oldContents = code === "A" ? "" : await headContents(path, cwd);
     const newContents = code === "D" ? "" : await workingContents(path, cwd);
+
     if (looksBinary(oldContents) || looksBinary(newContents)) continue;
     const status = code === "A" ? "added" : code === "D" ? "deleted" : "modified";
+
     files.push({ path, oldContents, newContents, status });
   }
+
   return files;
 }
 
@@ -79,6 +88,7 @@ export async function workingTreeDiff(cwd = process.cwd()): Promise<WorkingTreeD
   // untracked files included by default
   const untrackedList = (await git(["ls-files", "--others", "--exclude-standard"], cwd)) ?? "";
   let untracked = "";
+
   for (const file of untrackedList.split("\n").filter(Boolean)) {
     // `git diff --no-index` exits 1 when the files differ - that is success here
     const gitProcess = Bun.spawn(["git", "diff", "--no-index", "--", "/dev/null", file], {
@@ -88,13 +98,16 @@ export async function workingTreeDiff(cwd = process.cwd()): Promise<WorkingTreeD
     });
     const stdout = await new Response(gitProcess.stdout).text();
     const code = await gitProcess.exited;
+
     if ((code === 0 || code === 1) && stdout.trim()) {
       untracked += stdout.trim() + "\n";
       const newContents = await workingContents(file, cwd);
+
       if (!looksBinary(newContents)) {
         files.push({ path: file, oldContents: "", newContents, status: "added" });
       }
     }
   }
+
   return { patch: [tracked, untracked].filter(Boolean).join("\n"), files };
 }