@mewbleh/purrx 1.0.8

package/bin/purrx.js

@@ -0,0 +1,352 @@
+#!/usr/bin/env node
+import readline from "node:readline";
+import { loginWithChatGPT, loginWithApiKey } from "../src/auth/login.js";
+import {
+  clearAuth,
+  ensureFreshAuth,
+  resolveAuthMode,
+  readAuth,
+} from "../src/auth/tokens.js";
+import { startTui } from "../src/ui/tui.js";
+import { runTurn } from "../src/core/agent.js";
+import { createApprovalManager } from "../src/core/approval.js";
+import { ToolRegistry } from "../src/tools/registry.js";
+import { authFilePath } from "../src/config.js";
+import { resolveModel, listModels } from "../src/api/models.js";
+import { detectPlatform } from "../src/platform.js";
+import {
+  listSessions,
+  loadSession,
+  latestSession,
+  deleteSession,
+  createSession,
+  saveSession,
+} from "../src/core/session.js";
+
+function promptLine(question) {
+  return new Promise((resolve) => {
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+    });
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+}
+
+// Tiny flag parser: returns { _: positional[], flags: {name: value|true} }.
+function parseArgs(argv) {
+  const out = { _: [], flags: {} };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a.startsWith("--")) {
+      const name = a.slice(2);
+      const next = argv[i + 1];
+      if (next && !next.startsWith("--")) {
+        out.flags[name] = next;
+        i++;
+      } else {
+        out.flags[name] = true;
+      }
+    } else {
+      out._.push(a);
+    }
+  }
+  return out;
+}
+
+async function cmdLogin(args) {
+  const { flags } = parseArgs(args);
+  if (flags["api-key"]) {
+    let key = typeof flags["api-key"] === "string" ? flags["api-key"] : "";
+    if (!key) key = await promptLine("Enter your OpenAI API key: ");
+    if (!key) {
+      console.error("No API key provided.");
+      process.exit(1);
+    }
+    const file = loginWithApiKey(key);
+    console.log(`Saved API key to ${file}`);
+    return;
+  }
+
+  try {
+    const { file, plan } = await loginWithChatGPT();
+    console.log(`\n✓ Signed in with ChatGPT (plan: ${plan}).`);
+    console.log(`Credentials saved to ${file}`);
+  } catch (err) {
+    console.error(`\nLogin failed: ${err.message}`);
+    process.exit(1);
+  }
+}
+
+function cmdLogout() {
+  const ok = clearAuth();
+  console.log(ok ? "Logged out." : "No credentials found.");
+}
+
+function cmdStatus() {
+  const auth = readAuth();
+  console.log(`platform: ${detectPlatform()}`);
+  if (!auth) {
+    console.log("Not signed in. Run `purrx login`.");
+    return;
+  }
+  const info = resolveAuthMode(auth);
+  if (!info) {
+    console.log("Credentials present but unusable. Try `purrx login` again.");
+    return;
+  }
+  console.log(
+    `signed in: ${info.mode === "chatgpt" ? "ChatGPT account" : "API key"}`
+  );
+  console.log(`auth file: ${authFilePath()}`);
+}
+
+async function ensureAuthOrExit() {
+  const auth = await ensureFreshAuth();
+  const info = resolveAuthMode(auth);
+  if (!info) {
+    console.error("You are not signed in. Run `purrx login` first.");
+    process.exit(1);
+  }
+  return info;
+}
+
+async function cmdChat(args) {
+  const { flags } = parseArgs(args);
+  const authInfo = await ensureAuthOrExit();
+
+  // Resume logic.
+  let session = null;
+  if (flags.continue) {
+    session = latestSession();
+    if (session) console.log(`resuming latest session ${session.id}`);
+  } else if (flags.resume) {
+    session = loadSession(flags.resume);
+    if (!session) {
+      console.error(`session not found: ${flags.resume}`);
+      process.exit(1);
+    }
+    console.log(`resuming session ${session.id}`);
+  }
+
+  const model = await resolveModel(authInfo, flags.model);
+  if (!session) session = createSession({ cwd: process.cwd(), model });
+
+  await startTui(authInfo, {
+    session,
+    model,
+    policy: flags.approval || session.policy || "suggest",
+  });
+}
+
+async function cmdExec(args) {
+  const { _, flags } = parseArgs(args);
+  const message = _.join(" ").trim();
+  if (!message) {
+    console.error('Usage: purrx exec "your request" [--model M] [--approval P]');
+    process.exit(1);
+  }
+  const authInfo = await ensureAuthOrExit();
+  const model = await resolveModel(authInfo, flags.model);
+
+  // In non-interactive exec, default to full-auto unless told otherwise.
+  const policy = flags.approval || "full-auto";
+  const approval = createApprovalManager(policy);
+
+  const registry = new ToolRegistry();
+  await registry.init({
+    onLog: (msg) => console.error(`  · ${msg}`),
+    webSearch: flags["no-web-search"] ? false : true,
+  });
+
+  const session = createSession({ cwd: process.cwd(), model });
+  try {
+    await runTurn({
+      authInfo,
+      history: session.history,
+      userMessage: message,
+      cwd: process.cwd(),
+      model,
+      registry,
+      approval,
+      onChange: () => saveSession(session),
+    });
+  } finally {
+    registry.shutdown();
+  }
+  console.log(`\nsession saved: ${session.id}`);
+}
+
+async function cmdModels(args) {
+  const { flags } = parseArgs(args);
+  const authInfo = await ensureAuthOrExit();
+  const models = await listModels(authInfo);
+  const active = await resolveModel(authInfo, flags.model);
+  console.log("available models:");
+  for (const m of models) {
+    console.log(`  ${m}${m === active ? "  (default)" : ""}`);
+  }
+}
+
+function cmdSessions(args) {
+  const { _, flags } = parseArgs(args);
+  const sub = _[0];
+
+  if (sub === "rm" || flags.rm) {
+    const id = sub === "rm" ? _[1] : flags.rm;
+    if (!id) {
+      console.error("usage: purrx sessions rm <id>");
+      process.exit(1);
+    }
+    console.log(deleteSession(id) ? `deleted ${id}` : `not found: ${id}`);
+    return;
+  }
+
+  const sessions = listSessions();
+  if (!sessions.length) {
+    console.log("no saved sessions.");
+    return;
+  }
+  console.log("saved sessions (newest first):\n");
+  for (const s of sessions) {
+    console.log(`  ${s.id}`);
+    console.log(`    updated: ${s.updated_at}  turns: ${s.turns}`);
+    if (s.preview) console.log(`    "${s.preview}"`);
+    console.log();
+  }
+  console.log("resume with:  purrx chat --resume <id>");
+}
+
+async function cmdMcp(args) {
+  const { _ } = parseArgs(args);
+  const sub = _[0];
+  const { readMcpConfig } = await import("../src/tools/mcp.js");
+  const { configFilePath } = await import("../src/config.js");
+
+  if (sub === "init") {
+    const fs = await import("node:fs");
+    const path = configFilePath();
+    let existing = {};
+    try {
+      existing = JSON.parse(fs.readFileSync(path, "utf8"));
+    } catch {
+      // none yet
+    }
+    if (!existing.mcpServers) existing.mcpServers = {};
+    if (Object.keys(existing.mcpServers).length === 0) {
+      existing.mcpServers.example = {
+        command: "npx",
+        args: ["-y", "@modelcontextprotocol/server-filesystem", "."],
+        disabled: true,
+      };
+    }
+    fs.mkdirSync(path.replace(/[^\\/]+$/, ""), { recursive: true });
+    fs.writeFileSync(path, JSON.stringify(existing, null, 2));
+    console.log(`wrote MCP config scaffold to ${path}`);
+    console.log("edit it to add servers, then set disabled: false.");
+    return;
+  }
+
+  // Default: list configured servers.
+  const config = readMcpConfig();
+  const names = Object.keys(config);
+  if (!names.length) {
+    console.log("no MCP servers configured.");
+    console.log(`add some in ${configFilePath()} (run: purrx mcp init)`);
+    return;
+  }
+  console.log("configured MCP servers:");
+  for (const name of names) {
+    const s = config[name];
+    const status = s.disabled ? " (disabled)" : "";
+    console.log(`  ${name}${status}: ${s.command} ${(s.args || []).join(" ")}`);
+  }
+}
+
+function printHelp() {
+  console.log(`purrx  lightweight AI coding agent
+
+Usage:
+  purrx                          Start interactive chat (default)
+  purrx chat [opts]              Start interactive chat
+  purrx exec "<request>" [opts]  Run a single request non-interactively
+  purrx models                   List models your account can use
+  purrx mcp                      List configured MCP servers
+  purrx mcp init                 Write an MCP config scaffold
+  purrx sessions                 List saved sessions
+  purrx sessions rm <id>         Delete a saved session
+  purrx login                    Sign in with your ChatGPT account (OAuth)
+  purrx login --api-key [KEY]    Sign in with an OpenAI API key
+  purrx logout                   Remove stored credentials
+  purrx status                   Show platform and sign-in status
+  purrx help                     Show this help
+
+Chat options:
+  --model <id>        Model to use for this session
+  --approval <policy> suggest | auto-edit | full-auto  (default: suggest)
+  --continue          Resume the most recent session
+  --resume <id>       Resume a specific session
+
+Exec options:
+  --model <id>        Model to use
+  --approval <policy> default: full-auto for non-interactive use
+
+Environment:
+  OPENAI_API_KEY   Use this API key directly (overrides stored auth)
+  PURRX_MODEL      Default model (default: gpt-5-codex)
+  PURRX_HOME       Data dir override (default: OS-appropriate location)
+  CODEX_HOME       Shared with the official Codex CLI auth.json
+  NO_COLOR         Disable colored output
+
+Supported platforms: Windows, macOS, Linux, Android (Termux)
+`);
+}
+
+async function main() {
+  const [, , command, ...rest] = process.argv;
+
+  switch (command) {
+    case undefined:
+    case "chat":
+      await cmdChat(rest);
+      break;
+    case "exec":
+      await cmdExec(rest);
+      break;
+    case "models":
+      await cmdModels(rest);
+      break;
+    case "mcp":
+      await cmdMcp(rest);
+      break;
+    case "sessions":
+      cmdSessions(rest);
+      break;
+    case "login":
+      await cmdLogin(rest);
+      break;
+    case "logout":
+      cmdLogout();
+      break;
+    case "status":
+      cmdStatus();
+      break;
+    case "help":
+    case "--help":
+    case "-h":
+      printHelp();
+      break;
+    default:
+      console.error(`Unknown command: ${command}\n`);
+      printHelp();
+      process.exit(1);
+  }
+}
+
+main().catch((err) => {
+  console.error(`Fatal: ${err.message}`);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "@mewbleh/purrx",
+  "version": "1.0.8",
+  "description": "purrx, a lightweight AI coding agent for your terminal",
+  "type": "module",
+  "main": "src/index.js",
+  "bin": {
+    "purrx": "bin/purrx.js"
+  },
+  "files": [
+    "bin/",
+    "src/",
+    "README.md",
+    "LICENSE",
+    "AGENTS.md"
+  ],
+  "scripts": {
+    "start": "node bin/purrx.js",
+    "check": "node scripts/check.js",
+    "typecheck": "tsc --noEmit",
+    "test": "node scripts/check.js && tsc --noEmit"
+  },
+  "keywords": [
+    "ai",
+    "agent",
+    "coding-agent",
+    "cli",
+    "codex",
+    "chatgpt",
+    "openai",
+    "mcp",
+    "llm",
+    "tui"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/mewbleh/purrx.git"
+  },
+  "homepage": "https://github.com/mewbleh/purrx#readme",
+  "bugs": {
+    "url": "https://github.com/mewbleh/purrx/issues"
+  },
+  "author": "mewbleh",
+  "license": "Apache-2.0",
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "@types/node": "^26.0.1",
+    "typescript": "^6.0.3"
+  },
+  "dependencies": {
+    "@inquirer/prompts": "^8.5.2",
+    "boxen": "^8.0.1",
+    "chalk": "^5.6.2",
+    "cli-highlight": "^2.1.11",
+    "marked": "^15.0.12",
+    "marked-terminal": "^7.3.0",
+    "ora": "^9.4.1"
+  }
+}

