privateer-agent 0.2.1 → 0.3.0

package/src/mcp/oauth.ts

@@ -1,245 +0,0 @@
-import { createServer, type Server as HttpServer } from "node:http";
-import { spawn } from "node:child_process";
-import { existsSync, readFileSync, writeFileSync, mkdirSync, chmodSync, rmSync } from "node:fs";
-import { join } from "node:path";
-import { createHash, randomBytes } from "node:crypto";
-import type { OAuthClientProvider } from "@modelcontextprotocol/sdk/client/auth.js";
-import type {
-  OAuthClientInformation,
-  OAuthClientInformationFull,
-  OAuthClientMetadata,
-  OAuthTokens,
-} from "@modelcontextprotocol/sdk/shared/auth.js";
-import { globalPaths } from "../config/paths.ts";
-
-// Called when interactive consent is needed, so the host (e.g. the TUI) can show
-// the URL in case the browser doesn't open on its own.
-export type AuthorizePrompt = (info: { server: string; url: string }) => void;
-
-// Everything we persist between runs for one remote server. Written owner-only
-// (0600) since it holds OAuth tokens. `port` is pinned so the loopback redirect
-// URI stays stable across runs (and thus matches the registered client).
-interface AuthStore {
-  port?: number;
-  state?: string;
-  codeVerifier?: string;
-  clientInformation?: OAuthClientInformationFull;
-  tokens?: OAuthTokens;
-}
-
-const DEFAULT_PORT = 7777;
-const CALLBACK_PATH = "/oauth/callback";
-
-function authDir(): string {
-  return join(globalPaths().dir, "mcp-auth");
-}
-
-// One file per server, keyed by a short hash of its URL.
-function storePath(serverUrl: string): string {
-  const hash = createHash("sha256").update(serverUrl).digest("hex").slice(0, 16);
-  return join(authDir(), `${hash}.json`);
-}
-
-// An interactive OAuth 2.1 (PKCE + dynamic client registration) provider that
-// persists credentials to disk and catches the redirect on a loopback server.
-// One instance per remote server connection.
-export class FileOAuthProvider implements OAuthClientProvider {
-  private store: AuthStore;
-  private readonly path: string;
-  private port: number;
-  private server?: HttpServer;
-  private redirect?: { resolve: (code: string) => void; reject: (e: Error) => void };
-
-  constructor(
-    private readonly serverName: string,
-    private readonly serverUrl: string,
-    private readonly onAuthorize?: AuthorizePrompt,
-  ) {
-    this.path = storePath(serverUrl);
-    this.store = readStore(this.path);
-    const envPort = Number(process.env.PRIVATEER_OAUTH_PORT);
-    this.port = this.store.port ?? (Number.isInteger(envPort) ? envPort : DEFAULT_PORT);
-  }
-
-  get redirectUrl(): string {
-    return `http://127.0.0.1:${this.port}${CALLBACK_PATH}`;
-  }
-
-  get clientMetadata(): OAuthClientMetadata {
-    return {
-      client_name: "Privateer",
-      redirect_uris: [this.redirectUrl],
-      grant_types: ["authorization_code", "refresh_token"],
-      response_types: ["code"],
-      token_endpoint_auth_method: "none", // public client (PKCE), no secret
-    };
-  }
-
-  clientInformation(): OAuthClientInformation | undefined {
-    return this.store.clientInformation;
-  }
-
-  saveClientInformation(info: OAuthClientInformationFull): void {
-    this.store.clientInformation = info;
-    this.persist();
-  }
-
-  tokens(): OAuthTokens | undefined {
-    return this.store.tokens;
-  }
-
-  saveTokens(tokens: OAuthTokens): void {
-    this.store.tokens = tokens;
-    this.persist();
-  }
-
-  saveCodeVerifier(verifier: string): void {
-    this.store.codeVerifier = verifier;
-    this.persist();
-  }
-
-  codeVerifier(): string {
-    if (!this.store.codeVerifier) throw new Error("no PKCE code verifier saved");
-    return this.store.codeVerifier;
-  }
-
-  state(): string {
-    this.store.state = randomBytes(16).toString("hex");
-    this.persist();
-    return this.store.state;
-  }
-
-  // Drop persisted credentials when the server says they're stale, so the next
-  // connect re-runs discovery / re-authorizes instead of looping on 401s.
-  invalidateCredentials(scope: "all" | "client" | "tokens" | "verifier" | "discovery"): void {
-    if (scope === "all") this.store = { port: this.store.port };
-    else if (scope === "client") delete this.store.clientInformation;
-    else if (scope === "tokens") delete this.store.tokens;
-    else if (scope === "verifier") delete this.store.codeVerifier;
-    this.persist();
-  }
-
-  // Bind the loopback listener, open the browser, and arm the wait. The SDK calls
-  // this during auth() right before it throws UnauthorizedError.
-  async redirectToAuthorization(authorizationUrl: URL): Promise<void> {
-    await this.listen();
-    this.onAuthorize?.({ server: this.serverName, url: authorizationUrl.toString() });
-    openBrowser(authorizationUrl.toString());
-  }
-
-  // Resolves with the authorization code once the user is redirected back. Caller
-  // passes it to transport.finishAuth(). Always tears the listener down after.
-  waitForCode(timeoutMs = 300_000): Promise<string> {
-    return new Promise<string>((resolve, reject) => {
-      const done = (fn: () => void) => {
-        clearTimeout(timer);
-        this.closeServer();
-        fn();
-      };
-      const timer = setTimeout(
-        () => done(() => reject(new Error(`OAuth for "${this.serverName}" timed out`))),
-        timeoutMs,
-      );
-      this.redirect = {
-        resolve: (code) => done(() => resolve(code)),
-        reject: (e) => done(() => reject(e)),
-      };
-    });
-  }
-
-  private listen(): Promise<void> {
-    if (this.server) return Promise.resolve();
-    return new Promise<void>((resolve, reject) => {
-      const server = createServer((req, res) => this.handleCallback(req.url ?? "", res));
-      server.once("error", (err) => reject(new Error(`OAuth loopback on port ${this.port}: ${err.message}`)));
-      server.listen(this.port, "127.0.0.1", () => {
-        this.server = server;
-        // Capture the actually-bound port (matters when port 0 = ephemeral) and pin
-        // it, so future runs reuse the same redirect URI the client registered with.
-        const addr = server.address();
-        if (addr && typeof addr === "object") this.port = addr.port;
-        this.store.port = this.port;
-        this.persist();
-        resolve();
-      });
-    });
-  }
-
-  private handleCallback(rawUrl: string, res: import("node:http").ServerResponse): void {
-    const url = new URL(rawUrl, this.redirectUrl);
-    if (url.pathname !== CALLBACK_PATH) {
-      res.writeHead(404).end();
-      return;
-    }
-    const code = url.searchParams.get("code");
-    const err = url.searchParams.get("error");
-    const state = url.searchParams.get("state");
-    res.writeHead(200, { "content-type": "text/html" });
-    res.end(
-      `<!doctype html><body style="font-family:system-ui;padding:2rem">` +
-        `<h2>${code ? "Authorized — you can close this tab." : "Authorization failed."}</h2>` +
-        `</body>`,
-    );
-    if (err) return this.redirect?.reject(new Error(`authorization error: ${err}`));
-    if (state && this.store.state && state !== this.store.state) {
-      return this.redirect?.reject(new Error("OAuth state mismatch (possible CSRF)"));
-    }
-    if (code) this.redirect?.resolve(code);
-    else this.redirect?.reject(new Error("authorization callback missing code"));
-  }
-
-  private closeServer(): void {
-    this.server?.close();
-    this.server = undefined;
-  }
-
-  private persist(): void {
-    mkdirSync(authDir(), { recursive: true });
-    tryChmod(authDir(), 0o700);
-    writeFileSync(this.path, JSON.stringify(this.store, null, 2) + "\n", { encoding: "utf8", mode: 0o600 });
-    tryChmod(this.path, 0o600);
-  }
-}
-
-function readStore(path: string): AuthStore {
-  if (!existsSync(path)) return {};
-  try {
-    return JSON.parse(readFileSync(path, "utf8")) as AuthStore;
-  } catch {
-    return {};
-  }
-}
-
-function tryChmod(path: string, mode: number): void {
-  try {
-    chmodSync(path, mode);
-  } catch {
-    /* non-POSIX filesystem — best effort */
-  }
-}
-
-// Open a URL in the user's default browser. Best-effort and non-blocking; if it
-// fails the URL was already surfaced via the AuthorizePrompt callback.
-function openBrowser(url: string): void {
-  // Headless / CI / tests: skip the launch; the URL is surfaced via AuthorizePrompt.
-  if (process.env.PRIVATEER_NO_BROWSER) return;
-  const cmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
-  try {
-    const child = spawn(cmd, [url], { stdio: "ignore", detached: true, shell: process.platform === "win32" });
-    child.on("error", () => {});
-    child.unref();
-  } catch {
-    /* headless / no browser — user uses the printed URL */
-  }
-}
-
-// Wipe stored OAuth state for one server (used by `/mcp logout`).
-export function clearStoredAuth(serverUrl: string): void {
-  const path = storePath(serverUrl);
-  if (existsSync(path)) rmSync(path, { force: true });
-}
-
-// Whether we hold an OAuth access token for this server (for `/mcp` status).
-export function hasStoredAuth(serverUrl: string): boolean {
-  return Boolean(readStore(storePath(serverUrl)).tokens?.access_token);
-}

