harnery 0.31.6 → 0.33.0

package/src/lib/claude-desktop.ts

@@ -1,6 +1,19 @@
-import { copyFileSync, existsSync, mkdirSync, readdirSync, readFileSync, statSync } from "node:fs";
+import { randomUUID } from "node:crypto";
+import {
+  copyFileSync,
+  createReadStream,
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  readFileSync,
+  renameSync,
+  statSync,
+  unlinkSync,
+  writeFileSync,
+} from "node:fs";
 import { homedir } from "node:os";
 import { basename, dirname, join } from "node:path";
+import { createInterface } from "node:readline";
 
 /**
  * Claude desktop app session-index access.
@@ -67,6 +80,49 @@ export interface MirrorPlan {
   skippedArchived: number;
 }
 
+export type DesktopLifecycleState = "active" | "blocked" | "done";
+
+export interface DesktopLifecycleRecord {
+  state: DesktopLifecycleState;
+  updatedAt: string;
+  instanceId: string | null;
+  sessionId: string | null;
+  reason: string | null;
+}
+
+export type DesktopTidySource = "lifecycle" | "legacy-prefix";
+
+export interface DesktopTidyAction {
+  entry: DesktopSessionEntry;
+  source: DesktopTidySource;
+  lifecycle: DesktopLifecycleRecord | null;
+}
+
+export type DesktopTidySkipReason =
+  | "already_archived"
+  | "blocked_title"
+  | "lifecycle_active"
+  | "lifecycle_blocked"
+  | "unmatched";
+
+export interface DesktopTidySkip {
+  entry: DesktopSessionEntry;
+  reason: DesktopTidySkipReason;
+  lifecycle: DesktopLifecycleRecord | null;
+}
+
+export interface DesktopTidyPlan {
+  actions: DesktopTidyAction[];
+  skipped: DesktopTidySkip[];
+}
+
+export interface DesktopTidyOptions {
+  /** Restrict entries to accounts whose UUID starts with one of these prefixes. */
+  accounts?: string[];
+  /** Accept an unmatched historical `[DONE]` title as a compatibility fallback. */
+  includeLegacyPrefix?: boolean;
+}
+
 const SESSIONS_DIRNAME = "claude-code-sessions";
 
 function isWsl(): boolean {
@@ -294,3 +350,178 @@ export function applyMirror(plan: MirrorPlan): { copied: number } {
   }
   return { copied };
 }