package/src/api/client.js

@@ -0,0 +1,121 @@
+import { API_BASE, CHATGPT_BASE } from "../config.js";
+
+// Builds the request URL and headers for the resolved auth mode.
+/**
+ * @param {import("../types.js").AuthInfo} authInfo
+ * @returns {{ url: string, headers: Record<string, string> }}
+ */
+function buildRequest(authInfo) {
+  if (authInfo.mode === "chatgpt") {
+    /** @type {Record<string, string>} */
+    const headers = {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${authInfo.accessToken}`,
+      "OpenAI-Beta": "responses=experimental",
+      originator: "codex_cli_rs",
+    };
+    if (authInfo.accountId) {
+      headers["chatgpt-account-id"] = authInfo.accountId;
+    }
+    return { url: `${CHATGPT_BASE}/responses`, headers };
+  }
+  // API-key mode.
+  return {
+    url: `${API_BASE}/responses`,
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${authInfo.apiKey}`,
+    },
+  };
+}
+
+// Streams a Responses API request. Calls handlers as SSE events arrive.
+//   onText(deltaString)     -> assistant text deltas
+//   onEvent(parsedEvent)    -> every parsed event (for tool call assembly)
+// Returns the final "response.completed" payload.
+/**
+ * @param {Object} req
+ * @param {import("../types.js").AuthInfo} req.authInfo
+ * @param {string} req.model
+ * @param {import("../types.js").HistoryItem[]} req.input
+ * @param {import("../types.js").ToolDefinition[]} [req.tools]
+ * @param {string} [req.instructions]
+ * @param {{ onText?: (delta: string) => void, onEvent?: (event: any) => void }} [handlers]
+ * @returns {Promise<any>}
+ */
+export async function streamResponse({ authInfo, model, input, tools, instructions }, handlers = {}) {
+  const { url, headers } = buildRequest(authInfo);
+
+  /** @type {Record<string, any>} */
+  const payload = {
+    model,
+    input,
+    stream: true,
+    store: false,
+  };
+  if (instructions) payload.instructions = instructions;
+  if (tools && tools.length) {
+    payload.tools = tools;
+    payload.tool_choice = "auto";
+  }
+
+  const resp = await fetch(url, {
+    method: "POST",
+    headers,
+    body: JSON.stringify(payload),
+  });
+
+  if (!resp.ok || !resp.body) {
+    const text = await resp.text().catch(() => "");
+    throw new Error(`API request failed (${resp.status}): ${text}`);
+  }
+
+  const reader = resp.body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  let finalResponse = null;
+
+  while (true) {
+    const { value, done } = await reader.read();
+    if (done) break;
+    buffer += decoder.decode(value, { stream: true });
+
+    // SSE frames are separated by a blank line.
+    let idx;
+    while ((idx = buffer.indexOf("\n\n")) !== -1) {
+      const frame = buffer.slice(0, idx);
+      buffer = buffer.slice(idx + 2);
+
+      const dataLines = frame
+        .split("\n")
+        .filter((l) => l.startsWith("data:"))
+        .map((l) => l.slice(5).trim());
+      if (!dataLines.length) continue;
+
+      const data = dataLines.join("\n");
+      if (data === "[DONE]") continue;
+
+      let event;
+      try {
+        event = JSON.parse(data);
+      } catch {
+        continue;
+      }
+
+      if (handlers.onEvent) handlers.onEvent(event);
+
+      if (event.type === "response.output_text.delta" && handlers.onText) {
+        handlers.onText(event.delta || "");
+      }
+      if (event.type === "response.completed") {
+        finalResponse = event.response;
+      }
+      if (event.type === "error" || event.type === "response.failed") {
+        const msg = event.error?.message || event.response?.error?.message || "unknown error";
+        throw new Error(`API stream error: ${msg}`);
+      }
+    }
+  }
+
+  return finalResponse;
+}