package/src/memory/auto.ts

@@ -1,146 +0,0 @@
-import { mkdirSync, writeFileSync, readFileSync, existsSync, readdirSync, rmSync } from "node:fs";
-import { join } from "node:path";
-import { globalDir } from "../config/load.ts";
-import { parseFrontmatter } from "../commands/custom.ts";
-import { projectKey } from "./store.ts";
-
-// Agent-authored "auto-memory": durable facts the agent records across runs, modeled on
-// Claude Code's memory files. Each memory is one markdown file with flat frontmatter
-// (so it round-trips through parseFrontmatter, which only reads `key: value` lines) plus
-// a body. A per-scope MEMORY.md index lists them and is recalled into the system prompt.
-//
-// Two scopes: "project" memories live under the per-project dir (keyed by cwd) and only
-// recall in that project; "global" memories live under the global dir and recall
-// everywhere. Project memories win on a name clash.
-
-export type MemoryType = "user" | "feedback" | "project" | "reference";
-export type MemoryScope = "project" | "global";
-
-export interface MemoryRecord {
-  name: string;
-  description: string;
-  type: MemoryType;
-  scope: MemoryScope;
-  body: string;
-  path: string;
-}
-
-const INDEX_FILE = "MEMORY.md";
-const VALID_TYPES: MemoryType[] = ["user", "feedback", "project", "reference"];
-
-function memoryDir(scope: MemoryScope, cwd: string): string {
-  return scope === "global"
-    ? join(globalDir(), "memory")
-    : join(globalDir(), "projects", projectKey(cwd), "memory");
-}
-
-// Constrain a proposed name to a safe, kebab-ish file stem (no path traversal, no spaces).
-export function sanitizeName(name: string): string {
-  return name
-    .toLowerCase()
-    .replace(/[^a-z0-9._-]+/g, "-")
-    .replace(/^[-.]+|[-.]+$/g, "")
-    .slice(0, 80);
-}
-
-function coerceType(raw: string | undefined): MemoryType {
-  return VALID_TYPES.includes(raw as MemoryType) ? (raw as MemoryType) : "project";
-}
-
-function readDir(scope: MemoryScope, cwd: string): MemoryRecord[] {
-  const dir = memoryDir(scope, cwd);
-  if (!existsSync(dir)) return [];
-  const out: MemoryRecord[] = [];
-  for (const file of readdirSync(dir)) {
-    if (!file.endsWith(".md") || file === INDEX_FILE) continue;
-    const path = join(dir, file);
-    const { meta, body } = parseFrontmatter(readFileSync(path, "utf8"));
-    const name = meta.name || file.replace(/\.md$/, "");
-    out.push({
-      name,
-      description: meta.description ?? "",
-      type: coerceType(meta.type),
-      scope,
-      body: body.trim(),
-      path,
-    });
-  }
-  return out;
-}
-
-// Regenerate a scope's MEMORY.md from the memory files it contains. Regenerating (vs.
-// editing in place) keeps the index free of stale or duplicate lines.
-function rebuildIndex(scope: MemoryScope, cwd: string): void {
-  const dir = memoryDir(scope, cwd);
-  const records = readDir(scope, cwd).sort((a, b) => a.name.localeCompare(b.name));
-  const indexPath = join(dir, INDEX_FILE);
-  if (records.length === 0) {
-    if (existsSync(indexPath)) rmSync(indexPath, { force: true });
-    return;
-  }
-  const lines = [
-    "# Memory Index",
-    "",
-    ...records.map((r) => `- [${r.name}](${r.name}.md) — ${r.description}`),
-    "",
-  ];
-  mkdirSync(dir, { recursive: true });
-  writeFileSync(indexPath, lines.join("\n"), "utf8");
-}
-
-// All memories visible from this cwd: project entries override global on a name clash.
-export function listMemories(cwd: string): MemoryRecord[] {
-  const byName = new Map<string, MemoryRecord>();
-  for (const r of readDir("global", cwd)) byName.set(r.name, r);
-  for (const r of readDir("project", cwd)) byName.set(r.name, r);
-  return [...byName.values()].sort((a, b) => a.name.localeCompare(b.name));
-}
-
-export function readMemory(cwd: string, name: string): MemoryRecord | null {
-  const key = sanitizeName(name);
-  return listMemories(cwd).find((r) => r.name === key) ?? null;
-}
-
-export function saveMemory(
-  cwd: string,
-  input: { name: string; description: string; type?: MemoryType; scope?: MemoryScope; body: string },
-): MemoryRecord {
-  const scope: MemoryScope = input.scope === "global" ? "global" : "project";
-  const name = sanitizeName(input.name);
-  if (!name) throw new Error("memory name is empty after sanitizing");
-  const type = coerceType(input.type);
-  const dir = memoryDir(scope, cwd);
-  mkdirSync(dir, { recursive: true });
-  const path = join(dir, `${name}.md`);
-  const frontmatter = [
-    "---",
-    `name: ${name}`,
-    `description: ${input.description.replace(/\n/g, " ").trim()}`,
-    `type: ${type}`,
-    `scope: ${scope}`,
-    "---",
-  ].join("\n");
-  writeFileSync(path, `${frontmatter}\n${input.body.trim()}\n`, "utf8");
-  rebuildIndex(scope, cwd);
-  return { name, description: input.description, type, scope, body: input.body.trim(), path };
-}
-
-export function deleteMemory(cwd: string, name: string): MemoryRecord | null {
-  const existing = readMemory(cwd, name);
-  if (!existing) return null;
-  rmSync(existing.path, { force: true });
-  rebuildIndex(existing.scope, cwd);
-  return existing;
-}
-
-// The memory index(es) to recall into the system prompt, or null when there are none.
-export function loadMemoryContext(cwd: string): string | null {
-  const sections: string[] = [];
-  for (const scope of ["project", "global"] as const) {
-    const indexPath = join(memoryDir(scope, cwd), INDEX_FILE);
-    if (!existsSync(indexPath)) continue;
-    const body = readFileSync(indexPath, "utf8").trim();
-    if (body) sections.push(`(${scope})\n${body}`);
-  }
-  return sections.length ? sections.join("\n\n") : null;
-}

