@cueloop/daemon 0.1.0-alpha.8 → 0.1.0-alpha.81

package/src/thread-surface-config.test.ts

@@ -0,0 +1,63 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { loadGhosttyThreadSurface, loadHerdrThreadSurface } from "./thread-surface-config";
+
+let dir: string;
+let userPath: string;
+
+beforeEach(() => {
+  dir = mkdtempSync(join(tmpdir(), "cueloop-herdr-config-"));
+  userPath = join(dir, "user.toml");
+});
+
+describe("personal Ghostty Thread surface config", () => {
+  test("defaults to tab and accepts pane, window, or none", () => {
+    expect(loadGhosttyThreadSurface(userPath)).toBe("tab");
+
+    for (const mode of ["pane", "window", "none"] as const) {
+      writeFileSync(userPath, `[integrations.ghostty]\nthread_surface = "${mode}"\n`);
+      expect(loadGhosttyThreadSurface(userPath)).toBe(mode);
+    }
+
+    writeFileSync(userPath, '[integrations.ghostty]\nthread_surface = "invalid"\n');
+    expect(loadGhosttyThreadSurface(userPath)).toBe("tab");
+  });
+
+  test("ignores repository config", () => {
+    const repoConfig = join(dir, "repo", ".cueloop", "config.toml");
+
+    mkdirSync(join(dir, "repo", ".cueloop"), { recursive: true });
+    writeFileSync(userPath, '[integrations.ghostty]\nthread_surface = "window"\n');
+    writeFileSync(repoConfig, '[integrations.ghostty]\nthread_surface = "none"\n');
+
+    expect(loadGhosttyThreadSurface(userPath)).toBe("window");
+  });
+});
+
+afterEach(() => {
+  rmSync(dir, { recursive: true, force: true });
+});
+
+describe("personal Herdr Thread surface config", () => {
+  test("defaults to tab and accepts pane or none", () => {
+    expect(loadHerdrThreadSurface(userPath)).toBe("tab");
+    writeFileSync(userPath, '[integrations.herdr]\nthread_surface = "pane"\n');
+    expect(loadHerdrThreadSurface(userPath)).toBe("pane");
+    writeFileSync(userPath, '[integrations.herdr]\nthread_surface = "none"\n');
+    expect(loadHerdrThreadSurface(userPath)).toBe("none");
+    writeFileSync(userPath, '[integrations.herdr]\nthread_surface = "invalid"\n');
+    expect(loadHerdrThreadSurface(userPath)).toBe("tab");
+  });
+
+  test("never reads a repository's terminal automation setting", () => {
+    const repoConfig = join(dir, "repo", ".cueloop", "config.toml");
+
+    mkdirSync(join(dir, "repo", ".cueloop"), { recursive: true });
+    writeFileSync(userPath, '[integrations.herdr]\nthread_surface = "pane"\n');
+    writeFileSync(repoConfig, '[integrations.herdr]\nthread_surface = "none"\n');
+
+    expect(loadHerdrThreadSurface(userPath)).toBe("pane");
+  });
+});

package/src/thread-surface-config.ts