+
+/**
+ * Read the latest durable lifecycle declaration for every Harnery session.
+ *
+ * The canonical ledger rotates into `events-*.ndjson` archives. Stream each
+ * file rather than loading the whole history into one string, then compare
+ * event timestamps because adapter replay may append an older event later.
+ * Records are indexed by both session_id and instance_id so a desktop
+ * cliSessionId can match either identity shape used by older adapters.
+ */
+export async function readDesktopLifecycleIndex(
+  coordRoot: string,
+): Promise<Map<string, DesktopLifecycleRecord>> {
+  const coordDir = join(coordRoot, ".harnery");
+  const archives = safeReaddir(coordDir)
+    .filter((name) => name.startsWith("events-") && name.endsWith(".ndjson"))
+    .sort();
+  const files = [...archives, "events.ndjson"]
+    .map((name) => join(coordDir, name))
+    .filter((path) => existsSync(path));
+
+  const records = new Map<string, DesktopLifecycleRecord>();
+  const timestamps = new Map<string, number>();
+
+  for (const file of files) {
+    let lines: ReturnType<typeof createInterface> | null = null;
+    try {
+      lines = createInterface({
+        input: createReadStream(file, { encoding: "utf8" }),
+        crlfDelay: Infinity,
+      });
+      for await (const line of lines) {
+        if (!line.trim()) continue;
+        let raw: unknown;
+        try {
+          raw = JSON.parse(line);
+        } catch {
+          continue;
+        }
+        if (!raw || typeof raw !== "object") continue;
+        const event = raw as Record<string, unknown>;
+        if (event.event_type !== "state.task_state" || typeof event.ts !== "string") continue;
+        const data = event.data;
+        if (!data || typeof data !== "object") continue;
+        const state = (data as Record<string, unknown>).state;
+        if (state !== "active" && state !== "blocked" && state !== "done") continue;
+
+        const instanceId = typeof event.instance_id === "string" ? event.instance_id : null;
+        const sessionId = typeof event.session_id === "string" ? event.session_id : null;
+        const reasonValue = (data as Record<string, unknown>).reason;
+        const record: DesktopLifecycleRecord = {
+          state,
+          updatedAt: event.ts,
+          instanceId,
+          sessionId,
+          reason: typeof reasonValue === "string" && reasonValue.length > 0 ? reasonValue : null,
+        };
+        const timestamp = Number.isFinite(Date.parse(event.ts)) ? Date.parse(event.ts) : 0;
+        for (const key of new Set(
+          [sessionId, instanceId].filter((value): value is string => !!value),
+        )) {
+          const priorTimestamp = timestamps.get(key);
+          if (priorTimestamp !== undefined && priorTimestamp > timestamp) continue;
+          timestamps.set(key, timestamp);
+          records.set(key, record);
+        }
+      }
+    } catch {
+      // A missing or concurrently rotated event file cannot make tidy unsafe:
+      // absent lifecycle evidence leaves entries unmatched and therefore skipped.
+    } finally {
+      lines?.close();
+    }
+  }
+
+  return records;
+}
+
+/** Select desktop entries whose durable lifecycle is done. */
+export function planTidy(
+  accounts: DesktopAccount[],
+  lifecycleBySession: ReadonlyMap<string, DesktopLifecycleRecord>,
+  opts: DesktopTidyOptions = {},
+): DesktopTidyPlan {
+  const selectedAccounts = accounts.filter(
+    (account) =>
+      !opts.accounts?.length ||
+      opts.accounts.some((prefix) => account.accountUuid.startsWith(prefix)),
+  );
+  const actions: DesktopTidyAction[] = [];
+  const skipped: DesktopTidySkip[] = [];
+
+  for (const account of selectedAccounts) {
+    for (const entry of account.entries) {
+      const lifecycle = lifecycleForEntry(entry, lifecycleBySession);
+      if (entry.isArchived) {
+        skipped.push({ entry, reason: "already_archived", lifecycle });
+        continue;
+      }
+      if (hasLifecyclePrefix(entry.title, "BLOCKED")) {
+        skipped.push({ entry, reason: "blocked_title", lifecycle });
+        continue;
+      }
+      if (lifecycle) {
+        if (lifecycle.state === "done") {
+          actions.push({ entry, source: "lifecycle", lifecycle });
+        } else {
+          skipped.push({ entry, reason: `lifecycle_${lifecycle.state}`, lifecycle });
+        }
+        continue;
+      }
+      if (opts.includeLegacyPrefix && hasLifecyclePrefix(entry.title, "DONE")) {
+        actions.push({ entry, source: "legacy-prefix", lifecycle: null });
+      } else {
+        skipped.push({ entry, reason: "unmatched", lifecycle: null });
+      }
+    }
+  }
+
+  return { actions, skipped };
+}
+
+/** Apply a tidy plan with same-directory temp files and atomic renames. */
+export function applyTidy(plan: DesktopTidyPlan): { archived: number; alreadyArchived: number } {
+  let archived = 0;
+  let alreadyArchived = 0;
+  for (const action of plan.actions) {
+    if (archiveEntry(action.entry.file)) archived++;
+    else alreadyArchived++;
+  }
+  return { archived, alreadyArchived };
+}
+
+function lifecycleForEntry(
+  entry: DesktopSessionEntry,
+  lifecycleBySession: ReadonlyMap<string, DesktopLifecycleRecord>,
+): DesktopLifecycleRecord | null {
+  if (entry.cliSessionId) {
+    const lifecycle = lifecycleBySession.get(entry.cliSessionId);
+    if (lifecycle) return lifecycle;
+  }
+  return entry.sessionId ? (lifecycleBySession.get(entry.sessionId) ?? null) : null;
+}
+
+function hasLifecyclePrefix(title: string | null, state: "BLOCKED" | "DONE"): boolean {
+  if (!title) return false;
+  return new RegExp(`^\\s*\\[${state}\\](?:\\s*-|\\s|$)`, "i").test(title);
+}
+
+function archiveEntry(file: string): boolean {
+  const text = readFileSync(file, "utf8");
+  const raw = JSON.parse(text) as unknown;
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+    throw new Error(`desktop entry is not a JSON object: ${file}`);
+  }
+  const entry = raw as Record<string, unknown>;
+  if (entry.isArchived === true) return false;
+  entry.isArchived = true;
+
+  const pretty = text.includes("\n");
+  const trailingNewline = text.endsWith("\n") ? "\n" : "";
+  const next = `${JSON.stringify(entry, null, pretty ? 2 : undefined)}${trailingNewline}`;
+  const temp = join(dirname(file), `.${basename(file)}.${process.pid}.${randomUUID()}.tmp`);
+  try {
+    writeFileSync(temp, next, { encoding: "utf8", mode: statSync(file).mode });
+    renameSync(temp, file);
+  } finally {
+    try {
+      unlinkSync(temp);
+    } catch {
+      // rename already consumed the temp file, or creation failed before it existed
+    }
+  }
+  return true;
+}