@jameslovespancakes/pi-plus 1.0.0

package/src/core/codex/store.ts

@@ -0,0 +1,97 @@
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import type { QuotaSnapshot } from "../anthropic/store.ts";
+
+/**
+ * Codex account storage.
+ *
+ * Deliberately a separate file from the Anthropic store rather than a shared
+ * one. The two providers issue different credential shapes (Codex carries an
+ * `accountId` that must accompany every request) and the Anthropic file is
+ * byte-compatible with an older format we still want to be able to downgrade
+ * to. Sharing one file would couple those constraints together for no gain.
+ */
+
+export interface CodexAccount {
+  id: string;
+  label?: string;
+  enabled?: boolean;
+  access?: string;
+  refresh?: string;
+  expires?: number;
+  /** ChatGPT account id; sent as `chatgpt-account-id` on every request. */
+  accountId?: string;
+  /** From the token claims, e.g. "pro" or "plus". Display only. */
+  plan?: string;
+  addedAt?: number;
+  lastRefreshedAt?: number;
+  quota?: QuotaSnapshot;
+}
+
+export interface CodexStorage {
+  accounts: CodexAccount[];
+  routing?: { mode?: string };
+}
+
+export const MAIN_ACCOUNT_ID = "main";
+
+function storePath(): string {
+  return join(homedir(), ".pi", "agent", "codex-accounts.json");
+}
+
+export function loadCodexAccounts(path = storePath()): CodexStorage {
+  try {
+    const raw = JSON.parse(readFileSync(path, "utf8"));
+    const accounts = Array.isArray(raw?.accounts) ? raw.accounts : [];
+    return { accounts, routing: raw?.routing };
+  } catch {
+    return { accounts: [] };
+  }
+}
+
+export function saveCodexAccounts(storage: CodexStorage, path = storePath()): void {
+  mkdirSync(join(homedir(), ".pi", "agent"), { recursive: true });
+  // 0600: these are live OAuth credentials.
+  writeFileSync(path, JSON.stringify(storage, null, 2) + "\n", { mode: 0o600 });
+}
+
+/** Inserts or replaces one account, leaving the others untouched. */
+export function saveCodexAccount(account: CodexAccount, path = storePath()): void {
+  const storage = loadCodexAccounts(path);
+  const index = storage.accounts.findIndex((a) => a.id === account.id);
+  if (index >= 0) storage.accounts[index] = { ...storage.accounts[index], ...account };
+  else storage.accounts.push(account);
+  saveCodexAccounts(storage, path);
+}
+
+export function removeCodexAccount(id: string, path = storePath()): boolean {
+  const storage = loadCodexAccounts(path);
+  const before = storage.accounts.length;
+  storage.accounts = storage.accounts.filter((a) => a.id !== id);
+  if (storage.accounts.length === before) return false;
+  saveCodexAccounts(storage, path);
+  return true;
+}
+
+export const isUsableCodex = (a: CodexAccount): boolean => a.enabled !== false && !!a.access;
+
+/**
+ * Reads plan and account id out of an access token.
+ *
+ * Codex tokens are JWTs carrying `chatgpt_plan_type` and `chatgpt_account_id`,
+ * so a new account needs no extra API call to identify itself.
+ */
+export function claimsOf(accessToken: string | undefined): { accountId?: string; plan?: string } {
+  if (!accessToken) return {};
+  try {
+    const payload = JSON.parse(Buffer.from(accessToken.split(".")[1] ?? "", "base64url").toString());
+    const auth = payload?.["https://api.openai.com/auth"] ?? {};
+    return {
+      accountId: typeof auth.chatgpt_account_id === "string" ? auth.chatgpt_account_id : undefined,
+      plan: typeof auth.chatgpt_plan_type === "string" ? auth.chatgpt_plan_type : undefined,
+    };
+  } catch {
+    return {};
+  }
+}

package/src/core/config.ts

