cueloop 0.1.0-alpha.21 → 0.1.0-alpha.23

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cueloop",
-  "version": "0.1.0-alpha.21",
+  "version": "0.1.0-alpha.23",
   "license": "Apache-2.0",
   "type": "module",
   "bin": {
@@ -10,9 +10,9 @@
     ".": "./src/main.ts"
   },
   "dependencies": {
-    "@cueloop/schema": "0.1.0-alpha.21",
-    "@cueloop/daemon": "0.1.0-alpha.21",
-    "@cueloop/client": "0.1.0-alpha.21"
+    "@cueloop/schema": "0.1.0-alpha.23",
+    "@cueloop/daemon": "0.1.0-alpha.23",
+    "@cueloop/client": "0.1.0-alpha.23"
   },
   "publishConfig": {
     "access": "public"

package/src/main.ts

@@ -72,6 +72,16 @@ async function main(): Promise<number> {
       await new Promise(() => {}); // serve until signalled
       return 0;
     }
+    case "share": {
+      const { positional, flags } = parseArgs(argv.slice(1));
+      const { shareCommand } = await import("./share-command");
+      const port = stringFlag(flags, "port");
+      return shareCommand({
+        sessionId: positional[0],
+        host: stringFlag(flags, "host"),
+        port: port !== undefined ? Number(port) : undefined,
+      });
+    }
     case "review":
       return reviewEntry(argv.slice(1));
     case "review-post": {
@@ -213,6 +223,8 @@ function printHelp(): void {
       "  cueloop serve [session-id]       share over ssh: observers are read-only,",
       "                                   you stay the controller (--port 2222, --host 127.0.0.1;",
       "                                   password-less - share the address deliberately)",
+      "  cueloop share [session-id]       hand a plan to a teammate: copies one",
+      "                                   ssh line (--host cueloop.dev, --port 22)",
       "  cueloop session <verb> [flags]   script the daemon (create|get|list|wait|annotate|resolve|submit-revision)",
       "  cueloop daemon                   run the daemon in the foreground",
     ].join("\n"),

package/src/open-target.test.ts

@@ -1,8 +1,4 @@
-/**
- * Verb-first open resolution over a plain session list: latest-pending default,
- * by-id, and fuzzy-by-title (exact wins, unique substring wins, else
- * ambiguous). No daemon and no TUI - the resolver is pure over the array.
- */
+/** Verb-first open resolution over a plain session list: latest-pending default, by-id, and fuzzy-by-title (exact wins, unique substring wins, else ambiguous). Pure over the array - no daemon, no TUI. */
 
 import { describe, expect, test } from "bun:test";
 import type { ArtifactType, ReviewSession } from "@cueloop/schema";
@@ -61,7 +57,10 @@ describe("verb scope predicates are disjoint", () => {
   });
 
   test("a PR review resolves under exactly one scope - never both diff and review", () => {
+    // Arrange
     const prReview = session({ id: "ses_pr", type: "diff", pr: "42" });
+
+    // Assert
     expect(isDiffReview(prReview)).toBe(false);
     expect(isPrReview(prReview)).toBe(true);
   });
@@ -77,35 +76,47 @@ describe("isSessionId", () => {
 
 describe("resolveOpenTarget: latest pending default", () => {
   test("picks the most recent pending session in scope", () => {
+    // Arrange
     const sessions = [
       session({ id: "ses_old", createdAt: "2026-01-01T00:00:00.000Z" }),
       session({ id: "ses_new", createdAt: "2026-03-01T00:00:00.000Z" }),
       session({ id: "ses_mid", createdAt: "2026-02-01T00:00:00.000Z" }),
     ];
+
+    // Assert
     expect(resolveOpenTarget(sessions, { match: isPlan })).toEqual({ kind: "session", sessionId: "ses_new" });
   });
 
   test("ignores resolved sessions and other artifact types", () => {
+    // Arrange
     const sessions = [
       session({ id: "ses_resolved", createdAt: "2026-05-01T00:00:00.000Z", status: "resolved" }),
       session({ id: "ses_diff", type: "diff", createdAt: "2026-04-01T00:00:00.000Z" }),
       session({ id: "ses_plan", createdAt: "2026-02-01T00:00:00.000Z" }),
     ];
+
+    // Assert
     expect(resolveOpenTarget(sessions, { match: isPlan })).toEqual({ kind: "session", sessionId: "ses_plan" });
   });
 
   test("no pending session in scope reports no-pending", () => {
+    // Arrange
     const sessions = [session({ id: "ses_done", status: "resolved" })];
+
+    // Assert
     expect(resolveOpenTarget(sessions, { match: isPlan })).toEqual({ kind: "no-pending" });
   });
 });
 
 describe("resolveOpenTarget: by id", () => {
   test("an exact session id in scope opens that session, pending or not", () => {
+    // Arrange
     const sessions = [
       session({ id: "ses_a" }),
       session({ id: "ses_b", status: "resolved" }),
     ];
+
+    // Assert
     expect(resolveOpenTarget(sessions, { match: isPlan, selector: "ses_b" })).toEqual({
       kind: "session",
       sessionId: "ses_b",
@@ -113,7 +124,10 @@ describe("resolveOpenTarget: by id", () => {
   });
 
   test("an id outside the scope does not match", () => {
+    // Arrange
     const sessions = [session({ id: "ses_diff", type: "diff" })];
+
+    // Assert
     expect(resolveOpenTarget(sessions, { match: isPlan, selector: "ses_diff" })).toEqual({
       kind: "no-match",
       selector: "ses_diff",
@@ -123,10 +137,13 @@ describe("resolveOpenTarget: by id", () => {
 
 describe("resolveOpenTarget: fuzzy by title", () => {
   test("case-insensitive exact title wins over substring rivals", () => {
+    // Arrange
     const sessions = [
       session({ id: "ses_exact", title: "Rollout" }),
       session({ id: "ses_sub", title: "Rollout plan v2" }),
     ];
+
+    // Assert
     expect(resolveOpenTarget(sessions, { match: isPlan, selector: "rollout" })).toEqual({
       kind: "session",
       sessionId: "ses_exact",
@@ -134,10 +151,13 @@ describe("resolveOpenTarget: fuzzy by title", () => {
   });
 
   test("a unique case-insensitive substring match wins", () => {
+    // Arrange
     const sessions = [
       session({ id: "ses_auth", title: "Auth rewrite" }),
       session({ id: "ses_cache", title: "Cache warmup" }),
     ];
+
+    // Assert
     expect(resolveOpenTarget(sessions, { match: isPlan, selector: "AUTH" })).toEqual({
       kind: "session",
       sessionId: "ses_auth",
@@ -145,10 +165,13 @@ describe("resolveOpenTarget: fuzzy by title", () => {
   });
 
   test("several substring matches are ambiguous and list the candidate titles", () => {
+    // Arrange
     const sessions = [
       session({ id: "ses_1", title: "Payments rollout" }),
       session({ id: "ses_2", title: "Rollout of search" }),
     ];
+
+    // Assert
     expect(resolveOpenTarget(sessions, { match: isPlan, selector: "rollout" })).toEqual({
       kind: "ambiguous",
       selector: "rollout",
@@ -157,7 +180,10 @@ describe("resolveOpenTarget: fuzzy by title", () => {
   });
 
   test("no title match reports no-match", () => {
+    // Arrange
     const sessions = [session({ id: "ses_1", title: "Auth rewrite" })];
+
+    // Assert
     expect(resolveOpenTarget(sessions, { match: isPlan, selector: "billing" })).toEqual({
       kind: "no-match",
       selector: "billing",
@@ -177,7 +203,10 @@ describe("openTargetMessage", () => {
   });
 
   test("ambiguous lists the candidate titles", () => {
+    // Act
     const message = openTargetMessage("plan", { kind: "ambiguous", selector: "rollout", titles: ["A", "B"] });
+
+    // Assert
     expect(message).toContain('"rollout" matches several plan reviews');
     expect(message).toContain("  - A");
     expect(message).toContain("  - B");

package/src/session-commands.ts

@@ -96,7 +96,12 @@ export async function sessionCommand(argv: string[]): Promise<number> {
         const id = required(positional[1], "session id");
         const contentFile = stringFlag(flags, "content-file");
         const content = contentFile ? await Bun.file(contentFile).text() : await readStdin();
-        out(await client.sessionSubmitRevision(id, content));
+        // --addressed a_1,a_2 - the annotation ids this revision acted on
+        const addressed = (stringFlag(flags, "addressed") ?? "")
+          .split(",")
+          .map((annotationId) => annotationId.trim())
+          .filter(Boolean);
+        out(await client.sessionSubmitRevision(id, content, addressed));
         return 0;
       }
       default:

package/src/share-command.test.ts

@@ -0,0 +1,87 @@
+import { describe, expect, mock, test } from "bun:test";
+import { SCHEMA_VERSION, type ReviewSession } from "@cueloop/schema";
+import type { SessionClient } from "@cueloop/daemon/client";
+import { shareSession, type ShareDeps } from "./share-command";
+
+function sessionFixture(id: string): ReviewSession {
+  return {
+    schemaVersion: SCHEMA_VERSION,
+    id,
+    workspace: { repoRoot: "/repo", branch: "main" },
+    artifact: { type: "plan", content: "# Plan\n", meta: {} },
+    revisions: [{ revision: 1, content: "# Plan\n", submittedAt: "2026-01-01T00:00:00.000Z" }],
+    annotations: [],
+    verdict: null,
+    status: "pending",
+    createdAt: "2026-01-01T00:00:00.000Z",
+  };
+}
+
+/** A SessionClient that answers get/list from a fixed list. */
+function fakeClient(sessions: ReviewSession[]): SessionClient {
+  return {
+    sessionGet: async (id: string) => sessions.find((session) => session.id === id)!,
+    sessionList: async () => sessions,
+  } as unknown as SessionClient;
+}
+
+function depsSpy(overrides: Partial<ShareDeps> = {}): ShareDeps & { lines: string[] } {
+  const lines: string[] = [];
+  return {
+    publish: mock(async () => ({ line: "ssh p_abc123xy@cueloop.dev", copied: true })),
+    out: (message: string) => void lines.push(message),
+    lines,
+    ...overrides,
+  };
+}
+
+describe(shareSession, () => {
+  test("publishes the named session and reports the copied ssh line", async () => {
+    // Arrange
+    const publish = mock(async (session: ReviewSession) => (expect(session.id).toBe("ses_2"), { line: "ssh p_abc123xy@cueloop.dev", copied: true }));
+    const deps = depsSpy({ publish });
+
+    // Act
+    const code = await shareSession(fakeClient([sessionFixture("ses_1"), sessionFixture("ses_2")]), { sessionId: "ses_2" }, deps);
+
+    // Assert
+    expect(code).toBe(0);
+    expect(deps.lines).toEqual(["share link copied - ssh p_abc123xy@cueloop.dev"]);
+  });
+
+  test("without an id, shares the most recent session", async () => {
+    // Arrange
+    const publish = mock(async (session: ReviewSession) => (expect(session.id).toBe("ses_2"), { line: "ssh p_zzzzzzzz@cueloop.dev", copied: true }));
+    const deps = depsSpy({ publish });
+
+    // Act
+    await shareSession(fakeClient([sessionFixture("ses_1"), sessionFixture("ses_2")]), {}, deps);
+
+    // Assert
+    expect(deps.publish).toHaveBeenCalledTimes(1);
+  });
+
+  test("prints the bare line when the clipboard is unavailable", async () => {
+    // Arrange
+    const deps = depsSpy({ publish: mock(async () => ({ line: "ssh p_abc123xy@cueloop.dev", copied: false })) });
+
+    // Act
+    await shareSession(fakeClient([sessionFixture("ses_1")]), { sessionId: "ses_1" }, deps);
+
+    // Assert
+    expect(deps.lines).toEqual(["ssh p_abc123xy@cueloop.dev"]);
+  });
+
+  test("reports nothing to share when the inbox is empty", async () => {
+    // Arrange
+    const deps = depsSpy();
+
+    // Act
+    const code = await shareSession(fakeClient([]), {}, deps);
+
+    // Assert
+    expect(code).toBe(1);
+    expect(deps.lines[0]).toContain("no plan to share");
+    expect(deps.publish).not.toHaveBeenCalled();
+  });
+});

package/src/share-command.ts

@@ -0,0 +1,54 @@
+/**
+ * `cueloop share [session-id]` - hand a plan to a teammate as one SSH line.
+ * This side just picks the session and delegates to the shared `publishShare`
+ * transport (the same one the in-TUI Share button uses); the gateway seals and
+ * stores. The transport and output are injected so the orchestration is
+ * testable without a live gateway.
+ */
+
+import { DaemonClient, type SessionClient } from "@cueloop/daemon/client";
+import { publishShare, type ShareResult, type ShareTarget } from "@cueloop/client";
+import type { ReviewSession } from "@cueloop/schema";
+
+export interface ShareParams {
+  sessionId?: string;
+  host?: string;
+  port?: number;
+  home?: string;
+}
+
+export interface ShareDeps {
+  publish: (session: ReviewSession, target: ShareTarget) => Promise<ShareResult>;
+  out: (message: string) => void;
+}
+
+const defaultDeps: ShareDeps = { publish: publishShare, out: (message) => console.log(message) };
+
+/** Connect to the local daemon, then share the chosen session. */
+export async function shareCommand(params: ShareParams, deps: ShareDeps = defaultDeps): Promise<number> {
+  const client = await DaemonClient.connect({ home: params.home, autostart: true });
+  try {
+    return await shareSession(client, params, deps);
+  } finally {
+    client.close();
+  }
+}
+
+/** The orchestration, over any SessionClient - the seam the tests drive. */
+export async function shareSession(client: SessionClient, params: ShareParams, deps: ShareDeps): Promise<number> {
+  const session = await pickSession(client, params.sessionId);
+  if (!session) {
+    deps.out("no plan to share - open a review first");
+    return 1;
+  }
+  const { line, copied } = await deps.publish(session, { host: params.host, port: params.port });
+  deps.out(copied ? `share link copied - ${line}` : line);
+  return 0;
+}
+
+/** The named session, or the most recent one when no id is given. */
+async function pickSession(client: SessionClient, sessionId?: string): Promise<ReviewSession | null> {
+  if (sessionId) return client.sessionGet(sessionId);
+  const sessions = await client.sessionList();
+  return sessions.at(-1) ?? null;
+}