@cueloop/daemon 0.1.0-alpha.0 → 0.1.0-alpha.100

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,7 +1,37 @@
 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";
+import { DaemonCore } from "./api";
 import { DaemonError } from "./errors";
-import { isKnownMethod, parseParams, validateSessionRecord } from "./validate";
-import { SCHEMA_VERSION } from "@cueloop/schema";
+import {
+  AnchorSchema,
+  AnnotationSchema,
+  ArtifactMetaSchema,
+  ArtifactSchema,
+  IdentitySchema,
+  RevisionSchema,
+  ThreadRecordSchema,
+  MessageSchema,
+  WorkspaceSchema,
+  isKnownMethod,
+  parseParams,
+  validateThreadRecord,
+} from "./validate";
+import {
+  ARTIFACT_TYPES,
+  SCHEMA_VERSION,
+  type Anchor,
+  type Annotation,
+  type Artifact,
+  type ArtifactMeta,
+  type Identity,
+  type Thread,
+  type Revision,
+  type Message,
+  type WorkspaceKey,
+} from "@cueloop/schema";
 
 describe("method allowlist", () => {
   test("known and unknown methods", () => {
@@ -12,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", () => {
@@ -25,11 +58,48 @@ 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);
     }
   });
 
+  test.each([
+    [
+      [
+        { start: 2, end: 4, quote: "ab" },
+        { start: 1, end: 2, quote: "c" },
+      ],
+    ],
+    [
+      [
+        { start: 1, end: 4, quote: "abc" },
+        { start: 3, end: 5, quote: "de" },
+      ],
+    ],
+    [[{ start: 1, end: 4, quote: "ab" }]],
+  ])("rejects malformed text Cut provenance", (textCuts) => {
+    expect(() =>
+      parseParams("session.setWorkingCopy", {
+        id: "ses_1",
+        workingCopy: "remaining",
+        textCuts,
+      }),
+    ).toThrow("text Cuts must be ordered, non-overlapping, and match their quote lengths");
+  });
+
   test("rejects an unknown artifact type", () => {
     expect(() =>
       parseParams("session.create", {
@@ -46,21 +116,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", () => {
@@ -68,7 +157,7 @@ describe("parseParams", () => {
   });
 });
 
-describe("validateSessionRecord", () => {
+describe("validateThreadRecord", () => {
   const record = {
     schemaVersion: SCHEMA_VERSION,
     id: "ses_1",
@@ -76,23 +165,279 @@ 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: 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 = <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",
+    vcs: "jj",
+    vcsChangeId: "change",
+    vcsRevisionId: "revision",
+    agent: "claude-code",
+    agentSessionId: "sess-1",
+    planPath: "/repo/plan.md",
+    prototypePath: "/repo/proto.html",
+    pr: "org/repo#1",
+    prBrief: "# PR",
+    prBaseSha: "base",
+    prHeadSha: "head",
+    prRefreshBaseSha: "next-base",
+    prRefreshHeadSha: "next",
+    prUrl: "https://github.com/org/repo/pull/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 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",
+    reviewComment: {
+      severity: "p1",
+      title: "Finding",
+      path: "src/x.ts",
+      line: 1,
+      startLine: 1,
+      startAnchor: fullAnchor,
+      side: "RIGHT",
+      suggestion: "replacement",
+      prompt: "fix it",
+    },
+    replyTo: "a0",
+    resolution: { revision: 2, source: "agent" },
+    createdAt: "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: "",
+    annotations: [fullAnnotation],
+    sentAt: "now",
+  };
+  const fullRevision: Required<Revision> = {
+    revision: 1,
+    content: "# P",
+    submittedAt: "now",
+    source: { vcs: "jj", changeId: "change", revisionId: "revision" },
+    files: [{ path: "a.ts", oldContents: "a", newContents: "b", status: "modified" }],
+  };
+  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",
+    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",
+    shares: [
+      {
+        id: "p_abc123xy",
+        name: "review link",
+        requireAuth: true,
+        allowlist: ["octocat"],
+        owner: "SHA256:owner",
+        shareBranch: "main",
+      },
+    ],
+    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("a persisted Thread with stale text Cut provenance is refused", () => {
+    const result = validateThreadRecord({
+      ...fullSession,
+      workingCopy: "# P",
+    });
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toContain(
+        "text Cuts do not match the submitted artifact and working copy",
+      );
+    }
+  });
+
+  test("schema key sets match the schema types", () => {
+    expect(entryKeys(WorkspaceSchema)).toEqual(keys(fullWorkspace));
+    expect(entryKeys(ArtifactMetaSchema)).toEqual(keys(fullMeta));
+    expect(entryKeys(ArtifactSchema)).toEqual(keys(fullArtifact));
+    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(MessageSchema)).toEqual(keys(fullMessage));
+    expect(entryKeys(IdentitySchema)).toEqual(keys(fullIdentity));
+    expect(entryKeys(ThreadRecordSchema)).toEqual(keys(fullSession));
+    // persisted annotations carry the stamped createdAt
+    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);
   });
 });