talon-agent 5.26.3 → 5.26.5

package/src/core/layout/claude-relink.ts

@@ -0,0 +1,131 @@
+/**
+ * Keep Claude transcripts resumable when the Talon home moves.
+ *
+ * Claude Code files a session's transcript under
+ * `~/.claude/projects/<slug>/`, where the slug IS the absolute cwd with
+ * every non-alphanumeric character turned into `-`. Talon's cwd is
+ * `<TALON_HOME>/workspace`, so moving the home — `/home/bun/.talon` to
+ * `/data/.talon` when a container switches to the single data root, or a
+ * new TALON_HOME on a host — changes the slug, and every stored session
+ * id then points at a transcript Claude can no longer find.
+ *
+ * This copies the old slug directories' files under the new slug. It
+ * never overwrites a file that already exists there and never moves or
+ * deletes the originals: the old directories stay as they were.
+ */
+
+import { constants } from "node:fs";
+import { copyFile, mkdir, readdir } from "node:fs/promises";
+import { join } from "node:path";
+import { relocateClaudeSlug } from "../backup/sources/relocate.js";
+import { claudeProjectSlug, sessionCwds } from "../backup/sources/sessions.js";
+
+export type RelinkResult = {
+  /** The old slug directory, left in place. */
+  from: string;
+  /** The directory the current home's sessions are looked up in. */
+  to: string;
+  /** Files copied (existing ones are skipped, never replaced). */
+  copied: number;
+};
+
+function matchesSlugOf(name: string, home: string): boolean {
+  return sessionCwds(home)
+    .map(claudeProjectSlug)
+    .some((slug) => name === slug || name.startsWith(`${slug}-`));
+}
+
+/** Copy `src` into `dst` recursively; existing files win. Returns files copied. */
+export async function mergeCopy(src: string, dst: string): Promise<number> {
+  await mkdir(dst, { recursive: true });
+  let copied = 0;
+  for (const entry of await readdir(src, { withFileTypes: true })) {
+    const from = join(src, entry.name);
+    const to = join(dst, entry.name);
+    if (entry.isDirectory()) {
+      copied += await mergeCopy(from, to);
+    } else if (entry.isFile()) {
+      try {
+        await copyFile(from, to, constants.COPYFILE_EXCL);
+        copied++;
+      } catch (err) {
+        if ((err as NodeJS.ErrnoException).code !== "EEXIST") throw err;
+      }
+    }
+  }
+  return copied;
+}
+
+async function listDir(dir: string): Promise<string[]> {
+  try {
+    return (await readdir(dir, { withFileTypes: true }))
+      .filter((e) => e.isDirectory())
+      .map((e) => e.name)
+      .sort();
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Old-slug directories to carry over: every project dir, in any of the
+ * `sources` projects directories, that belongs to one of `previousHomes`
+ * and not to `home`.
+ */
+async function findOldSlugDirs(input: {
+  home: string;
+  previousHomes: readonly string[];
+  sources: readonly string[];
+}): Promise<{ from: string; name: string; previousHome: string }[]> {
+  const found: { from: string; name: string; previousHome: string }[] = [];
+  for (const dir of new Set(input.sources)) {
+    const names = await listDir(dir);
+    for (const previousHome of new Set(input.previousHomes)) {
+      if (previousHome === input.home) continue;
+      for (const name of names) {
+        if (!matchesSlugOf(name, previousHome)) continue;
+        if (matchesSlugOf(name, input.home)) continue;
+        found.push({ from: join(dir, name), name, previousHome });
+      }
+    }
+  }
+  return found;
+}
+
+/**
+ * Copy transcripts filed under a previous home's slug to the current
+ * home's slug. `projectsDir` is where the current Claude looks;
+ * `extraSources` are other projects directories to read from (an old
+ * `~/.claude` still mounted during a migration). Sources in `skip` were
+ * carried over on an earlier boot. A directory that fails to copy is
+ * reported through `onError` and left for the next boot.
+ */
+export async function relinkClaudeProjects(input: {
+  home: string;
+  projectsDir: string;
+  previousHomes: readonly string[];
+  extraSources?: readonly string[];
+  skip?: ReadonlySet<string>;
+  onError?: (from: string, err: unknown) => void;
+}): Promise<RelinkResult[]> {
+  const olds = await findOldSlugDirs({
+    home: input.home,
+    previousHomes: input.previousHomes,
+    sources: [input.projectsDir, ...(input.extraSources ?? [])],
+  });
+  const results: RelinkResult[] = [];
+  for (const { from, name, previousHome } of olds) {
+    if (input.skip?.has(from)) continue;
+    const to = join(
+      input.projectsDir,
+      relocateClaudeSlug(name, previousHome, input.home),
+    );
+    if (to === from) continue;
+    try {
+      results.push({ from, to, copied: await mergeCopy(from, to) });
+    } catch (err) {
+      input.onError?.(from, err);
+    }
+  }
+  return results;
+}

package/src/core/layout/index.ts

@@ -0,0 +1,170 @@
+/**
+ * Storage layout at boot: keep Claude transcripts reachable across a
+ * Talon-home move, and (in a container) warn when a backend's session
+ * store is not on a persistent volume. See docs/docker.md.
+ *
+ * Neither step throws: both are advisory, and a boot must never fail
+ * because a check could not read a directory.
+ */
+
+import { readFile, mkdir } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import writeFileAtomic from "write-file-atomic";
+import { claudeProjectsDir } from "../backup/sources/sessions.js";
+import { raiseAlert } from "../frontend-runtime/alerts.js";
+import { dirs } from "../../util/paths.js";
+import { log, logWarn } from "../../util/log.js";
+import { relinkClaudeProjects, type RelinkResult } from "./claude-relink.js";
+import { readMountTable, type MountEntry } from "./mounts.js";
+import {
+  describeFindings,
+  findEphemeralStores,
+  inContainer,
+  type StorageFinding,
+} from "./persistence.js";
+
+type Env = Readonly<Record<string, string | undefined>>;
+
+/**
+ * Talon homes the published image has used. In a container either may
+ * hold the transcripts of a deployment that moved to the other.
+ */
+const CONTAINER_HOMES = ["/home/bun/.talon", "/data/.talon"] as const;
+/** The pre-/data image's HOME, where an old `~/.claude` may still be mounted. */
+const LEGACY_USER_HOME = "/home/bun";
+
+/** What the last boot recorded: the home it ran in, dirs already copied. */
+type RelinkState = { home: string; merged: string[] };
+
+async function readState(file: string): Promise<RelinkState | null> {
+  try {
+    const raw = JSON.parse(await readFile(file, "utf8")) as unknown;
+    if (!raw || typeof raw !== "object") return null;
+    const { home, merged } = raw as Record<string, unknown>;
+    if (typeof home !== "string") return null;
+    return {
+      home,
+      merged: Array.isArray(merged)
+        ? merged.filter((m): m is string => typeof m === "string")
+        : [],
+    };
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Carry Claude transcripts over from a previous Talon home's project slug.
+ * The previous home comes from the state file (which travels with a copied
+ * `.talon`, so it names the old path after a migration) and, in a
+ * container, from the image's known homes.
+ */
+export async function relinkAfterHomeMove(opts: {
+  home: string;
+  userHome: string;
+  env: Env;
+  container: boolean;
+  stateFile: string;
+}): Promise<RelinkResult[]> {
+  const state = await readState(opts.stateFile);
+  const previousHomes = [
+    ...(state ? [state.home] : []),
+    ...(opts.container ? CONTAINER_HOMES : []),
+  ].filter((h) => h !== opts.home);
+  const projectsDir = claudeProjectsDir(opts.userHome, opts.env);
+  const legacyProjects = join(LEGACY_USER_HOME, ".claude", "projects");
+  const results = await relinkClaudeProjects({
+    home: opts.home,
+    projectsDir,
+    previousHomes,
+    extraSources:
+      opts.container && legacyProjects !== projectsDir ? [legacyProjects] : [],
+    skip: new Set(state?.merged ?? []),
+    onError: (from, err) =>
+      logWarn(
+        "sessions",
+        `Could not copy Claude transcripts from ${from}: ${String(err)} (will retry next boot)`,
+      ),
+  });
+  for (const r of results) {
+    log(
+      "sessions",
+      `Talon home moved: copied ${r.copied} Claude transcript file(s) from ${r.from} to ${r.to} (the original is kept)`,
+    );
+  }
+  if (state?.home !== opts.home || results.length > 0) {
+    const merged = [...(state?.merged ?? []), ...results.map((r) => r.from)];
+    await mkdir(dirname(opts.stateFile), { recursive: true });
+    await writeFileAtomic(
+      opts.stateFile,
+      JSON.stringify({ home: opts.home, merged: [...new Set(merged)] }) + "\n",
+      { mode: 0o600 },
+    );
+  }
+  return results;
+}
+
+/**
+ * In a container, raise one admin alert listing every store that would
+ * not survive a recreate. Returns the findings (empty outside a container
+ * or when the check is switched off with TALON_STORAGE_CHECK=0).
+ */
+export function checkContainerStorage(opts: {
+  talonHome: string;
+  userHome: string;
+  env: Env;
+  config: Record<string, unknown>;
+  container: boolean;
+  mounts?: readonly MountEntry[];
+  raise?: typeof raiseAlert;
+}): StorageFinding[] {
+  if (!opts.container || opts.env.TALON_STORAGE_CHECK === "0") return [];
+  const findings = findEphemeralStores({
+    ...opts,
+    mounts: opts.mounts ?? readMountTable(),
+  });
+  if (findings.length === 0) return [];
+  // Losing only Claude's account file costs a re-onboarding; losing a
+  // session store costs every conversation.
+  const onlyAccountFile = findings.every((f) =>
+    f.path.endsWith(".claude.json"),
+  );
+  (opts.raise ?? raiseAlert)(
+    "storage.ephemeral",
+    describeFindings(findings, opts.env),
+    { severity: onlyAccountFile ? "warn" : "error" },
+  );
+  return findings;
+}
+
+/** Both steps, with this process's paths. Never throws. */
+export async function runStorageLayoutChecks(
+  config: Record<string, unknown>,
+): Promise<void> {
+  const env = process.env;
+  const container = inContainer(env);
+  const userHome = homedir();
+  try {
+    await relinkAfterHomeMove({
+      home: dirs.root,
+      userHome,
+      env,
+      container,
+      stateFile: join(dirs.data, "claude-relink.json"),
+    });
+  } catch (err) {
+    logWarn("sessions", `Claude transcript relink failed: ${String(err)}`);
+  }
+  try {
+    checkContainerStorage({
+      talonHome: dirs.root,
+      userHome,
+      env,
+      config,
+      container,
+    });
+  } catch (err) {
+    logWarn("bot", `Container storage check failed: ${String(err)}`);
+  }
+}

package/src/core/layout/mounts.ts

@@ -0,0 +1,129 @@
+/**
+ * Which filesystem a path lives on, read from /proc/self/mountinfo.
+ *
+ * Inside a container the root filesystem is the image's writable layer:
+ * whatever is written there is gone the moment the container is recreated
+ * (an image update, a NAS app redeploy). Only bind mounts and named
+ * volumes outlive it. This module answers "is this path on one of those?"
+ * without shelling out to `mountpoint` or `df`.
+ */
+
+import { existsSync, readFileSync, realpathSync } from "node:fs";
+import { dirname, join, relative, sep } from "node:path";
+
+/** One line of /proc/self/mountinfo, the fields this module needs. */
+export type MountEntry = {
+  /** Where it is mounted, in this mount namespace. */
+  mountPoint: string;
+  /** The directory of the source filesystem that is mounted there. */
+  root: string;
+  fsType: string;
+  source: string;
+};
+
+/** Where a path's data lives, as far as surviving a container recreate goes. */
+export type Persistence =
+  | "persistent"
+  /** The container's own writable layer (or a tmpfs): lost on recreate. */
+  | "ephemeral"
+  /** An anonymous Docker volume: lost when the container is removed. */
+  | "anonymous";
+
+/** mountinfo escapes space, tab, newline and backslash as octal. */
+function unescape(field: string): string {
+  return field.replace(/\\([0-7]{3})/g, (_, oct: string) =>
+    String.fromCharCode(parseInt(oct, 8)),
+  );
+}
+
+/**
+ * Parse mountinfo text (proc(5)): `id parent maj:min root mountpoint opts
+ * [optional…] - fstype source superopts`. Malformed lines are skipped.
+ */
+export function parseMountInfo(text: string): MountEntry[] {
+  const out: MountEntry[] = [];
+  for (const line of text.split("\n")) {
+    const fields = line.trim().split(" ");
+    const dash = fields.indexOf("-");
+    if (fields.length < 6 || dash < 6 || dash + 2 >= fields.length) continue;
+    out.push({
+      root: unescape(fields[3]),
+      mountPoint: unescape(fields[4]),
+      fsType: fields[dash + 1],
+      source: unescape(fields[dash + 2]),
+    });
+  }
+  return out;
+}
+
+function covers(mountPoint: string, path: string): boolean {
+  if (mountPoint === "/") return true;
+  return path === mountPoint || path.startsWith(mountPoint + "/");
+}
+
+/**
+ * The mount a path is on: the longest covering mount point, and among
+ * equal ones the last listed (a later mount on the same point shadows the
+ * earlier one).
+ */
+export function mountFor(
+  path: string,
+  mounts: readonly MountEntry[],
+): MountEntry | undefined {
+  let best: MountEntry | undefined;
+  for (const m of mounts) {
+    if (!covers(m.mountPoint, path)) continue;
+    if (!best || m.mountPoint.length >= best.mountPoint.length) best = m;
+  }
+  return best;
+}
+
+/** Docker names anonymous volumes by a 64-hex id; named ones by name. */
+const ANONYMOUS_VOLUME = /\/volumes\/[0-9a-f]{64}\/_data(\/|$)/;
+
+/** Classify the mount a path is on. A missing mount counts as ephemeral. */
+export function classifyMount(mount: MountEntry | undefined): Persistence {
+  if (!mount || mount.mountPoint === "/" || mount.fsType === "tmpfs")
+    return "ephemeral";
+  if (ANONYMOUS_VOLUME.test(mount.root)) return "anonymous";
+  return "persistent";
+}
+
+/**
+ * The real path `path` resolves to once created: symlinks in the part that
+ * exists are followed (a `~/.claude` symlinked onto a volume is on that
+ * volume), the part that doesn't is appended as-is.
+ */
+function resolveExisting(path: string): string {
+  let head = path;
+  const tail: string[] = [];
+  while (!existsSync(head)) {
+    const parent = dirname(head);
+    if (parent === head) return path;
+    tail.unshift(relative(parent, head));
+    head = parent;
+  }
+  try {
+    return tail.length ? join(realpathSync(head), ...tail) : realpathSync(head);
+  } catch {
+    return path;
+  }
+}
+
+/** Read this process's mount table; empty when there is none (not Linux). */
+export function readMountTable(file = "/proc/self/mountinfo"): MountEntry[] {
+  try {
+    return parseMountInfo(readFileSync(file, "utf8"));
+  } catch {
+    return [];
+  }
+}
+
+/** Whether `path` would survive the container being recreated. */
+export function persistenceOf(
+  path: string,
+  mounts: readonly MountEntry[],
+): Persistence {
+  const real = resolveExisting(path).split(sep).join("/");
+  return classifyMount(mountFor(real, mounts));
+}

package/src/core/layout/persistence.ts

@@ -0,0 +1,132 @@
+/**
+ * Boot check: in a container, is every backend's session store on a
+ * volume that outlives the container?
+ *
+ * The image keeps everything under one data root (HOME=/data). A setup
+ * that maps only part of it — commonly just `~/.talon` in a NAS "custom
+ * app" — runs fine until the first image update, which silently takes
+ * every Claude/Codex/OpenCode transcript with it: the database still
+ * names those sessions, but nothing is left to resume. This check turns
+ * that into one admin alert at boot, naming each path and the fix.
+ */
+
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { backendStoreDirs } from "../backup/sources/sessions.js";
+import { persistenceOf, type MountEntry, type Persistence } from "./mounts.js";
+
+export type StorageFinding = {
+  path: string;
+  /** What the operator loses with it. */
+  label: string;
+  persistence: Exclude<Persistence, "persistent">;
+};
+
+type Env = Readonly<Record<string, string | undefined>>;
+
+/** Whether this process runs inside a container (Docker, Podman, the image). */
+export function inContainer(
+  env: Env,
+  exists: (path: string) => boolean = existsSync,
+): boolean {
+  return (
+    env.TALON_CONTAINER === "1" ||
+    exists("/.dockerenv") ||
+    exists("/run/.containerenv")
+  );
+}
+
+const LABELS: Record<string, string> = {
+  claude: "Claude Code transcripts and sign-in",
+  codex: "Codex sessions and sign-in",
+  opencode: "OpenCode sessions",
+  kilo: "Kilo sessions",
+  agy: "Antigravity sign-in and conversations",
+};
+
+/** Every path whose loss costs the operator something, with what it holds. */
+function storagePaths(input: {
+  talonHome: string;
+  userHome: string;
+  env: Env;
+  config: Record<string, unknown>;
+}): { path: string; label: string }[] {
+  const paths = [
+    {
+      path: input.talonHome,
+      label: "Talon home: config, chat history, memory, keys",
+    },
+  ];
+  for (const store of backendStoreDirs(
+    input.userHome,
+    input.env,
+    input.config,
+  )) {
+    paths.push({
+      path: store.path,
+      label: LABELS[store.backend] ?? `${store.backend} sessions`,
+    });
+  }
+  // Claude Code keeps its account/onboarding state next to ~/.claude,
+  // not inside it — unless CLAUDE_CONFIG_DIR moves both.
+  if (!input.env.CLAUDE_CONFIG_DIR?.trim()) {
+    paths.push({
+      path: join(input.userHome, ".claude.json"),
+      label: "Claude Code account state",
+    });
+  }
+  return paths;
+}
+
+/**
+ * The stores that would not survive a container recreate. Empty when the
+ * mount table is unknown: no table, no claim either way.
+ */
+export function findEphemeralStores(input: {
+  talonHome: string;
+  userHome: string;
+  env: Env;
+  config: Record<string, unknown>;
+  mounts: readonly MountEntry[];
+}): StorageFinding[] {
+  if (input.mounts.length === 0) return [];
+  const findings: StorageFinding[] = [];
+  const seen = new Set<string>();
+  for (const { path, label } of storagePaths(input)) {
+    if (seen.has(path)) continue;
+    seen.add(path);
+    const persistence = persistenceOf(path, input.mounts);
+    if (persistence !== "persistent")
+      findings.push({ path, label, persistence });
+  }
+  return findings;
+}
+
+const WHERE: Record<StorageFinding["persistence"], string> = {
+  ephemeral: "container filesystem, lost on every image update",
+  anonymous: "anonymous Docker volume, lost when the container is removed",
+};
+
+/** The admin alert text for a set of findings. */
+export function describeFindings(
+  findings: readonly StorageFinding[],
+  env: Env,
+): string {
+  const lines = findings.map(
+    (f) => `• ${f.path}: ${f.label} (${WHERE[f.persistence]})`,
+  );
+  const legacy =
+    env.TALON_LAYOUT === "legacy"
+      ? "\nThis container runs the old /home/bun layout (only some paths mounted)."
+      : "";
+  return (
+    "Some of Talon's state is not on a persistent volume and will be lost " +
+    "when this container is recreated:\n" +
+    lines.join("\n") +
+    legacy +
+    "\n\nFix: mount one volume at /data and run with HOME=/data (the image " +
+    "default), after copying the paths above into it. Nothing is moved for " +
+    'you. Steps: docs/docker.md, "Upgrading from the old layout".' +
+    "\nSilence this check with TALON_STORAGE_CHECK=0."
+  );
+}

package/src/frontend/presentation/backup-panel.ts

@@ -180,7 +180,13 @@ function storageLines(f: ReportFormatter, status: BackupStatus): string[] {
   if (policy) {
     lines.push(
       `${f.bold("Retention:")} newest ${policy.keepLocal} kept here, ` +
-        `${policy.keepRemote} per target · pinned ones are never pruned`,
+        `${policy.keepRemote} per target` +
+        (policy.keepDaily ? ` · 1/day for ${policy.keepDaily}d` : "") +
+        (policy.keepWeekly ? ` · 1/week for ${policy.keepWeekly}w` : "") +
+        (policy.keepCheckpoints
+          ? ` · ${policy.keepCheckpoints} checkpoints`
+          : "") +
+        ` · pinned ones and the last verified are never pruned`,
     );
     lines.push(
       policy.encrypted

package/src/plugins/mempalace/provision.ts

@@ -21,7 +21,6 @@
  */
 
 import { existsSync } from "node:fs";
-import { homedir } from "node:os";
 import { dirname, join, resolve } from "node:path";
 import type { DoctorCheck } from "../../core/doctor/index.js";
 import {
@@ -41,6 +40,7 @@ import {
   type ProvisionState,
 } from "../../core/plugin/provision.js";
 import { dirs, files } from "../../util/paths.js";
+import { userHome } from "../../util/fs-path.js";
 
 /**
  * The mempalace version Talon installs and reconciles the managed venv
@@ -89,7 +89,7 @@ export interface MempalaceSection {
  */
 export function resolveMempalacePaths(
   section: MempalaceSection | undefined,
-  home = homedir(),
+  home = userHome(),
 ): { pythonPath: string; palacePath: string } {
   return {
     pythonPath: resolve(
@@ -166,7 +166,7 @@ export async function provisionMempalace(
   const exec = deps.exec ?? runStep;
   const platform = deps.platform ?? process.platform;
   const now = deps.now ?? Date.now;
-  const home = deps.home ?? homedir();
+  const home = deps.home ?? userHome();
   const pathExists = deps.pathExists ?? existsSync;
   const target = section.version ?? MEMPALACE_PINNED_VERSION;
 
@@ -606,7 +606,7 @@ export async function inspectMempalace(
 ): Promise<DoctorCheck[]> {
   const exec = deps.exec ?? runStep;
   const pathExists = deps.pathExists ?? existsSync;
-  const home = deps.home ?? homedir();
+  const home = deps.home ?? userHome();
   const { pythonPath: python } = resolveMempalacePaths(section, home);
   const pin = section.version ?? MEMPALACE_PINNED_VERSION;
   const managed =

package/src/plugins/playwright/provision.ts

@@ -14,7 +14,6 @@
  */
 
 import { existsSync, readFileSync, readdirSync } from "node:fs";
-import { homedir } from "node:os";
 import { dirname, join, resolve } from "node:path";
 import type { DoctorCheck } from "../../core/doctor/index.js";
 import {
@@ -34,6 +33,7 @@ import {
   bundledPlaywrightVersion,
   couplingError,
 } from "./version-coupling.js";
+import { userHome } from "../../util/fs-path.js";
 
 /** Engines whose builds Playwright manages (vs system channels). */
 const MANAGED_ENGINES = new Set(["chromium", "firefox", "webkit"]);
@@ -173,7 +173,7 @@ function browserPresent(
 ): boolean {
   const root = browsersRoot(
     deps.platform ?? process.platform,
-    deps.home ?? homedir(),
+    deps.home ?? userHome(),
     deps.env ?? process.env,
   );
   const present = new Set((deps.listDir ?? safeListDir)(root));