@yannelli/paseo-linear-plugin 1.0.1 → 1.1.0-beta.1

package/server/stores.ts

@@ -0,0 +1,126 @@
+import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { type ZodType, z } from "zod";
+import { type IssueMap, IssueMapSchema, type LaunchInput, LaunchInputSchema } from "../shared/live";
+
+const MAX_MAPS = 200;
+/** A launch still waiting after this long is dropped, so a stale one never starts by surprise. */
+export const PENDING_LAUNCH_MAX_AGE_MS = 60 * 60_000;
+
+interface JsonFile<T> {
+  read(): Promise<T>;
+  /** Changes run one at a time, so a read, change, and write never interleave. */
+  update<R>(change: (current: T) => { next: T; result: R }): Promise<R>;
+}
+
+export function createJsonFile<T>(file: string, schema: ZodType<T>, empty: () => T): JsonFile<T> {
+  let value: T | null = null;
+  let queue: Promise<unknown> = Promise.resolve();
+  async function load(): Promise<T> {
+    if (value !== null) return value;
+    try {
+      value = schema.parse(JSON.parse(await readFile(file, "utf8")));
+    } catch {
+      value = empty();
+    }
+    return value;
+  }
+  async function save(next: T) {
+    value = next;
+    await mkdir(path.dirname(file), { recursive: true, mode: 0o700 });
+    const temporary = `${file}.${process.pid}.tmp`;
+    await writeFile(temporary, JSON.stringify(next), { mode: 0o600 });
+    await rename(temporary, file);
+  }
+  return {
+    read: load,
+    update(change) {
+      const run = queue
+        .catch(() => undefined)
+        .then(async () => {
+          const { next, result } = change(await load());
+          await save(next);
+          return result;
+        });
+      queue = run;
+      return run;
+    },
+  };
+}
+
+export interface MapStore {
+  get(identifier: string): Promise<IssueMap | null>;
+  set(map: IssueMap): Promise<void>;
+  delete(identifier: string): Promise<void>;
+}
+
+/** Explore maps survive daemon restarts, so a finished explore run is never paid for twice. */
+export function createMapStore(file: string): MapStore {
+  const store = createJsonFile<Record<string, IssueMap>>(
+    file,
+    z.record(z.string(), IssueMapSchema),
+    () => ({}),
+  );
+  return {
+    async get(identifier) {
+      return (await store.read())[identifier] ?? null;
+    },
+    set(map) {
+      return store.update((current) => {
+        const kept = Object.values({ ...current, [map.identifier]: map })
+          .sort((a, b) => b.createdAt.localeCompare(a.createdAt))
+          .slice(0, MAX_MAPS);
+        return { next: Object.fromEntries(kept.map((entry) => [entry.identifier, entry])), result: undefined };
+      });
+    },
+    delete(identifier) {
+      return store.update((current) => {
+        const { [identifier]: _removed, ...rest } = current;
+        return { next: rest, result: undefined };
+      });
+    },
+  };
+}
+
+const PendingLaunchSchema = LaunchInputSchema.extend({ queuedAt: z.number() });
+type PendingLaunch = z.infer<typeof PendingLaunchSchema>;
+
+export interface LaunchQueue {
+  add(launch: LaunchInput): Promise<void>;
+  /** Removes and returns the issue's waiting launches, so each one starts at most once. */
+  claim(identifier: string): Promise<LaunchInput[]>;
+}
+
+// Agents that wait for an explore run are saved to disk, so a plugin reload or daemon
+// restart while the run works still starts them once the map is ready.
+export function createLaunchQueue(file: string, now = () => Date.now()): LaunchQueue {
+  const store = createJsonFile<Record<string, PendingLaunch[]>>(
+    file,
+    z.record(z.string(), z.array(PendingLaunchSchema)),
+    () => ({}),
+  );
+  return {
+    add(launch) {
+      return store.update((current) => ({
+        next: {
+          ...current,
+          [launch.identifier]: [...(current[launch.identifier] ?? []), { ...launch, queuedAt: now() }],
+        },
+        result: undefined,
+      }));
+    },
+    claim(identifier) {
+      return store.update((current) => {
+        const { [identifier]: waiting = [], ...others } = current;
+        const fresh = waiting.filter((launch) => now() - launch.queuedAt < PENDING_LAUNCH_MAX_AGE_MS);
+        if (fresh.length < waiting.length) {
+          console.error(`Dropped ${waiting.length - fresh.length} stale Linear launch for ${identifier}`);
+        }
+        return {
+          next: others,
+          result: fresh.map(({ queuedAt: _queuedAt, ...launch }: PendingLaunch) => launch),
+        };
+      });
+    },
+  };
+}

