pim-agent 0.0.1 → 0.9.0

package/packages/core/src/shared/SearchRender.ts

@@ -0,0 +1,82 @@
+import { OutputBudget } from "./OutputBudget";
+import { Paths } from "./Paths";
+
+export const NO_MATCHES = "No matches.";
+
+export type SearchPathFormat = "relative" | "absolute";
+
+export type SearchPathOptions = {
+  readonly cwd: string;
+  readonly pathFormat: SearchPathFormat;
+};
+
+export type SearchList = {
+  readonly body: string;
+  readonly totalItems: number;
+  readonly visibleItems: number;
+  readonly truncated: boolean;
+};
+
+export type SubjectTitleOptions = {
+  readonly subject: string;
+  readonly path: string | undefined;
+  readonly suffix?: string | undefined;
+  readonly cwd: string;
+};
+
+function formatPath(path: string, options: SearchPathOptions): string {
+  return options.pathFormat === "absolute"
+    ? path
+    : Paths.displayRelative(path, options.cwd);
+}
+
+function subjectTitle(options: SubjectTitleOptions): string {
+  const resolved =
+    options.path === undefined
+      ? undefined
+      : Paths.resolve(options.path, options.cwd);
+  const dir =
+    resolved === undefined || resolved === options.cwd
+      ? undefined
+      : Paths.displayRelative(resolved, options.cwd);
+  const target = joinTarget(dir, options.suffix);
+  const location = target ? ` in ${target}` : "";
+  return `${options.subject}${location}`;
+}
+
+function joinTarget(
+  dir: string | undefined,
+  suffix: string | undefined
+): string | undefined {
+  if (suffix === undefined) {
+    return dir;
+  }
+  return dir === undefined ? suffix : `${dir}/${suffix}`;
+}
+
+function capList(lines: readonly string[], headLimit: number): SearchList {
+  if (lines.length === 0) {
+    return {
+      body: NO_MATCHES,
+      totalItems: 0,
+      visibleItems: 0,
+      truncated: false,
+    };
+  }
+
+  const { visible } = OutputBudget.applyByteCap(lines.slice(0, headLimit));
+
+  return {
+    body: visible.join("\n"),
+    totalItems: lines.length,
+    visibleItems: visible.length,
+    truncated: visible.length < lines.length,
+  };
+}
+
+export const SearchRender = {
+  NO_MATCHES,
+  formatPath,
+  subjectTitle,
+  capList,
+};

package/packages/core/src/shared/SendFile.ts

@@ -0,0 +1,23 @@
+import { FsErrors } from "./FsErrors";
+import { Paths } from "./Paths";
+
+const MAX_BYTES = 50 * 1024 * 1024;
+
+async function validate(
+  rawPath: string,
+  cwd: string
+): Promise<{ readonly path: string; readonly size: number }> {
+  const path = Paths.resolve(rawPath, cwd);
+  const st = await FsErrors.statOrThrow(path);
+  if (!st.isFile()) {
+    throw new Error(`${rawPath} is not a regular file.`);
+  }
+  if (st.size > MAX_BYTES) {
+    throw new Error(
+      `${rawPath} is ${st.size} bytes; max allowed is ${MAX_BYTES}.`
+    );
+  }
+  return { path, size: st.size };
+}
+
+export const SendFile = { MAX_BYTES, validate };

package/packages/core/src/shared/SpillCache.ts