package/src/api/models.js

@@ -0,0 +1,57 @@
+import { API_BASE, CHATGPT_BASE, DEFAULT_MODEL } from "../config.js";
+
+// Fetches the list of model ids the current account can actually use.
+// - API-key mode: GET https://api.openai.com/v1/models
+// - ChatGPT mode: the codex backend does not expose a public models list the
+//   same way, so we probe a known-good set and fall back to the default.
+export async function listModels(authInfo) {
+  if (authInfo.mode === "apikey") {
+    return listApiKeyModels(authInfo.apiKey);
+  }
+  return listChatGptModels();
+}
+
+async function listApiKeyModels(apiKey) {
+  try {
+    const resp = await fetch(`${API_BASE}/models`, {
+      headers: { Authorization: `Bearer ${apiKey}` },
+    });
+    if (!resp.ok) return fallbackModels();
+    const json = /** @type {any} */ (await resp.json());
+    const ids = (json.data || [])
+      .map((/** @type {any} */ m) => m.id)
+      .filter(Boolean)
+      // Keep models usable for chat/agent work (gpt*, o*, codex).
+      .filter((/** @type {string} */ id) => /^(gpt|o\d|codex|chatgpt)/i.test(id))
+      .sort();
+    return ids.length ? ids : fallbackModels();
+  } catch {
+    return fallbackModels();
+  }
+}
+
+// The ChatGPT/Codex backend exposes models tied to the plan. There is no
+// stable public list endpoint, so we report the commonly available Codex
+// models. DEFAULT_MODEL is always first.
+function listChatGptModels() {
+  const known = ["gpt-5-codex", "gpt-5", "gpt-5-mini", "o4-mini", "o3"];
+  return dedupeWithDefault(known);
+}
+
+function fallbackModels() {
+  return dedupeWithDefault(["gpt-5-codex", "gpt-5", "gpt-5-mini", "gpt-4.1"]);
+}
+
+function dedupeWithDefault(list) {
+  const set = new Set([DEFAULT_MODEL, ...list]);
+  return [...set];
+}
+
+// Resolves the model to use: explicit override > config/session > a model the
+// account actually has > DEFAULT_MODEL.
+export async function resolveModel(authInfo, preferred) {
+  if (preferred) return preferred;
+  const available = await listModels(authInfo).catch(() => []);
+  if (available.includes(DEFAULT_MODEL)) return DEFAULT_MODEL;
+  return available[0] || DEFAULT_MODEL;
+}