package/server/subagent-logs.ts

@@ -0,0 +1,146 @@
+import { open, readdir, readFile, stat } from "node:fs/promises";
+import { homedir } from "node:os";
+import path from "node:path";
+import type { SubagentLog } from "../shared/live";
+
+// Claude writes each subagent's transcript beside the session, also for subagents that run in
+// the background and send nothing to the parent timeline. This reads their tool calls and turns
+// them into timeline items the panel already understands. Nothing here writes or runs anything.
+
+const SESSION_ID = /^[A-Za-z0-9-]{8,80}$/;
+const MAX_RUNS = 8;
+const MAX_TAIL_BYTES = 512 * 1024;
+const MAX_ITEMS = 120;
+
+/** Folders that can hold Claude's `projects` folder: the env setting, the default, Paseo homes. */
+async function claudeHomes(): Promise<string[]> {
+  const homes = [process.env.CLAUDE_CONFIG_DIR, path.join(homedir(), ".claude")];
+  const paseoHome = process.env.PASEO_HOME || path.join(homedir(), ".paseo");
+  const accounts = await readdir(path.join(paseoHome, "zerosub", "homes")).catch(() => []);
+  for (const name of accounts) homes.push(path.join(paseoHome, "zerosub", "homes", name));
+  return [...new Set(homes.filter((home): home is string => Boolean(home)))];
+}
+
+const found = new Map<string, string>();
+
+async function isDirectory(target: string): Promise<boolean> {
+  return (await stat(target).catch(() => null))?.isDirectory() ?? false;
+}
+
+/** The session's `subagents` folder. Claude names the project folder after the cwd. */
+export async function subagentFolder(sessionId: string, cwd: string): Promise<string | null> {
+  if (!SESSION_ID.test(sessionId)) return null;
+  const known = found.get(sessionId);
+  if (known) return known;
+  const slug = cwd.replace(/[^A-Za-z0-9]/g, "-");
+  for (const home of await claudeHomes()) {
+    const projects = path.join(home, "projects");
+    const guess = path.join(projects, slug, sessionId, "subagents");
+    const names = (await isDirectory(guess)) ? [slug] : await readdir(projects).catch(() => []);
+    for (const name of names) {
+      const folder = path.join(projects, name, sessionId, "subagents");
+      if (await isDirectory(folder)) {
+        found.set(sessionId, folder);
+        return folder;
+      }
+    }
+  }
+  return null;
+}
+
+async function tail(file: string): Promise<string> {
+  const handle = await open(file, "r");
+  try {
+    const { size } = await handle.stat();
+    const start = Math.max(0, size - MAX_TAIL_BYTES);
+    const buffer = Buffer.alloc(size - start);
+    await handle.read(buffer, 0, buffer.length, start);
+    const text = buffer.toString("utf8");
+    // A cut first line is not valid JSON; drop it.
+    return start > 0 ? text.slice(text.indexOf("\n") + 1) : text;
+  } finally {
+    await handle.close();
+  }
+}
+
+type Block = Record<string, unknown>;
+type Item = SubagentLog["items"][number];
+
+const str = (value: unknown) => (typeof value === "string" ? value : "");
+const lines = (value: unknown) => (str(value) ? str(value).replace(/\n$/, "").split("\n").length : 0);
+
+/** A Claude tool call as a Paseo-style tool call item, with paths moved from the worktree. */
+export function toolItem(block: Block, move: (value: string) => string, cwd: string): Item {
+  const input = (block.input ?? {}) as Block;
+  const name = str(block.name);
+  const file = move(str(input.file_path) || str(input.notebook_path));
+  let detail: Record<string, unknown> = { type: "unknown" };
+  if (name === "Read" && file) detail = { type: "read", filePath: file };
+  else if ((name === "Edit" || name === "MultiEdit" || name === "NotebookEdit") && file) {
+    const edits = Array.isArray(input.edits) ? (input.edits as Block[]) : [input];
+    const added = edits.reduce((sum, edit) => sum + lines(edit.new_string ?? edit.new_source), 0);
+    const removed = edits.reduce((sum, edit) => sum + lines(edit.old_string), 0);
+    detail = { type: "edit", filePath: file, added, removed };
+  } else if (name === "Write" && file) detail = { type: "write", filePath: file, added: lines(input.content) };
+  else if (name === "Grep" || name === "Glob") detail = { type: "search", query: str(input.pattern) };
+  else if (name === "Bash") detail = { type: "shell", command: move(str(input.command)), cwd };
+  return { type: "tool_call", callId: str(block.id), name, status: "running", detail };
+}
+
+/** Tool calls in a transcript, newest last, with each finished call marked done or failed. */
+export function transcriptItems(text: string, move: (value: string) => string, cwd: string) {
+  const items = new Map<string, Item>();
+  let finished = false;
+  for (const line of text.split("\n")) {
+    if (!line.trim()) continue;
+    let entry: Block;
+    try {
+      entry = JSON.parse(line) as Block;
+    } catch {
+      continue;
+    }
+    const message = (entry.message ?? {}) as Block;
+    const content = Array.isArray(message.content) ? (message.content as Block[]) : [];
+    if (entry.type === "assistant") {
+      finished = message.stop_reason === "end_turn" && !content.some((block) => block.type === "tool_use");
+    }
+    for (const block of content) {
+      if (block.type === "tool_use" && str(block.id)) items.set(str(block.id), toolItem(block, move, cwd));
+      const done = block.type === "tool_result" ? items.get(str(block.tool_use_id)) : undefined;
+      if (done) done.status = block.is_error ? "failed" : "completed";
+    }
+  }
+  return { items: [...items.values()].slice(-MAX_ITEMS), finished };
+}
+
+/** The newest subagents of a Claude session, with their tool calls. */
+export async function subagentLogs(sessionId: string, cwd: string): Promise<SubagentLog[]> {
+  const folder = await subagentFolder(sessionId, cwd);
+  if (!folder) return [];
+  const names = (await readdir(folder).catch(() => [])).filter((name) => /^agent-[A-Za-z0-9]+\.jsonl$/.test(name));
+  const dated = await Promise.all(
+    names.map(async (name) => ({ name, at: (await stat(path.join(folder, name)).catch(() => null))?.mtimeMs ?? 0 })),
+  );
+  const newest = dated.sort((a, b) => b.at - a.at).slice(0, MAX_RUNS);
+  const runs: SubagentLog[] = [];
+  for (const { name, at } of newest) {
+    const id = name.slice("agent-".length, -".jsonl".length);
+    const meta = JSON.parse(
+      (await readFile(path.join(folder, `agent-${id}.meta.json`), "utf8").catch(() => "{}")) || "{}",
+    ) as Block;
+    const worktree = str(meta.worktreePath).replace(/\/+$/, "");
+    // A subagent in its own worktree sees the same repository, so its paths map onto the agent's.
+    const move = (value: string) => (worktree ? value.split(worktree).join(cwd) : value);
+    const { items, finished } = transcriptItems(await tail(path.join(folder, name)).catch(() => ""), move, cwd);
+    runs.push({
+      id,
+      type: str(meta.agentType) || "Subagent",
+      description: str(meta.description),
+      toolUseId: str(meta.toolUseId) || null,
+      updatedAt: Math.round(at),
+      finished,
+      items,
+    });
+  }
+  return runs;
+}