@@ -0,0 +1,78 @@
+import { readdirSync, statSync, unlinkSync } from "node:fs";
+import { mkdir, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { FsErrors } from "./FsErrors";
+import { Paths } from "./Paths";
+import { Sweeper } from "./Sweeper";
+
+// UUIDv7-named spills and content-addressed ones, which share the TTL.
+const SPILL_FILE_RE =
+  /^[a-z0-9]+-(?:[0-9a-f]{8}-[0-9a-f]{4}-7[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|[0-9a-f]{64})\.[a-z0-9]+$/;
+
+const TTL_MS = 7 * 24 * 60 * 60 * 1000;
+const SWEEP_INTERVAL_MS = 60 * 60 * 1000;
+
+function dir(): string {
+  return join(Paths.pimHomeDir(), "cache");
+}
+
+/** Writes under a caller-chosen name; an existing file of that name is kept, so content-addressed names re-write for free. */
+async function writeNamed(
+  name: string,
+  data: string | Uint8Array
+): Promise<string | null> {
+  const cacheDir = dir();
+  const path = join(cacheDir, name);
+  try {
+    await mkdir(cacheDir, { recursive: true, mode: 0o700 });
+    await writeFile(path, data, { flag: "wx", mode: 0o600 });
+    return path;
+  } catch (error) {
+    return FsErrors.code(error) === "EEXIST" ? path : null;
+  }
+}
+
+async function write(
+  prefix: string,
+  ext: string,
+  data: string | Uint8Array
+): Promise<string | null> {
+  return writeNamed(`${prefix}-${Bun.randomUUIDv7()}.${ext}`, data);
+}
+
+function cleanup(cacheDir = dir(), now = Date.now()): void {
+  let entries: string[];
+  try {
+    entries = readdirSync(cacheDir);
+  } catch {
+    return;
+  }
+
+  const cutoff = now - TTL_MS;
+  for (const name of entries) {
+    if (!SPILL_FILE_RE.test(name)) {
+      continue;
+    }
+    const path = join(cacheDir, name);
+    try {
+      const metadata = statSync(path);
+      if (metadata.isFile() && metadata.mtimeMs < cutoff) {
+        unlinkSync(path);
+      }
+    } catch {}
+  }
+}
+
+function installSweeper(): void {
+  Sweeper.install({ cleanup, intervalMs: SWEEP_INTERVAL_MS });
+}
+
+export const SpillCache = {
+  TTL_MS,
+  SWEEP_INTERVAL_MS,
+  dir,
+  write,
+  writeNamed,
+  cleanup,
+  installSweeper,
+};

package/packages/core/src/shared/SubagentLogs.ts

@@ -0,0 +1,102 @@
+import { readdirSync, rmSync, statSync } from "node:fs";
+import { mkdir, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { Paths } from "./Paths";
+import { Sweeper } from "./Sweeper";
+
+// The parent id names a directory; a call id is opaque provider data, hashed rather than trusted as a segment.
+const ID_RE = /^[A-Za-z0-9_-]{1,128}$/;
+// A call id arrives off the wire: bound what gets hashed.
+const MAX_CALL_ID_LENGTH = 4096;
+
+const TTL_MS = 30 * 24 * 60 * 60 * 1000;
+const SWEEP_INTERVAL_MS = 60 * 60 * 1000;
+
+// Must stay outside pi's sessions root, which `SessionRegistry` globs as the session catalogue.
+function dir(): string {
+  return join(Paths.pimHomeDir(), "subagents");
+}
+
+function pathFor(parentSessionId: string, callId: string): string | null {
+  if (
+    !ID_RE.test(parentSessionId) ||
+    callId.length === 0 ||
+    callId.length > MAX_CALL_ID_LENGTH
+  ) {
+    return null;
+  }
+  return join(
+    dir(),
+    parentSessionId,
+    `${Bun.SHA256.hash(callId, "hex")}.jsonl`
+  );
+}
+
+// Create the log empty with explicit modes: a file pi creates takes the process umask.
+async function create(
+  parentSessionId: string,
+  callId: string
+): Promise<string | null> {
+  const path = pathFor(parentSessionId, callId);
+  if (!path) {
+    return null;
+  }
+  try {
+    await mkdir(dirname(path), { recursive: true, mode: 0o700 });
+    await writeFile(path, "", { flag: "wx", mode: 0o600 });
+    return path;
+  } catch {
+    return null;
+  }
+}
+
+// Expire a parent's children together by newest mtime, or a long run loses its earlier subagents.
+function cleanup(root = dir(), now = Date.now()): void {
+  let names: string[];
+  try {
+    names = readdirSync(root);
+  } catch {
+    return;
+  }
+
+  const cutoff = now - TTL_MS;
+  for (const name of names) {
+    if (!ID_RE.test(name)) {
+      continue;
+    }
+    const parentDir = join(root, name);
+    try {
+      if (!statSync(parentDir).isDirectory()) {
+        continue;
+      }
+      if (newestMtime(parentDir) >= cutoff) {
+        continue;
+      }
+      rmSync(parentDir, { recursive: true, force: true });
+    } catch {}
+  }
+}
+
+function newestMtime(parentDir: string): number {
+  let newest = statSync(parentDir).mtimeMs;
+  for (const name of readdirSync(parentDir)) {
+    try {
+      newest = Math.max(newest, statSync(join(parentDir, name)).mtimeMs);
+    } catch {}
+  }
+  return newest;
+}
+
+function installSweeper(): void {
+  Sweeper.install({ cleanup, intervalMs: SWEEP_INTERVAL_MS });
+}
+
+export const SubagentLogs = {
+  TTL_MS,
+  SWEEP_INTERVAL_MS,
+  dir,
+  pathFor,
+  create,
+  cleanup,
+  installSweeper,
+};