package/src/memory/checkpoints.ts

@@ -1,227 +0,0 @@
-import { createHash } from "node:crypto";
-import { existsSync, readFileSync, writeFileSync, mkdirSync, rmSync, readdirSync } from "node:fs";
-import { dirname, join } from "node:path";
-
-// How many of the most recent checkpoints to keep. Older ones are dropped and any blobs
-// they alone referenced are garbage-collected, so a long-lived session stays bounded.
-const DEFAULT_MAX_CHECKPOINTS = 100;
-
-// The on-disk state of a single file at a moment in time. `existed: false` means the
-// file was absent (so restoring deletes it). When it existed, `hash` keys its content
-// in the blob store rather than inlining it, so the index stays small and repeated
-// content across turns is stored once.
-export interface FileState {
-  existed: boolean;
-  hash?: string;
-}
-
-export interface Checkpoint {
-  id: string;
-  label: string;
-  ts: number;
-  messagesLength: number; // engine.messages length at checkpoint time
-  committedLength: number; // UI transcript length at checkpoint time
-  files: Record<string, FileState>; // absolute path → state captured at checkpoint time
-}
-
-export type RewindScope = "conversation" | "files" | "both";
-
-// The serialized index for one session's checkpoints. Blob bodies live separately
-// (content-addressed under `blobs/`), so this stays compact regardless of file size.
-interface PersistedIndex {
-  seq: number;
-  original: Record<string, FileState>;
-  touched: string[];
-  checkpoints: Checkpoint[];
-}
-
-// Content-addressed file-content store. Backed by disk when a directory is given (so
-// snapshots survive a restart) or an in-memory map otherwise (live-session only, used
-// by tests and any non-persisted store). Identical content is stored once under its
-// sha256, which keeps growth bounded since most turns touch few files and content
-// repeats heavily across checkpoints.
-class BlobStore {
-  private mem = new Map<string, string>();
-
-  constructor(private dir?: string) {}
-
-  put(content: string): string {
-    const hash = createHash("sha256").update(content).digest("hex");
-    if (this.dir) {
-      const p = join(this.dir, hash);
-      if (!existsSync(p)) {
-        mkdirSync(this.dir, { recursive: true });
-        writeFileSync(p, content, "utf8");
-      }
-    } else {
-      this.mem.set(hash, content);
-    }
-    return hash;
-  }
-
-  get(hash: string): string | undefined {
-    if (this.dir) {
-      const p = join(this.dir, hash);
-      return existsSync(p) ? readFileSync(p, "utf8") : undefined;
-    }
-    return this.mem.get(hash);
-  }
-
-  // Drop every stored blob whose hash isn't in `live`.
-  keep(live: Set<string>): void {
-    if (this.dir) {
-      if (!existsSync(this.dir)) return;
-      for (const name of readdirSync(this.dir)) {
-        if (!live.has(name)) rmSync(join(this.dir, name), { force: true });
-      }
-    } else {
-      for (const h of this.mem.keys()) if (!live.has(h)) this.mem.delete(h);
-    }
-  }
-}
-
-// Undo for the agent's edits, durable when bound to a session directory. A checkpoint
-// is taken before each turn, capturing the conversation length and the current content
-// of every file the session has modified so far. The first time any file is mutated we
-// also record its original (pre-modification) state, so a rewind can restore files
-// first touched after a checkpoint back to their baseline — or delete files the session
-// created. When constructed with a directory the index and blobs are persisted there,
-// so `/rewind` keeps working after the process restarts and the session is resumed.
-export class CheckpointStore {
-  private original = new Map<string, FileState>();
-  private touched = new Set<string>();
-  private checkpoints: Checkpoint[] = [];
-  private seq = 0;
-  private blobs: BlobStore;
-
-  constructor(
-    private dir?: string,
-    private maxCheckpoints = DEFAULT_MAX_CHECKPOINTS,
-  ) {
-    this.blobs = new BlobStore(dir ? join(dir, "blobs") : undefined);
-  }
-
-  // Rehydrate a store from a session's checkpoint directory (or a fresh, empty store
-  // bound to that directory when nothing has been persisted there yet).
-  static load(dir: string): CheckpointStore {
-    const store = new CheckpointStore(dir);
-    store.loadFrom(dir);
-    return store;
-  }
-
-  private loadFrom(dir: string): void {
-    try {
-      const p = join(dir, "index.json");
-      if (!existsSync(p)) return;
-      const data = JSON.parse(readFileSync(p, "utf8")) as PersistedIndex;
-      this.seq = data.seq ?? 0;
-      this.original = new Map(Object.entries(data.original ?? {}));
-      this.touched = new Set(data.touched ?? []);
-      this.checkpoints = data.checkpoints ?? [];
-    } catch {
-      /* corrupt index: start fresh rather than crash */
-    }
-  }
-
-  // Re-point this store at a different session's persisted checkpoints, replacing all
-  // in-memory state. Used when `/resume` swaps the live conversation for a stored one:
-  // the engine's existing recordMutation closure keeps pointing at this instance, so we
-  // mutate it in place rather than constructing a new store.
-  adopt(dir: string): void {
-    this.dir = dir;
-    this.blobs = new BlobStore(join(dir, "blobs"));
-    this.original = new Map();
-    this.touched = new Set();
-    this.checkpoints = [];
-    this.seq = 0;
-    this.loadFrom(dir);
-  }
-
-  private captureFileState(abs: string): FileState {
-    if (!existsSync(abs)) return { existed: false };
-    try {
-      return { existed: true, hash: this.blobs.put(readFileSync(abs, "utf8")) };
-    } catch {
-      return { existed: false };
-    }
-  }
-
-  private applyFileState(abs: string, state: FileState): void {
-    if (state.existed && state.hash != null) {
-      mkdirSync(dirname(abs), { recursive: true });
-      writeFileSync(abs, this.blobs.get(state.hash) ?? "", "utf8");
-    } else if (existsSync(abs)) {
-      rmSync(abs, { force: true });
-    }
-  }
-
-  private persist(): void {
-    if (!this.dir) return;
-    try {
-      mkdirSync(this.dir, { recursive: true });
-      const data: PersistedIndex = {
-        seq: this.seq,
-        original: Object.fromEntries(this.original),
-        touched: [...this.touched],
-        checkpoints: this.checkpoints,
-      };
-      writeFileSync(join(this.dir, "index.json"), JSON.stringify(data), "utf8");
-    } catch {
-      /* persistence is best-effort; the in-memory store stays usable */
-    }
-  }
-
-  // Called by write/edit immediately before they mutate `abs`.
-  recordMutation(abs: string): void {
-    if (!this.original.has(abs)) this.original.set(abs, this.captureFileState(abs));
-    this.touched.add(abs);
-    this.persist();
-  }
-
-  create(opts: { messagesLength: number; committedLength: number; label: string }): Checkpoint {
-    const files: Record<string, FileState> = {};
-    for (const p of this.touched) files[p] = this.captureFileState(p);
-    const cp: Checkpoint = {
-      id: `cp${++this.seq}`,
-      label: opts.label.replace(/\s+/g, " ").trim().slice(0, 60) || "(turn)",
-      ts: Date.now(),
-      messagesLength: opts.messagesLength,
-      committedLength: opts.committedLength,
-      files,
-    };
-    this.checkpoints.push(cp);
-    this.trim();
-    this.persist();
-    return cp;
-  }
-
-  // Enforce the retention cap, dropping the oldest checkpoints and reclaiming any blobs
-  // they alone referenced. Files first touched before the surviving window stay
-  // rewindable: the oldest retained checkpoint falls back to the `original` baseline,
-  // whose blobs are never collected while the file remains in `touched`.
-  private trim(): void {
-    if (this.checkpoints.length <= this.maxCheckpoints) return;
-    this.checkpoints.splice(0, this.checkpoints.length - this.maxCheckpoints);
-    const live = new Set<string>();
-    for (const s of this.original.values()) if (s.hash) live.add(s.hash);
-    for (const cp of this.checkpoints)
-      for (const s of Object.values(cp.files)) if (s.hash) live.add(s.hash);
-    this.blobs.keep(live);
-  }
-
-  list(): Checkpoint[] {
-    return [...this.checkpoints];
-  }
-
-  get(id: string): Checkpoint | undefined {
-    return this.checkpoints.find((c) => c.id === id);
-  }
-
-  // Restore every session-touched file to its state as of `cp`: the checkpoint's
-  // snapshot if present, otherwise the file's original (pre-first-touch) state.
-  restoreFiles(cp: Checkpoint): void {
-    for (const abs of this.touched) {
-      this.applyFileState(abs, cp.files[abs] ?? this.original.get(abs) ?? { existed: false });
-    }
-  }
-}