package/server/sync.ts

@@ -0,0 +1,127 @@
+import type { PluginServerContext } from "@getpaseo/plugin/server";
+import type { WorkflowState } from "../shared/linear";
+import { syncNowRpc } from "../shared/live";
+import { AGENT_LABELS, isInternalAgent } from "../shared/prompts";
+import { type LinearSettings, projectEnabled } from "../shared/settings";
+import { planStatusMoves, progressByKey, type TodoLike } from "../shared/todo-sync";
+import type { Paseo } from "./agent-runs";
+import type { LinearAccess } from "./handlers";
+import { agentInfo } from "./live";
+
+const STATES_MAX_AGE_MS = 10 * 60_000;
+
+export interface SyncDependencies {
+  access: LinearAccess;
+  readSettings(): Promise<LinearSettings | null>;
+}
+
+export interface SyncResult {
+  moves: { identifier: string; from: WorkflowState; to: WorkflowState }[];
+  skipped: string | null;
+}
+
+function latestTodos(items: readonly { type: string; items?: unknown }[]): TodoLike[] | null {
+  for (let index = items.length - 1; index >= 0; index -= 1) {
+    const item = items[index];
+    if (item?.type === "todo" && Array.isArray(item.items)) return item.items as TodoLike[];
+  }
+  return null;
+}
+
+export function registerSync(server: PluginServerContext, dependencies: SyncDependencies) {
+  const { access, readSettings } = dependencies;
+  const teamStates = new Map<string, { at: number; states: Map<string, WorkflowState[]> }>();
+  const queues = new Map<string, Promise<unknown>>();
+
+  async function statesFor(projectId: string | null, teamId: string) {
+    const { linear, fingerprint } = await access.connect(projectId);
+    const cached = teamStates.get(fingerprint);
+    if (cached && Date.now() - cached.at < STATES_MAX_AGE_MS && cached.states.has(teamId)) {
+      return cached.states.get(teamId) ?? [];
+    }
+    const catalog = await linear.catalog();
+    const states = new Map(catalog.teams.map((team) => [team.id, team.states]));
+    teamStates.set(fingerprint, { at: Date.now(), states });
+    return states.get(teamId) ?? [];
+  }
+
+  // Reads Linear fresh, not the response cache, so a manual move since the last turn counts.
+  async function syncIssue(
+    identifier: string,
+    projectId: string | null,
+    todos: readonly TodoLike[],
+  ): Promise<SyncResult> {
+    const progress = progressByKey(todos);
+    if (progress.size === 0) return { moves: [], skipped: "No todo starts with an issue key." };
+    const { linear } = await access.connect(projectId);
+    const issue = await linear.getIssue(identifier);
+    const states = await statesFor(projectId, issue.team.id);
+    const moves = planStatusMoves({ parent: issue, progress, states });
+    const applied: SyncResult["moves"] = [];
+    for (const move of moves) {
+      await access.mutate(projectId, (service) =>
+        service.updateIssue(move.issueId, { stateId: move.to.id }),
+      );
+      applied.push({ identifier: move.identifier, from: move.from, to: move.to });
+    }
+    if (applied.length > 0) {
+      console.log(`Linear sync moved ${applied.map((m) => `${m.identifier} to ${m.to.name}`).join(", ")}`);
+    }
+    return { moves: applied, skipped: null };
+  }
+
+  // One sync per issue at a time, so two turns ending together cannot move an issue twice.
+  function queued(identifier: string, run: () => Promise<SyncResult>): Promise<SyncResult> {
+    const previous = queues.get(identifier) ?? Promise.resolve();
+    const next = previous.catch(() => undefined).then(run);
+    queues.set(identifier, next);
+    void next.finally(() => {
+      if (queues.get(identifier) === next) queues.delete(identifier);
+    });
+    return next;
+  }
+
+  async function syncAgent(
+    paseo: Paseo,
+    agentId: string,
+    todos: readonly TodoLike[] | null,
+  ): Promise<SyncResult> {
+    const agent = await agentInfo(paseo, agentId);
+    const settings = await readSettings();
+    if (settings && !projectEnabled(settings.access, agent.projectId)) {
+      return { moves: [], skipped: "Linear is off for this project." };
+    }
+    const identifier = agent.labels[AGENT_LABELS.issue];
+    if (!identifier || isInternalAgent(agent.labels)) {
+      return { moves: [], skipped: "This agent is not linked to a Linear issue." };
+    }
+    if (agent.labels[AGENT_LABELS.action] !== "implement") {
+      return { moves: [], skipped: "Only implementing agents update Linear statuses." };
+    }
+    let items = todos;
+    if (!items) {
+      const page = await paseo.agents
+        .ref(agentId)
+        .timeline.refetch({ direction: "tail", limit: 400, projection: "projected" });
+      items = latestTodos(page.entries.map((entry) => entry.item));
+    }
+    if (!items) return { moves: [], skipped: "The agent has no todos yet." };
+    const projectId = agent.labels[AGENT_LABELS.project] ?? null;
+    const todoItems = items;
+    return queued(identifier, () => syncIssue(identifier, projectId, todoItems));
+  }
+
+  server.on("agent.turn_ended", async (event, { paseo }) => {
+    const settings = await readSettings();
+    if (!settings?.live.syncTodos) return;
+    const todos = latestTodos(event.timeline);
+    if (!todos) return;
+    try {
+      await syncAgent(paseo, event.agent.id, todos);
+    } catch (error) {
+      console.error("Linear sync failed", error);
+    }
+  });
+
+  server.handle(syncNowRpc, async ({ agentId }, { paseo }) => syncAgent(paseo, agentId, null));
+}