@@ -0,0 +1,169 @@
+import { existsSync } from "node:fs";
+import { agentPath, readJson, writeJson } from "./store.ts";
+
+/**
+ * One file for everything pi-plus owns: `~/.pi/agent/pi-plus.json`.
+ *
+ * ```json
+ * {
+ *   "env":    { "ARTIFICIAL_ANALYSIS_API_KEY": "aa_…", "AGENT_BOARD_URL": "…" },
+ *   "policy": { "autoApprove": [], "requireApproval": [], "deny": [] },
+ *   "remote": { "injectStatus": true, "defaults": {}, "workers": [] }
+ * }
+ * ```
+ *
+ * Pi's own `settings.json` and `models.json` are deliberately NOT absorbed:
+ * pi reads those from fixed paths and folding them in here would break it.
+ *
+ * Every legacy file is migrated on first read and left on disk, so downgrading
+ * keeps working.
+ */
+
+export const CONFIG_FILE = "pi-plus.json";
+
+export interface PolicySection {
+  autoApprove: string[];
+  requireApproval: string[];
+  deny: string[];
+}
+
+export interface RemoteSection {
+  injectStatus?: boolean;
+  defaults?: Record<string, unknown>;
+  workers: Record<string, unknown>[];
+}
+
+export interface PiPlusConfig {
+  env: Record<string, string>;
+  policy: PolicySection;
+  remote: RemoteSection;
+}
+
+const DEFAULTS: PiPlusConfig = {
+  env: {},
+  policy: {
+    autoApprove: ["anthropic/*", "openai-codex/*"],
+    requireApproval: ["openrouter/*", "google/*", "openai/*", "xai/*"],
+    deny: [],
+  },
+  remote: { injectStatus: true, workers: [] },
+};
+
+/** Legacy file -> section, applied only when that section is still absent. */
+const MIGRATIONS: { file: string; apply: (raw: any, into: PiPlusConfig) => boolean }[] = [
+  {
+    file: "pi-plus.env.json",
+    apply: (raw, into) => {
+      if (Object.keys(into.env).length > 0 || !raw || typeof raw !== "object") return false;
+      for (const [key, value] of Object.entries(raw)) {
+        if (typeof value === "string" && value.trim()) into.env[key] = value.trim();
+      }
+      return true;
+    },
+  },
+  {
+    file: "model-quality-key.json",
+    apply: (raw, into) => {
+      if (into.env.ARTIFICIAL_ANALYSIS_API_KEY || typeof raw?.artificialAnalysis !== "string") return false;
+      into.env.ARTIFICIAL_ANALYSIS_API_KEY = raw.artificialAnalysis;
+      return true;
+    },
+  },
+  {
+    file: "agent-board.json",
+    apply: (raw, into) => {
+      if (into.env.AGENT_BOARD_URL || typeof raw?.url !== "string" || typeof raw?.token !== "string") return false;
+      into.env.AGENT_BOARD_URL = raw.url;
+      into.env.AGENT_BOARD_TOKEN = raw.token;
+      if (typeof raw.adminName === "string") into.env.AGENT_BOARD_NAME ??= raw.adminName;
+      return true;
+    },
+  },
+  {
+    file: "model-policy.json",
+    apply: (raw, into) => {
+      if (!raw || typeof raw !== "object" || !Array.isArray(raw.requireApproval)) return false;
+      into.policy = {
+        autoApprove: Array.isArray(raw.autoApprove) ? raw.autoApprove : DEFAULTS.policy.autoApprove,
+        requireApproval: raw.requireApproval,
+        deny: Array.isArray(raw.deny) ? raw.deny : [],
+      };
+      return true;
+    },
+  },
+  {
+    file: "remote.json",
+    apply: (raw, into) => {
+      if (into.remote.workers.length > 0 || !Array.isArray(raw?.workers)) return false;
+      into.remote = { injectStatus: raw.injectStatus !== false, defaults: raw.defaults, workers: raw.workers };
+      return true;
+    },
+  },
+  {
+    file: "remote-workers.json",
+    apply: (raw, into) => {
+      if (into.remote.workers.length > 0 || !Array.isArray(raw?.workers)) return false;
+      into.remote = { injectStatus: raw.injectStatus !== false, defaults: raw.defaults, workers: raw.workers };
+      return true;
+    },
+  },
+];
+
+let cache: PiPlusConfig | undefined;
+
+export function configPath(): string {
+  return process.env.PI_PLUS_CONFIG ?? agentPath(CONFIG_FILE);
+}
+
+function normalize(raw: Partial<PiPlusConfig> | undefined): PiPlusConfig {
+  return {
+    env: raw?.env && typeof raw.env === "object" ? { ...raw.env } : {},
+    policy: {
+      autoApprove: Array.isArray(raw?.policy?.autoApprove) ? raw.policy.autoApprove : DEFAULTS.policy.autoApprove,
+      requireApproval: Array.isArray(raw?.policy?.requireApproval)
+        ? raw.policy.requireApproval
+        : DEFAULTS.policy.requireApproval,
+      deny: Array.isArray(raw?.policy?.deny) ? raw.policy.deny : [],
+    },
+    remote: {
+      injectStatus: raw?.remote?.injectStatus !== false,
+      defaults: raw?.remote?.defaults,
+      workers: Array.isArray(raw?.remote?.workers) ? raw.remote.workers : [],
+    },
+  };
+}
+
+export function readConfig(): PiPlusConfig {
+  if (cache) return cache;
+
+  const path = configPath();
+  const exists = existsSync(path);
+  const config = normalize(exists ? readJson<Partial<PiPlusConfig>>(path, {}) : undefined);
+
+  // Only consider legacy sources when the unified file is absent or partial.
+  let migrated = false;
+  for (const migration of MIGRATIONS) {
+    const legacyPath = agentPath(migration.file);
+    if (!existsSync(legacyPath)) continue;
+    const raw = readJson<any>(legacyPath, undefined);
+    if (raw === undefined) continue;
+    if (migration.apply(raw, config)) migrated = true;
+  }
+
+  if (!exists || migrated) writeJson(path, config, true);
+  cache = config;
+  return config;
+}
+
+/** Read-modify-write of the whole file, so sections never clobber each other. */
+export function updateConfig(mutate: (config: PiPlusConfig) => void): boolean {
+  const config = readConfig();
+  mutate(config);
+  cache = config;
+  return writeJson(configPath(), config, true);
+}
+
+/** Drops the in-memory copy. Used by tests and after external edits. */
+export function resetConfigCache(): void {
+  cache = undefined;
+}