@@ -0,0 +1,61 @@
+import { existsSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { parse as parseToml } from "smol-toml";
+import * as v from "valibot";
+
+/** Placement of a cueloop Thread inside Herdr. */
+export type HerdrThreadSurface = "tab" | "pane" | "none";
+/** Placement of a cueloop Thread inside Ghostty. */
+export type GhosttyThreadSurface = "tab" | "pane" | "window" | "none";
+
+const PersonalThreadSurfaceSchema = v.object({
+  integrations: v.optional(
+    v.object({
+      herdr: v.optional(
+        v.object({
+          thread_surface: v.fallback(v.optional(v.picklist(["tab", "pane", "none"])), undefined),
+        }),
+      ),
+      ghostty: v.optional(
+        v.object({
+          thread_surface: v.fallback(
+            v.optional(v.picklist(["tab", "pane", "window", "none"])),
+            undefined,
+          ),
+        }),
+      ),
+    }),
+  ),
+});
+
+/** Read Herdr placement from the personal TOML file only; invalid values use the tab default. */
+export function loadHerdrThreadSurface(userConfigPath?: string): HerdrThreadSurface {
+  return (
+    loadPersonalThreadSurfaceConfig(userConfigPath)?.integrations?.herdr?.thread_surface ?? "tab"
+  );
+}
+
+/** Read Ghostty placement from the personal TOML file only. */
+export function loadGhosttyThreadSurface(userConfigPath?: string): GhosttyThreadSurface {
+  return (
+    loadPersonalThreadSurfaceConfig(userConfigPath)?.integrations?.ghostty?.thread_surface ?? "tab"
+  );
+}
+
+function loadPersonalThreadSurfaceConfig(userConfigPath?: string) {
+  const path =
+    userConfigPath ??
+    process.env.CUELOOP_CONFIG ??
+    join(process.env.XDG_CONFIG_HOME ?? join(homedir(), ".config"), "cueloop", "config.toml");
+
+  if (!existsSync(path)) return null;
+
+  try {
+    const parsed = v.safeParse(PersonalThreadSurfaceSchema, parseToml(readFileSync(path, "utf8")));
+
+    return parsed.success ? parsed.output : null;
+  } catch {
+    return null;
+  }
+}

package/src/validate.test.ts

@@ -1,4 +1,5 @@
 import { describe, expect, test } from "bun:test";
+import * as v from "valibot";
 import { mkdtempSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
@@ -9,23 +10,26 @@ import {
   AnnotationSchema,
   ArtifactMetaSchema,
   ArtifactSchema,
+  IdentitySchema,
   RevisionSchema,
-  SessionRecordSchema,
-  VerdictSchema,
+  ThreadRecordSchema,
+  MessageSchema,
   WorkspaceSchema,
   isKnownMethod,
   parseParams,
-  validateSessionRecord,
+  validateThreadRecord,
 } from "./validate";
 import {
+  ARTIFACT_TYPES,
   SCHEMA_VERSION,
   type Anchor,
   type Annotation,
   type Artifact,
   type ArtifactMeta,
-  type ReviewSession,
+  type Identity,
+  type Thread,
   type Revision,
-  type Verdict,
+  type Message,
   type WorkspaceKey,
 } from "@cueloop/schema";
 
@@ -38,11 +42,14 @@ describe("method allowlist", () => {
 
 describe("parseParams", () => {
   test("accepts a well-formed create and defaults meta", () => {
-    const p = parseParams("session.create", {
+    // Act
+    const params = parseParams("session.create", {
       workspace: { repoRoot: "/repo", branch: "main" },
       artifact: { type: "plan", content: "# P" },
     });
-    expect(p.artifact.meta).toEqual({});
+
+    // Assert
+    expect(params.artifact.meta).toEqual({});
   });
 
   test("rejects a missing workspace with a pathed message", () => {
@@ -51,8 +58,21 @@ describe("parseParams", () => {
       throw new Error("should have thrown");
     } catch (err) {
       expect(err).toBeInstanceOf(DaemonError);
-      expect((err as DaemonError).code).toBe("invalid_params");
-      expect((err as DaemonError).message).toContain("session.create: workspace");
+      if (err instanceof DaemonError) {
+        expect(err.code).toBe("invalid_params");
+        expect(err.message).toContain("session.create: workspace");
+      }
+    }
+  });
+
+  test("accepts every artifact type in the schema union", () => {
+    for (const type of ARTIFACT_TYPES) {
+      const params = parseParams("session.create", {
+        workspace: { repoRoot: "/repo", branch: "main" },
+        artifact: { type, content: "body" },
+      });
+
+      expect(params.artifact.type).toBe(type);
     }
   });
 
@@ -72,21 +92,40 @@ describe("parseParams", () => {
   test("defaults and clamps the wait timeout", () => {
     expect(parseParams("session.wait", { id: "ses_1" }).timeoutMs).toBe(60_000);
     expect(() => parseParams("session.wait", { id: "ses_1", timeoutMs: -5 })).toThrow();
-    expect(() => parseParams("session.wait", { id: "ses_1", timeoutMs: 99 * 60 * 60 * 1000 })).toThrow();
+    expect(() =>
+      parseParams("session.wait", { id: "ses_1", timeoutMs: 99 * 60 * 60 * 1000 }),
+    ).toThrow();
   });
 
-  test("verdict kinds are closed", () => {
-    expect(parseParams("session.resolve", { id: "s", verdictKind: "approve" }).summary).toBe("");
-    expect(() => parseParams("session.resolve", { id: "s", verdictKind: "lgtm" })).toThrow(/verdictKind/);
+  test("message kinds are closed", () => {
+    expect(parseParams("session.sendMessage", { id: "s", outcome: "approved" }).summary).toBe("");
+    expect(() => parseParams("session.sendMessage", { id: "s", outcome: "lgtm" })).toThrow(
+      /outcome/,
+    );
   });
 
   test("annotation kinds stay open (extension kinds are allowed)", () => {
-    const p = parseParams("session.annotate", {
+    // Act
+    const params = parseParams("session.annotate", {
       id: "s",
       annotation: { id: "a1", kind: "praise", anchor: { quote: "x" }, body: "nice" },
     });
-    expect(p.annotation.kind).toBe("praise");
-    expect(p.annotation.anchor.prefix).toBe("");
+
+    // Assert
+    expect(params.annotation.kind).toBe("praise");
+    expect(params.annotation.anchor.prefix).toBe("");
+  });
+
+  test("setViewed takes a full path list and rejects non-string entries", () => {
+    expect(
+      parseParams("session.setViewed", { id: "s", viewedPaths: ["src/a.ts", "src/b.ts"] })
+        .viewedPaths,
+    ).toEqual(["src/a.ts", "src/b.ts"]);
+    expect(parseParams("session.setViewed", { id: "s", viewedPaths: [] }).viewedPaths).toEqual([]);
+    expect(() => parseParams("session.setViewed", { id: "s", viewedPaths: [1] })).toThrow(
+      /viewedPaths/,
+    );
+    expect(() => parseParams("session.setViewed", { id: "s" })).toThrow(/viewedPaths/);
   });
 
   test("null params are treated as empty", () => {
@@ -94,7 +133,7 @@ describe("parseParams", () => {
   });
 });
 
-describe("validateSessionRecord", () => {
+describe("validateThreadRecord", () => {
   const record = {
     schemaVersion: SCHEMA_VERSION,
     id: "ses_1",
@@ -102,72 +141,185 @@ describe("validateSessionRecord", () => {
     artifact: { type: "plan", content: "# P", meta: {} },
     revisions: [{ revision: 1, content: "# P", submittedAt: "now" }],
     annotations: [],
-    verdict: null,
+    message: null,
     status: "pending",
     createdAt: "now",
   };
 
   test("accepts a valid record", () => {
-    expect(validateSessionRecord(record).ok).toBe(true);
+    expect(validateThreadRecord(record).ok).toBe(true);
   });
 
   test("rejects a foreign schema version with a readable reason", () => {
-    const r = validateSessionRecord({ ...record, schemaVersion: "99" });
-    expect(r.ok).toBe(false);
-    if (!r.ok) expect(r.error).toContain("schemaVersion");
+    // Act
+    const result = validateThreadRecord({ ...record, schemaVersion: "99" });
+
+    // Assert
+    expect(result.ok).toBe(false);
+    if (!result.ok) expect(result.error).toContain("schemaVersion");
   });
 
   test("rejects a structurally broken record", () => {
-    const r = validateSessionRecord({ ...record, revisions: "nope" });
-    expect(r.ok).toBe(false);
+    // Act
+    const result = validateThreadRecord({ ...record, revisions: "nope" });
+
+    // Assert
+    expect(result.ok).toBe(false);
   });
 });
 
 /**
- * Wire pins (#70): every schema's entries must cover exactly the keys of the
+ * Wire pins: every schema's entries must cover exactly the keys of the
  * schema type it mirrors. Runtime complement to the compile-time EntriesOf
  * check - the samples are fully populated and typed, so a new field in
  * @cueloop/schema shows up here too.
  */
 describe("wire pins", () => {
-  const keys = (o: object) => Object.keys(o).sort();
+  const keys = <Subject extends object>(subject: Subject) => Object.keys(subject).sort();
   const entryKeys = (schema: { entries: object }) => Object.keys(schema.entries).sort();
 
   const fullMeta: Required<ArtifactMeta> = {
+    workflow: "plan",
     cwd: "/repo",
     agent: "claude-code",
     agentSessionId: "sess-1",
     planPath: "/repo/plan.md",
+    prototypePath: "/repo/proto.html",
     pr: "org/repo#1",
     herdrPane: "%7",
     title: "Plan",
+    workbench: false,
+    snapshot: false,
+  };
+  const fullAnchor: Required<Anchor> = {
+    quote: "q",
+    prefix: "p",
+    suffix: "s",
+    blockIndex: 0,
+    endBlockIndex: 0,
+    start: 0,
+    end: 1,
+    selector: "div.card",
   };
-  const fullAnchor: Required<Anchor> = { quote: "q", prefix: "p", suffix: "s", blockIndex: 0, start: 0, end: 1 };
   const fullAnnotation: Required<Annotation> = {
     id: "a1",
     kind: "comment",
     anchor: fullAnchor,
+    target: { kind: "file", path: "src/x.ts", rev: "worktree" },
     body: "b",
     orphan: false,
+    author: "SHA256:abc",
+    replyTo: "a0",
+    resolution: { revision: 2, source: "agent" },
     createdAt: "now",
   };
-  const fullArtifact: Required<Artifact> = { type: "plan", content: "# P", meta: fullMeta };
-  const fullVerdict: Required<Verdict> = { kind: "approve", summary: "", feedback: "", resolvedAt: "now" };
+  const fullArtifact: Required<Artifact> = {
+    type: "plan",
+    content: "# P",
+    meta: fullMeta,
+    files: [{ path: "src/a.ts", oldContents: "old\n", newContents: "new\n", status: "modified" }],
+  };
+  const fullMessage: Required<Message> = {
+    id: "msg_1",
+    outcome: "approved",
+    summary: "",
+    body: "",
+    sentAt: "now",
+  };
   const fullRevision: Required<Revision> = { revision: 1, content: "# P", submittedAt: "now" };
-  const fullWorkspace: Required<WorkspaceKey> = { repoRoot: "/repo", branch: "main" };
-  const fullSession: Required<ReviewSession> = {
+  const fullWorkspace: Required<WorkspaceKey> = {
+    repoRoot: "/repo",
+    branch: "main",
+    rootCommit: "11e7abbcf507a13ae5e4e7559c4b42dbb52237fe",
+    remote: "git@github.com:acme/repo.git",
+  };
+  const fullIdentity: Required<Identity> = {
+    id: "SHA256:abc",
+    provider: "ssh",
+    name: "Al",
+    handle: "abc",
+  };
+  const fullSession: Required<Thread> = {
     schemaVersion: SCHEMA_VERSION,
     id: "ses_1",
     workspace: fullWorkspace,
     artifact: fullArtifact,
     revisions: [fullRevision],
     annotations: [fullAnnotation],
+    history: {
+      entries: [
+        {
+          id: "e1",
+          parentId: null,
+          type: "revision",
+          by: "agent",
+          content: "# P",
+          createdAt: "now",
+        },
+        { id: "e2", parentId: "e1", type: "comment", annotationId: "a1", createdAt: "now" },
+        { id: "e3", parentId: "e2", type: "comment-removed", annotationId: "a1", createdAt: "now" },
+        { id: "e4", parentId: "e3", type: "message", message: fullMessage, createdAt: "now" },
+        {
+          id: "e5",
+          parentId: "e4",
+          type: "branch-summary",
+          text: "tried a thing",
+          abandoned: ["e3"],
+          createdAt: "now",
+        },
+      ],
+      tips: { main: "e5" },
+      branch: "main",
+      labels: { e1: "start" },
+    },
+    curation: [{ path: "src/a.ts", hunkIndex: 0, changeIndex: 1 }],
+    shelvedAnnotations: [fullAnnotation],
+    parentSessionId: "ses_0",
+    shareBranch: "main",
     workingCopy: "# P edited",
-    verdict: fullVerdict,
+    viewedPaths: ["src/a.ts"],
+    message: fullMessage,
     status: "pending",
     createdAt: "now",
+    shares: [
+      {
+        id: "p_abc123xy",
+        name: "review link",
+        requireAuth: true,
+        allowlist: ["octocat"],
+        owner: "SHA256:owner",
+        shareBranch: "main",
+      },
+    ],
+    shareId: "p_abc123xy",
+    owner: "SHA256:owner",
+    access: { githubLogins: ["octocat"] },
+    participants: [fullIdentity],
   };
 
+  test("a history whose tree is broken is refused even when every entry is well-formed", () => {
+    // Arrange: a parent cycle
+    const record = {
+      ...fullSession,
+      history: {
+        entries: [
+          { id: "a", parentId: "b", type: "revision", by: "agent", content: "x", createdAt: "now" },
+          { id: "b", parentId: "a", type: "comment", annotationId: "a1", createdAt: "now" },
+        ],
+        tips: { main: "b" },
+        branch: "main",
+        labels: {},
+      },
+    };
+
+    // Act
+    const parsed = validateThreadRecord(record);
+
+    // Assert
+    expect(parsed.ok).toBe(false);
+    if (!parsed.ok) expect(parsed.error).toContain("history:");
+  });
+
   test("schema key sets match the schema types", () => {
     expect(entryKeys(WorkspaceSchema)).toEqual(keys(fullWorkspace));
     expect(entryKeys(ArtifactMetaSchema)).toEqual(keys(fullMeta));
@@ -175,27 +327,54 @@ 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));
-    expect(entryKeys(SessionRecordSchema)).toEqual(keys(fullSession));
+    expect(entryKeys(MessageSchema)).toEqual(keys(fullMessage));
+    expect(entryKeys(IdentitySchema)).toEqual(keys(fullIdentity));
+    expect(entryKeys(ThreadRecordSchema)).toEqual(keys(fullSession));
     // persisted annotations carry the stamped createdAt
-    const stored = SessionRecordSchema.entries.annotations.item;
+    const stored = ThreadRecordSchema.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", {
         workspace: fullWorkspace,
         artifact: { type: "plan", content: "# P", meta: fullMeta },
       });
       const core = new DaemonCore(home);
+
+      // Act
       const created = core.sessionCreate(params);
+
+      // Assert
       expect(core.sessionGet(created.id).artifact.meta).toEqual(fullMeta);
     } finally {
       rmSync(home, { recursive: true, force: true });
     }
   });
 });
+
+describe("IdentitySchema provider", () => {
+  test("accepts a verified github identity", () => {
+    const parsed = v.safeParse(IdentitySchema, {
+      id: "SHA256:abc",
+      provider: "github",
+      name: "markus",
+    });
+
+    expect(parsed.success).toBe(true);
+  });
+
+  test("rejects an unknown provider", () => {
+    const parsed = v.safeParse(IdentitySchema, { id: "SHA256:abc", provider: "email" });
+
+    expect(parsed.success).toBe(false);
+  });
+});