@cueloop/daemon 0.1.0-alpha.66 → 0.1.0-alpha.68

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cueloop/daemon",
-  "version": "0.1.0-alpha.66",
+  "version": "0.1.0-alpha.68",
   "description": "The cueloop session daemon and its client: socket protocol, atomic store, resumable waits",
   "homepage": "https://github.com/mmurakaru/cueloop#readme",
   "bugs": {
@@ -35,7 +35,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@cueloop/schema": "0.1.0-alpha.66",
+    "@cueloop/schema": "0.1.0-alpha.68",
     "@pierre/diffs": "^1.3.6",
     "valibot": "^1.4.2"
   },

package/src/api.test.ts

@@ -154,6 +154,24 @@ describe("session lifecycle", () => {
     expect(core.sessionGet(session.id).workingCopy).toBeUndefined();
   });
 
+  test("a thread rename sets the title, clears back to the default on empty, and survives a restart", () => {
+    // Arrange
+    const session = core.sessionCreate({ workspace: WS, artifact: PLAN });
+
+    // Act
+    core.sessionSetTitle(session.id, "  Renamed thread  ");
+
+    // Assert - trimmed and persisted
+    expect(core.sessionGet(session.id).artifact.meta.title).toBe("Renamed thread");
+    expect(new DaemonCore(home).sessionGet(session.id).artifact.meta.title).toBe("Renamed thread");
+
+    // Act - an empty title clears back to the derived default
+    core.sessionSetTitle(session.id, "   ");
+
+    // Assert
+    expect(core.sessionGet(session.id).artifact.meta.title).toBeUndefined();
+  });
+
   test("viewed paths merge, dedupe, clear on empty, and survive a daemon restart", () => {
     // Arrange
     const session = core.sessionCreate({ workspace: WS, artifact: PLAN });

package/src/api.ts

@@ -31,6 +31,7 @@ import {
   switchBranch,
   verdictAllows,
   type Annotation,
+  type DiffFileStatus,
   type HunkRejection,
   type NewEntry,
   type Artifact,
@@ -46,7 +47,9 @@ import { SessionStore, withHistory } from "./store";
 import { pruneExpiredSessions, resolveCleanupPeriodDays } from "./retention";
 import { HerdrTabStore, type HerdrTabHandle } from "./herdr-tab-store";
 import { DiffWatcher } from "./diff-watcher";
-import { workingTreeDiff } from "./working-tree";
+import { workingTreeDiff, workingChangeList } from "./working-tree";
+import { listProjectFiles, readProjectFile } from "./project-files";
+import { resolveWorkspace } from "./review";
 import { DaemonError } from "./errors";
 
 /** What a share hands back: the notes and names it collected, and the removals it recorded. */
@@ -321,6 +324,45 @@ export class DaemonCore {
     return session;
   }
 
+  /** Rename a session's display title; an empty title clears it back to the derived default. */
+  sessionSetTitle(id: string, title: string): ReviewSession {
+    const session = this.mutable(id);
+    const trimmed = title.trim();
+
+    if (trimmed.length === 0) delete session.artifact.meta.title;
+    else session.artifact.meta.title = trimmed;
+    this.store.upsert(session);
+    // the title shows in the Threads sidebar, so a rename is an inbox change, not just a content edit
+    this.emit("inbox.changed", id);
+
+    return session;
+  }
+
+  /** Tracked, repo-relative file paths for the session's workspace; [] when it has no repo. */
+  projectFiles(id: string): Promise<string[]> {
+    return listProjectFiles(this.sessionGet(id).workspace.repoRoot);
+  }
+
+  /** UTF-8 contents of a repo-relative file in the session's workspace, or null when it cannot be read safely. */
+  fileContents(id: string, path: string): Promise<string | null> {
+    return readProjectFile(this.sessionGet(id).workspace.repoRoot, path);
+  }
+
+  /** Tracked, repo-relative file paths for the git repo containing `cwd`; [] when it is not a repo. Owner-only. */
+  async repoFiles(cwd: string): Promise<string[]> {
+    return listProjectFiles((await resolveWorkspace(cwd)).repoRoot);
+  }
+
+  /** UTF-8 contents of a repo-relative file in the repo containing `cwd`, or null when unreadable. Owner-only. */
+  async repoFileContents(cwd: string, path: string): Promise<string | null> {
+    return readProjectFile((await resolveWorkspace(cwd)).repoRoot, path);
+  }
+
+  /** Changed files (repo-relative path plus git status) in the working tree at `cwd`. Owner-only. */
+  repoChanges(cwd: string): Promise<{ path: string; status: DiffFileStatus }[]> {
+    return workingChangeList(cwd);
+  }
+
   sessionSetShareId(id: string, shareId: string): ReviewSession {
     const session = this.mutable(id);
 

package/src/capabilities.ts

@@ -35,6 +35,14 @@ const PRIMITIVE_ROLES = {
   "session.restoreBlock": "owner",
   "session.curate": "owner",
   "session.setViewed": "owner",
+  "session.setTitle": "owner",
+  // reading the local working tree is the owner's alone; a share carries no repo to read
+  "session.projectFiles": "owner",
+  "session.fileContents": "owner",
+  // the launch repo is the local owner's; a share has no local repo to browse
+  "repo.files": "owner",
+  "repo.fileContents": "owner",
+  "repo.changes": "owner",
   // the tree is the owner's: collaborators comment on the branch a share follows
   "session.navigate": "owner",
   "session.branch": "owner",

package/src/client.ts

@@ -9,6 +9,7 @@ import * as v from "valibot";
 import type {
   Annotation,
   Artifact,
+  DiffFileStatus,
   HunkRejection,
   ReviewSession,
   VerdictKind,
@@ -78,6 +79,18 @@ export interface SessionClient {
   /** Replace a diff review's reject decisions; the working copy follows. */
   sessionCurate(id: string, rejections: HunkRejection[]): Promise<ReviewSession>;
   sessionSetViewed(id: string, viewedPaths: string[]): Promise<ReviewSession>;
+  /** Rename a session's display title; an empty title restores the derived default. */
+  sessionSetTitle(id: string, title: string): Promise<ReviewSession>;
+  /** Tracked, repo-relative file paths for the session's workspace; a client with no local repo (a share) omits it. */
+  projectFiles?(sessionId: string): Promise<string[]>;
+  /** UTF-8 contents of a repo-relative file, or null when it cannot be read safely; omitted by a client with no local repo. */
+  fileContents?(sessionId: string, path: string): Promise<string | null>;
+  /** Tracked, repo-relative paths for the git repo containing `cwd`, for the no-session welcome shell. */
+  repoFiles?(cwd: string): Promise<string[]>;
+  /** UTF-8 contents of a repo-relative file in `cwd`'s repo, or null when unreadable. */
+  repoFileContents?(cwd: string, path: string): Promise<string | null>;
+  /** Changed files (path plus git status) in the working tree at `cwd`. */
+  repoChanges?(cwd: string): Promise<{ path: string; status: DiffFileStatus }[]>;
   /** Move a branch's tip (the current one, or `branch` after switching to it) back to an entry on its path; a summary records the abandoned segment. */
   sessionNavigate(
     id: string,
@@ -365,6 +378,28 @@ export class DaemonClient implements SessionClient {
   sessionSetViewed(id: string, viewedPaths: string[]): Promise<ReviewSession> {
     return this.request("session.setViewed", { id, viewedPaths }, SessionRecordSchema);
   }
+  sessionSetTitle(id: string, title: string): Promise<ReviewSession> {
+    return this.request("session.setTitle", { id, title }, SessionRecordSchema);
+  }
+  projectFiles(sessionId: string): Promise<string[]> {
+    return this.request("session.projectFiles", { id: sessionId }, v.array(v.string()));
+  }
+  fileContents(sessionId: string, path: string): Promise<string | null> {
+    return this.request("session.fileContents", { id: sessionId, path }, v.nullable(v.string()));
+  }
+  repoFiles(cwd: string): Promise<string[]> {
+    return this.request("repo.files", { cwd }, v.array(v.string()));
+  }
+  repoFileContents(cwd: string, path: string): Promise<string | null> {
+    return this.request("repo.fileContents", { cwd, path }, v.nullable(v.string()));
+  }
+  repoChanges(cwd: string): Promise<{ path: string; status: DiffFileStatus }[]> {
+    return this.request(
+      "repo.changes",
+      { cwd },
+      v.array(v.object({ path: v.string(), status: v.picklist(["added", "modified", "deleted"]) })),
+    );
+  }
   /** Re-capture a diff session's working tree; changed=true when the patch moved and an event fired. */
   sessionRefreshDiff(id: string): Promise<{ changed: boolean }> {
     return this.request("session.refreshDiff", { id }, RefreshDiffResultSchema);

package/src/project-files.test.ts

@@ -0,0 +1,124 @@
+/** Read-only repo introspection: the tracked file tree and safe, bounded file reads. */
+
+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 { listProjectFiles, readProjectFile } from "./project-files";
+
+function git(args: string[], cwd: string): void {
+  const result = Bun.spawnSync(["git", ...args], { cwd, stdout: "ignore", stderr: "ignore" });
+
+  if (result.exitCode !== 0) throw new Error(`git ${args.join(" ")} failed in ${cwd}`);
+}
+
+let repo: string;
+
+beforeEach(() => {
+  repo = mkdtempSync(join(tmpdir(), "cueloop-project-files-"));
+  git(["init", "-q", "-b", "main"], repo);
+  git(["config", "user.email", "t@t"], repo);
+  git(["config", "user.name", "t"], repo);
+});
+
+afterEach(() => {
+  rmSync(repo, { recursive: true, force: true });
+});
+
+describe("listProjectFiles", () => {
+  test("returns the tracked files sorted ascending", async () => {
+    // Given a repo whose files are committed out of alphabetical order
+    writeFileSync(join(repo, "z.ts"), "export const z = 1;\n");
+    writeFileSync(join(repo, "a.ts"), "export const a = 1;\n");
+    writeFileSync(join(repo, "m.ts"), "export const m = 1;\n");
+    git(["add", "."], repo);
+    git(["commit", "-qm", "init"], repo);
+
+    // When the tracked files are listed
+    const files = await listProjectFiles(repo);
+
+    // Then every tracked path comes back in ascending order
+    expect(files).toEqual(["a.ts", "m.ts", "z.ts"]);
+  });
+
+  test("returns [] for a directory that is not a git repo", async () => {
+    // Given a plain directory with a file but no git repo
+    const plain = mkdtempSync(join(tmpdir(), "cueloop-project-files-plain-"));
+
+    writeFileSync(join(plain, "a.ts"), "export const a = 1;\n");
+    try {
+      // When the tracked files are listed
+      const files = await listProjectFiles(plain);
+
+      // Then nothing comes back and no error is thrown
+      expect(files).toEqual([]);
+    } finally {
+      rmSync(plain, { recursive: true, force: true });
+    }
+  });
+
+  test("returns [] when there is no repoRoot", async () => {
+    expect(await listProjectFiles(undefined)).toEqual([]);
+  });
+});
+
+describe("readProjectFile", () => {
+  test("reads a repo-relative file as UTF-8", async () => {
+    // Given a committed file with known contents
+    writeFileSync(join(repo, "a.ts"), "export const a = 1;\n");
+    git(["add", "."], repo);
+    git(["commit", "-qm", "init"], repo);
+
+    // When it is read by its repo-relative path
+    const contents = await readProjectFile(repo, "a.ts");
+
+    // Then its exact bytes come back
+    expect(contents).toBe("export const a = 1;\n");
+  });
+
+  test("returns null for a path that escapes the repo via ../", async () => {
+    // Given a secret file just outside the repo root
+    const secret = join(repo, "..", "outside-secret.txt");
+
+    writeFileSync(secret, "top secret\n");
+    try {
+      // When a traversal path tries to reach it
+      const contents = await readProjectFile(repo, "../outside-secret.txt");
+
+      // Then the read is refused
+      expect(contents).toBeNull();
+    } finally {
+      rmSync(secret, { force: true });
+    }
+  });
+
+  test("returns null for a missing file", async () => {
+    expect(await readProjectFile(repo, "nope.ts")).toBeNull();
+  });
+
+  test("returns null for a directory (not a regular file)", async () => {
+    // Given a directory inside the repo
+    mkdirSync(join(repo, "src"));
+
+    // When the directory path is read
+    const contents = await readProjectFile(repo, "src");
+
+    // Then it is refused
+    expect(contents).toBeNull();
+  });
+
+  test("returns null for a file larger than the cap", async () => {
+    // Given a file just over one megabyte
+    writeFileSync(join(repo, "big.bin"), "x".repeat(1024 * 1024 + 1));
+
+    // When it is read
+    const contents = await readProjectFile(repo, "big.bin");
+
+    // Then it is refused for exceeding the size cap
+    expect(contents).toBeNull();
+  });
+
+  test("returns null when there is no repoRoot", async () => {
+    expect(await readProjectFile(undefined, "a.ts")).toBeNull();
+  });
+});

package/src/project-files.ts

@@ -0,0 +1,56 @@
+/** Read-only repo introspection for the Project panel: the tracked file tree and a file's contents. */
+
+import { stat } from "node:fs/promises";
+import { isAbsolute, relative, resolve, sep } from "node:path";
+
+/** Ceiling on the returned tree; a pathological repo cannot flood the panel or the wire. */
+const MAX_FILES = 5000;
+/** Ceiling on a served file; the panel renders source, not multi-megabyte blobs. */
+const MAX_FILE_BYTES = 1024 * 1024;
+
+/** Tracked, repo-relative paths from `git ls-files`, sorted ascending and capped; [] on any failure or non-repo. */
+export async function listProjectFiles(repoRoot: string | undefined): Promise<string[]> {
+  if (repoRoot === undefined || repoRoot.length === 0) return [];
+  try {
+    const gitProcess = Bun.spawn(["git", "-C", repoRoot, "ls-files", "-z"], {
+      stdout: "pipe",
+      stderr: "ignore",
+    });
+    const stdout = await new Response(gitProcess.stdout).text();
+
+    if ((await gitProcess.exited) !== 0) return [];
+    const paths = stdout.split("\0").filter((path) => path.length > 0);
+
+    return paths.toSorted().slice(0, MAX_FILES);
+  } catch {
+    return [];
+  }
+}
+
+/** True when `candidate` resolves outside `root` (path traversal) or is `root` itself. */
+function escapesRoot(root: string, candidate: string): boolean {
+  const rel = relative(root, candidate);
+
+  return rel.length === 0 || rel === ".." || rel.startsWith(".." + sep) || isAbsolute(rel);
+}
+
+/** UTF-8 contents of `repoRoot/path`, or null: no repo, traversal escape, not a regular file, oversized, or any error. */
+export async function readProjectFile(
+  repoRoot: string | undefined,
+  path: string,
+): Promise<string | null> {
+  if (repoRoot === undefined || repoRoot.length === 0) return null;
+  const root = resolve(repoRoot);
+  const target = resolve(root, path);
+
+  if (escapesRoot(root, target)) return null;
+  try {
+    const stats = await stat(target);
+
+    if (!stats.isFile() || stats.size > MAX_FILE_BYTES) return null;
+
+    return await Bun.file(target).text();
+  } catch {
+    return null;
+  }
+}

package/src/server.ts

@@ -380,6 +380,27 @@ export class DaemonServer {
 
       return this.core.sessionSetViewed(params.id, params.viewedPaths);
     },
+    "session.setTitle": (_connection, request) => {
+      const params = parseParams("session.setTitle", request.params);
+
+      return this.core.sessionSetTitle(params.id, params.title);
+    },
+    "session.projectFiles": (_connection, request) =>
+      this.core.projectFiles(parseParams("session.projectFiles", request.params).id),
+    "session.fileContents": (_connection, request) => {
+      const params = parseParams("session.fileContents", request.params);
+
+      return this.core.fileContents(params.id, params.path);
+    },
+    "repo.files": (_connection, request) =>
+      this.core.repoFiles(parseParams("repo.files", request.params).cwd),
+    "repo.fileContents": (_connection, request) => {
+      const params = parseParams("repo.fileContents", request.params);
+
+      return this.core.repoFileContents(params.cwd, params.path);
+    },
+    "repo.changes": (_connection, request) =>
+      this.core.repoChanges(parseParams("repo.changes", request.params).cwd),
     "session.refreshDiff": (_connection, request) => {
       const params = parseParams("session.refreshDiff", request.params);
 

package/src/validate.ts

@@ -166,6 +166,12 @@ export const Params = {
     ),
   }),
   "session.setViewed": v.object({ id: SessionId, viewedPaths: v.array(v.string()) }),
+  "session.setTitle": v.object({ id: SessionId, title: v.string() }),
+  "session.projectFiles": v.object({ id: SessionId }),
+  "session.fileContents": v.object({ id: SessionId, path: NonEmpty }),
+  "repo.files": v.object({ cwd: NonEmpty }),
+  "repo.fileContents": v.object({ cwd: NonEmpty, path: NonEmpty }),
+  "repo.changes": v.object({ cwd: NonEmpty }),
   "session.navigate": v.object({
     id: SessionId,
     entryId: NonEmpty,

package/src/working-tree.ts

@@ -1,7 +1,7 @@
 /** Working-tree diff capture for `cueloop diff`, untracked files included. */
 
 import { join } from "node:path";
-import type { DiffFileContents } from "@cueloop/schema";
+import type { DiffFileContents, DiffFileStatus } from "@cueloop/schema";
 
 async function git(args: string[], cwd: string): Promise<string | null> {
   const gitProcess = Bun.spawn(["git", ...args], { cwd, stdout: "pipe", stderr: "ignore" });
@@ -12,6 +12,42 @@ async function git(args: string[], cwd: string): Promise<string | null> {
   return stdout.trim();
 }
 
+/** Map a `git diff --name-status` letter to a diff status; renames/copies read as modified. */
+function statusFromCode(code: string): DiffFileStatus {
+  const letter = code.charAt(0);
+  if (letter === "D") return "deleted";
+  if (letter === "A") return "added";
+
+  return "modified";
+}
+
+/**
+ * The working tree's changed files as repo-relative path plus status - a fast listing for the changes
+ * navigator that never reads file contents (unlike workingTreeDiff, which captures full curation copies).
+ * Uses tab-separated name-status so a trimmed leading column can never shift the parse.
+ */
+export async function workingChangeList(
+  cwd = process.cwd(),
+): Promise<{ path: string; status: DiffFileStatus }[]> {
+  const changes: { path: string; status: DiffFileStatus }[] = [];
+  const tracked = (await git(["diff", "--name-status", "HEAD"], cwd)) ?? "";
+
+  for (const line of tracked.split("\n")) {
+    if (line.trim().length === 0) continue;
+    const parts = line.split("\t");
+    // a rename is "R100<tab>old<tab>new"; the new path (last field) is what the reviewer opens
+    changes.push({ path: parts[parts.length - 1]!, status: statusFromCode(parts[0]!) });
+  }
+
+  const untracked = (await git(["ls-files", "--others", "--exclude-standard"], cwd)) ?? "";
+
+  for (const path of untracked.split("\n")) {
+    if (path.trim().length > 0) changes.push({ path, status: "added" });
+  }
+
+  return changes;
+}
+
 /** The blob at HEAD for a path, or "" when the path is not in HEAD (new file). */
 async function headContents(path: string, cwd: string): Promise<string> {
   const gitProcess = Bun.spawn(["git", "show", `HEAD:${path}`], {