package/src/core/env.ts

@@ -0,0 +1,58 @@
+import { readConfig, resetConfigCache, updateConfig } from "./config.ts";
+
+/**
+ * Credentials and endpoints, stored in the `env` section of `pi-plus.json`.
+ *
+ * Precedence is `process.env` first, then the file. That keeps CI and one-off
+ * shell overrides working exactly as people expect, while giving the TUI a
+ * single place to read and write.
+ */
+
+export type EnvKey =
+  | "ARTIFICIAL_ANALYSIS_API_KEY"
+  | "AGENT_BOARD_URL"
+  | "AGENT_BOARD_TOKEN"
+  | "AGENT_BOARD_NAME"
+  | "AGENT_BOARD_MODE"
+  | "AGENT_BOARD_SSH";
+
+export const ENV_KEYS: { key: EnvKey; label: string; secret: boolean }[] = [
+  { key: "ARTIFICIAL_ANALYSIS_API_KEY", label: "Artificial Analysis API key", secret: true },
+  { key: "AGENT_BOARD_URL", label: "Agent board URL", secret: false },
+  { key: "AGENT_BOARD_TOKEN", label: "Agent board token", secret: true },
+  { key: "AGENT_BOARD_NAME", label: "Agent board display name", secret: false },
+  { key: "AGENT_BOARD_MODE", label: "Agent board deployment (local|remote|external)", secret: false },
+  { key: "AGENT_BOARD_SSH", label: "Agent board SSH host, when remote", secret: false },
+];
+
+/** Reads a setting: real environment first, then the config file. */
+export function env(key: EnvKey): string | undefined {
+  const fromProcess = process.env[key];
+  if (typeof fromProcess === "string" && fromProcess.trim()) return fromProcess.trim();
+  const value = readConfig().env[key];
+  return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+
+/** Writes a setting. Passing undefined or blank removes it. */
+export function setEnv(key: EnvKey, value: string | undefined): boolean {
+  return updateConfig((config) => {
+    if (value === undefined || value.trim() === "") delete config.env[key];
+    else config.env[key] = value.trim();
+  });
+}
+
+/** True when the real environment supplies this key, so the file is ignored. */
+export function isFromProcessEnv(key: EnvKey): boolean {
+  const value = process.env[key];
+  return typeof value === "string" && value.trim() !== "";
+}
+
+/** `aa_vaoi…rXcC`: enough to recognise, not enough to use. */
+export function maskSecret(value: string): string {
+  if (value.length <= 10) return "•".repeat(value.length);
+  return `${value.slice(0, 5)}…${value.slice(-4)}`;
+}
+
+export function resetEnvCache(): void {
+  resetConfigCache();
+}

package/src/core/exec/process.ts

@@ -0,0 +1,146 @@
+import { spawn } from "node:child_process";
+import { createReadStream } from "node:fs";
+
+/**
+ * Process and SSH execution primitives.
+ *
+ * Extracted from the remote-jobs extension so anything needing a bounded child
+ * process gets the same timeout, abort and output-cap behaviour.
+ */
+
+export const SSH_ARGS = ["-o", "BatchMode=yes", "-o", "ConnectTimeout=8"];
+
+const PROCESS_TAIL_CHARS = 2 * 1024 * 1024;
+
+export interface ProcessResult {
+  code: number;
+  stdout: string;
+  stderr: string;
+  timedOut: boolean;
+  aborted: boolean;
+  totalOutputBytes: number;
+}
+
+export interface RunOptions {
+  cwd?: string;
+  input?: string | Buffer | { file: string };
+  timeoutSeconds?: number;
+  signal?: AbortSignal;
+  onData?: (chunk: string) => void;
+}
+
+/** Keeps only the trailing window of a stream so long builds cannot exhaust memory. */
+export function appendTail(current: string, chunk: string): string {
+  const next = current + chunk;
+  return next.length > PROCESS_TAIL_CHARS ? next.slice(-PROCESS_TAIL_CHARS) : next;
+}
+
+export function runProcess(command: string, args: string[], options: RunOptions = {}): Promise<ProcessResult> {
+  return new Promise((resolvePromise, reject) => {
+    const child = spawn(command, args, {
+      cwd: options.cwd,
+      shell: false,
+      stdio: [options.input === undefined ? "ignore" : "pipe", "pipe", "pipe"],
+      windowsHide: true,
+    });
+
+    let stdout = "";
+    let stderr = "";
+    let totalOutputBytes = 0;
+    let timedOut = false;
+    let aborted = false;
+    let settled = false;
+    let timer: NodeJS.Timeout | undefined;
+
+    const finishReject = (error: Error) => {
+      if (settled) return;
+      settled = true;
+      if (timer) clearTimeout(timer);
+      reject(error);
+    };
+
+    const kill = () => {
+      try {
+        child.kill("SIGTERM");
+      } catch {
+        // Process already exited.
+      }
+    };
+
+    child.stdout?.on("data", (data: Buffer) => {
+      const text = data.toString("utf8");
+      totalOutputBytes += data.length;
+      stdout = appendTail(stdout, text);
+      options.onData?.(text);
+    });
+
+    child.stderr?.on("data", (data: Buffer) => {
+      const text = data.toString("utf8");
+      totalOutputBytes += data.length;
+      stderr = appendTail(stderr, text);
+      options.onData?.(text);
+    });
+
+    child.on("error", finishReject);
+
+    if (options.timeoutSeconds) {
+      timer = setTimeout(() => {
+        timedOut = true;
+        kill();
+      }, options.timeoutSeconds * 1000);
+    }
+
+    const onAbort = () => {
+      aborted = true;
+      kill();
+    };
+
+    if (options.signal) {
+      if (options.signal.aborted) onAbort();
+      else options.signal.addEventListener("abort", onAbort, { once: true });
+    }
+
+    if (typeof options.input === "string" || Buffer.isBuffer(options.input)) {
+      child.stdin?.end(options.input);
+    } else if (options.input?.file && child.stdin) {
+      const target = child.stdin;
+      const stream = createReadStream(options.input.file);
+      stream.on("error", (error) => {
+        kill();
+        finishReject(error);
+      });
+      stream.pipe(target);
+    }
+
+    child.on("close", (code) => {
+      if (settled) return;
+      settled = true;
+      if (timer) clearTimeout(timer);
+      options.signal?.removeEventListener("abort", onAbort);
+      resolvePromise({ code: code ?? 1, stdout, stderr, timedOut, aborted, totalOutputBytes });
+    });
+  });
+}
+
+export async function runLocal(command: string, args: string[], cwd?: string): Promise<ProcessResult> {
+  return runProcess(command, args, { cwd, timeoutSeconds: 60 });
+}
+
+export async function runSshCommand(
+  host: string,
+  remoteCommand: string,
+  options: RunOptions = {},
+  extraArgs: string[] = [],
+): Promise<ProcessResult> {
+  return runProcess("ssh", [...SSH_ARGS, ...extraArgs, host, remoteCommand], options);
+}
+
+/** POSIX single-quote escaping for values interpolated into remote scripts. */
+export function shQuote(value: string): string {
+  return `'${value.replace(/'/g, `'"'"'`)}'`;
+}
+
+export function rootAssignment(root: string): string {
+  if (root.startsWith("~/")) return `ROOT="$HOME"/${shQuote(root.slice(2))}`;
+  return `ROOT=${shQuote(root)}`;
+}

package/src/core/exec/ssh-config.ts

@@ -0,0 +1,157 @@
+import { readFileSync } from "node:fs";
+import { globSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, isAbsolute, join } from "node:path";
+
+/**
+ * Minimal `~/.ssh/config` reader.
+ *
+ * Deliberately narrow: it extracts only what is needed to offer a host as a
+ * remote worker: the alias, HostName, User, Port, and whether an IdentityFile
+ * is configured. It never reads key material, and callers must keep the results
+ * in the UI layer: host aliases frequently name internal infrastructure and have
+ * no business being sent to a model provider.
+ */
+
+export interface SshHost {
+  /** The `Host` alias, which is what you pass to `ssh`. */
+  alias: string;
+  hostName?: string;
+  user?: string;
+  port?: number;
+  /** Path as written in the config. The file is never opened. */
+  identityFile?: string;
+  /** Config file this block came from, for display. */
+  source: string;
+}
+
+function defaultConfigPath(): string {
+  return join(homedir(), ".ssh", "config");
+}
+
+/** `Host` patterns that cannot be connected to directly. */
+function isPattern(alias: string): boolean {
+  return alias.includes("*") || alias.includes("?") || alias.startsWith("!");
+}
+
+function expandPath(value: string, base: string): string {
+  if (value.startsWith("~/")) return join(homedir(), value.slice(2));
+  return isAbsolute(value) ? value : join(base, value);
+}
+
+/**
+ * Parses one config file, following `Include` directives.
+ * `seen` guards against include cycles.
+ */
+function parseFile(path: string, seen: Set<string>, out: SshHost[]): void {
+  if (seen.has(path)) return;
+  seen.add(path);
+
+  let text: string;
+  try {
+    text = readFileSync(path, "utf8");
+  } catch {
+    return; // Missing or unreadable config is simply "no hosts".
+  }
+
+  let current: SshHost | undefined;
+  const push = () => {
+    if (current && !isPattern(current.alias)) out.push(current);
+    current = undefined;
+  };
+
+  for (const rawLine of text.split(/\r?\n/)) {
+    const line = rawLine.trim();
+    if (!line || line.startsWith("#")) continue;
+
+    // Keywords are case-insensitive; separator is whitespace or '='.
+    const match = /^([A-Za-z]+)[\s=]+(.*)$/.exec(line);
+    if (!match) continue;
+    const keyword = match[1].toLowerCase();
+    const value = match[2].trim().replace(/^"(.*)"$/, "$1");
+    if (!value) continue;
+
+    if (keyword === "host") {
+      push();
+      // `Host a b c` declares several aliases; the first connectable one wins.
+      const alias = value.split(/\s+/).find((candidate) => !isPattern(candidate));
+      if (alias) current = { alias, source: path };
+      continue;
+    }
+
+    if (keyword === "include") {
+      // Includes are resolved relative to the containing file's directory.
+      for (const pattern of value.split(/\s+/)) {
+        const resolved = expandPath(pattern, dirname(path));
+        let matches: string[] = [];
+        try {
+          matches = globSync(resolved);
+        } catch {
+          matches = [];
+        }
+        // A literal path that does not glob should still be attempted.
+        for (const file of matches.length > 0 ? matches : [resolved]) parseFile(file, seen, out);
+      }
+      continue;
+    }
+
+    if (!current) continue;
+    switch (keyword) {
+      case "hostname":
+        current.hostName = value;
+        break;
+      case "user":
+        current.user = value;
+        break;
+      case "port": {
+        const port = Number(value);
+        if (Number.isInteger(port) && port > 0 && port < 65536) current.port = port;
+        break;
+      }
+      case "identityfile":
+        // Recorded as a path only. The key itself is never read.
+        current.identityFile ??= value;
+        break;
+      default:
+        break;
+    }
+  }
+  push();
+}
+
+/** Every connectable host in the user's SSH config, in file order. */
+export function readSshHosts(path = defaultConfigPath()): SshHost[] {
+  const hosts: SshHost[] = [];
+  parseFile(path, new Set(), hosts);
+
+  // A later duplicate alias never overrides the first, matching ssh semantics.
+  const byAlias = new Map<string, SshHost>();
+  for (const host of hosts) if (!byAlias.has(host.alias)) byAlias.set(host.alias, host);
+  return [...byAlias.values()];
+}
+
+/** `deploy@203.0.113.9:2222` -> parts. Bare `host` is valid. */
+export function parseTarget(input: string): { user?: string; host: string; port?: number } | undefined {
+  const trimmed = input.trim();
+  if (!trimmed || /\s/.test(trimmed)) return undefined;
+
+  const at = trimmed.lastIndexOf("@");
+  if (at === 0) return undefined; // "@host" has an empty user
+  const user = at > 0 ? trimmed.slice(0, at) : undefined;
+  let rest = at > 0 ? trimmed.slice(at + 1) : trimmed;
+
+  let port: number | undefined;
+  // Only treat a trailing :N as a port; IPv6 literals keep their colons.
+  const portMatch = /^(.*):(\d+)$/.exec(rest);
+  if (portMatch && !portMatch[1].includes(":")) {
+    rest = portMatch[1];
+    port = Number(portMatch[2]);
+    if (!Number.isInteger(port) || port <= 0 || port >= 65536) return undefined;
+  }
+
+  if (!rest) return undefined;
+  // A leftover single colon is a malformed port ("host:abc"). Genuine IPv6
+  // literals always carry at least two.
+  if (rest.includes(":") && (rest.match(/:/g)?.length ?? 0) < 2) return undefined;
+  return { user, host: rest, port };
+}