@cueloop/daemon 0.1.0-alpha.63 → 0.1.0-alpha.65

package/src/validate.test.ts

@@ -57,8 +57,10 @@ 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");
+      }
     }
   });
 
@@ -172,7 +174,7 @@ describe("validateSessionRecord", () => {
  * @cueloop/schema shows up here too.
  */
 describe("wire pins", () => {
-  const keys = (subject: object) => Object.keys(subject).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> = {
@@ -190,6 +192,7 @@ describe("wire pins", () => {
     prefix: "p",
     suffix: "s",
     blockIndex: 0,
+    endBlockIndex: 0,
     start: 0,
     end: 1,
     selector: "div.card",
@@ -201,6 +204,7 @@ describe("wire pins", () => {
     body: "b",
     orphan: false,
     author: "SHA256:abc",
+    replyTo: "a0",
     resolution: { revision: 2, source: "agent" },
     createdAt: "now",
   };
@@ -231,6 +235,36 @@ describe("wire pins", () => {
     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: "verdict", verdict: fullVerdict, 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",
     viewedPaths: ["src/a.ts"],
     verdict: fullVerdict,
@@ -241,6 +275,29 @@ describe("wire pins", () => {
     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 = validateSessionRecord(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));

package/src/validate.ts

@@ -20,11 +20,15 @@ import {
   type DiffFileContents,
   type Identity,
   type ReviewSession,
+  type HunkRejection,
   type Revision,
+  type SessionHistory,
+  validateHistory,
   type Verdict,
   type WorkspaceKey,
 } from "@cueloop/schema";
 import { DaemonError } from "./errors";
+import type { Request } from "./protocol";
 
 /**
  * Drift guard for every hand-mirrored shape below. v.object strips keys it
@@ -74,6 +78,7 @@ export const AnchorSchema = v.object({
   prefix: v.optional(v.string(), ""),
   suffix: v.optional(v.string(), ""),
   blockIndex: v.optional(v.number()),
+  endBlockIndex: v.optional(v.number()),
   start: v.optional(v.number()),
   end: v.optional(v.number()),
   selector: v.optional(v.string()),
@@ -88,6 +93,7 @@ export const AnnotationSchema = v.object({
   body: v.string(),
   orphan: v.optional(v.boolean()),
   author: v.optional(v.string()),
+  replyTo: v.optional(NonEmpty),
   resolution: v.optional(
     v.object({
       revision: v.number(),
@@ -136,8 +142,39 @@ export const Params = {
     authorName: v.optional(v.string()),
   }),
   "session.removeAnnotation": v.object({ id: SessionId, annotationId: NonEmpty }),
+  "session.setParticipantName": v.object({ id: SessionId, author: NonEmpty, name: NonEmpty }),
   "session.setWorkingCopy": v.object({ id: SessionId, workingCopy: v.optional(v.string()) }),
+  "session.cutBlock": v.object({
+    id: SessionId,
+    blockIndex: v.pipe(v.number(), v.integer(), v.minValue(0)),
+  }),
+  "session.restoreBlock": v.object({
+    id: SessionId,
+    baseBlockIndex: v.pipe(v.number(), v.integer(), v.minValue(0)),
+    line: v.optional(v.pipe(v.number(), v.integer(), v.minValue(0))),
+  }),
+  "session.curate": v.object({
+    id: SessionId,
+    rejections: v.array(
+      v.object({
+        path: NonEmpty,
+        hunkIndex: v.pipe(v.number(), v.integer(), v.minValue(0)),
+        changeIndex: v.optional(v.pipe(v.number(), v.integer(), v.minValue(0))),
+      } satisfies EntriesOf<HunkRejection>),
+    ),
+  }),
   "session.setViewed": v.object({ id: SessionId, viewedPaths: v.array(v.string()) }),
+  "session.navigate": v.object({
+    id: SessionId,
+    entryId: NonEmpty,
+    summary: v.optional(v.string()),
+    // stand on this branch first, so a move on another branch is one request
+    branch: v.optional(NonEmpty),
+  }),
+  "session.branch": v.object({ id: SessionId, name: NonEmpty }),
+  "session.switch": v.object({ id: SessionId, branch: NonEmpty }),
+  "session.label": v.object({ id: SessionId, label: NonEmpty }),
+  "session.fork": v.object({ id: SessionId }),
   "session.refreshDiff": v.object({ id: SessionId }),
   "session.setShareId": v.object({ id: SessionId, shareId: NonEmpty }),
   "session.delete": v.object({ id: SessionId }),
@@ -145,6 +182,10 @@ export const Params = {
     id: SessionId,
     annotations: v.array(FullAnnotationSchema),
     participants: v.optional(v.array(IdentitySchema)),
+    // the removal entries a share recorded, carried by id so a merge applies each once
+    removals: v.optional(
+      v.array(v.object({ id: NonEmpty, annotationId: NonEmpty, createdAt: v.string() })),
+    ),
   }),
   "session.resolve": v.object({
     id: SessionId,
@@ -159,7 +200,13 @@ export const Params = {
   }),
   "events.subscribe": v.object({}),
   "daemon.ping": v.object({}),
-  "daemon.hello": v.object({ role: v.picklist(["owner", "collaborator", "agent"]) }),
+  // the owner token proves ownership; without it a request for owner stays a collaborator
+  "daemon.hello": v.object({
+    role: v.picklist(["owner", "collaborator", "agent"]),
+    token: v.optional(v.string()),
+    // the author a non-owner acts as, bound once for the connection
+    author: v.optional(NonEmpty),
+  }),
   "daemon.shutdown": v.object({}),
   // herdr adapter scratch: the review's opened tab, kept off the session record.
   "herdr.getTab": v.object({ id: SessionId }),
@@ -175,7 +222,7 @@ export function isKnownMethod(method: string): method is MethodName {
 /** Validate params for a method, or throw a DaemonError the client can read. */
 export function parseParams<M extends MethodName>(
   method: M,
-  params: unknown,
+  params: Request["params"],
 ): v.InferOutput<(typeof Params)[M]> {
   const result = v.safeParse(Params[method], params ?? {});
 
@@ -205,6 +252,47 @@ export const VerdictSchema = v.object({
   resolvedAt: v.string(),
 } satisfies EntriesOf<Verdict>);
 
+const EntryBaseEntries = {
+  id: NonEmpty,
+  parentId: v.nullable(NonEmpty),
+  createdAt: v.string(),
+};
+
+/** One record of a session's history; the tree pointers plus the entry's own fields. */
+export const SessionEntrySchema = v.variant("type", [
+  v.object({
+    ...EntryBaseEntries,
+    type: v.literal("revision"),
+    by: v.picklist(["agent", "reviewer"]),
+    content: v.string(),
+  }),
+  v.object({ ...EntryBaseEntries, type: v.literal("comment"), annotationId: NonEmpty }),
+  v.object({ ...EntryBaseEntries, type: v.literal("comment-removed"), annotationId: NonEmpty }),
+  v.object({ ...EntryBaseEntries, type: v.literal("verdict"), verdict: VerdictSchema }),
+  v.object({
+    ...EntryBaseEntries,
+    type: v.literal("branch-summary"),
+    text: v.string(),
+    abandoned: v.array(NonEmpty),
+  }),
+]);
+
+export const SessionHistorySchema = v.pipe(
+  v.object({
+    entries: v.array(SessionEntrySchema),
+    tips: v.record(v.string(), NonEmpty),
+    branch: NonEmpty,
+    labels: v.record(v.string(), v.string()),
+  } satisfies EntriesOf<SessionHistory>),
+  // the shape is not enough: the tree itself must hold, or a walk hangs or rewires the path
+  v.rawCheck(({ dataset, addIssue }) => {
+    if (!dataset.typed) return;
+    const problem = validateHistory(dataset.value);
+
+    if (problem !== null) addIssue({ message: `history: ${problem}` });
+  }),
+);
+
 /** Persisted records are validated on recovery: a bad file is skipped, not fatal. */
 export const SessionRecordSchema = v.object({
   schemaVersion: v.literal(SCHEMA_VERSION),
@@ -213,18 +301,31 @@ export const SessionRecordSchema = v.object({
   artifact: ArtifactSchema,
   revisions: v.array(RevisionSchema),
   annotations: v.array(FullAnnotationSchema),
+  history: v.optional(SessionHistorySchema),
+  curation: v.optional(
+    v.array(
+      v.object({
+        path: NonEmpty,
+        hunkIndex: v.number(),
+        changeIndex: v.optional(v.number()),
+      } satisfies EntriesOf<HunkRejection>),
+    ),
+  ),
   workingCopy: v.optional(v.string()),
   viewedPaths: v.optional(v.array(v.string())),
   verdict: v.nullable(VerdictSchema),
   status: v.picklist(["pending", "resolved"]),
   createdAt: v.string(),
+  shelvedAnnotations: v.optional(v.array(FullAnnotationSchema)),
+  parentSessionId: v.optional(v.string()),
   shareId: v.optional(v.string()),
+  shareBranch: v.optional(v.string()),
   owner: v.optional(v.string()),
   participants: v.optional(v.array(IdentitySchema)),
 } satisfies EntriesOf<ReviewSession>);
 
 export function validateSessionRecord(
-  raw: unknown,
+  raw: Parameters<typeof v.safeParse>[1],
 ): { ok: true; value: v.InferOutput<typeof SessionRecordSchema> } | { ok: false; error: string } {
   const result = v.safeParse(SessionRecordSchema, raw);