pum-agent 0.1.0-beta.3

package/src/index.tsx

@@ -0,0 +1,133 @@
+#!/usr/bin/env bun
+import { createCliRenderer } from "@opentui/core";
+import { createRoot } from "@opentui/react";
+import {
+  createAgentSessionFromServices,
+  createAgentSessionRuntime,
+  createAgentSessionServices,
+  ModelRuntime,
+  SessionManager,
+} from "@earendil-works/pi-coding-agent";
+import { mkdirSync } from "node:fs";
+import { App } from "./app";
+import { AGENT_DIR, AUTH_PATH, MODELS_PATH, sessionDir } from "./config";
+import { loadSettings } from "./settings";
+import { installWebSearch, webSearch } from "./web-search";
+import { setWritingStyle, writingStyleExtension } from "./writing-style";
+import {
+  explanationStrengthExtension,
+  setExplanationStrength,
+} from "./explanation-strength";
+import { createCheckModeExtension, setCheckModeConfig } from "./check-mode";
+import { SubagentManager } from "./subagents/manager";
+import { cleanupPendingImages } from "./image-paste";
+import { shutdownSignals } from "./platform";
+import { createShutdown } from "./shutdown";
+import { applyPatchExtension } from "./apply-patch";
+
+mkdirSync(AGENT_DIR, { recursive: true });
+
+const modelRuntime = await ModelRuntime.create({
+  authPath: AUTH_PATH,
+  modelsPath: MODELS_PATH,
+});
+const loginRequired = process.argv[2] === "login" || (await modelRuntime.getAvailable()).length === 0;
+
+const settings = loadSettings();
+setWritingStyle(settings.writingStyle);
+setExplanationStrength(settings.explanationStrength);
+setCheckModeConfig({ enabled: settings.checkMode, model: settings.checkModel });
+const checkModeExtension = createCheckModeExtension(modelRuntime);
+const subagentManager = new SubagentManager({
+  modelRuntime,
+  agentDir: AGENT_DIR,
+  childExtensionFactories: [
+    writingStyleExtension,
+    explanationStrengthExtension,
+    checkModeExtension,
+  ],
+});
+const subagentExtension = subagentManager.mainExtension();
+// Hosted web search rides on the provider, so it must be wrapped before the
+// session picks a model.
+webSearch.enabled = settings.webSearch;
+const searchProviders = installWebSearch(modelRuntime);
+
+// `pum -r` picks up the most recent session for this directory.
+const resume = process.argv.includes("-r") || process.argv.includes("--resume");
+
+const cwd = process.cwd();
+const sessionRuntime = await createAgentSessionRuntime(
+  async ({ cwd, sessionManager, sessionStartEvent }) => {
+    const services = await createAgentSessionServices({
+      cwd,
+      agentDir: AGENT_DIR,
+      modelRuntime,
+      resourceLoaderOptions: {
+        extensionFactories: [
+          writingStyleExtension,
+          explanationStrengthExtension,
+          checkModeExtension,
+          applyPatchExtension,
+          subagentExtension,
+        ],
+      },
+    });
+    return {
+      ...(await createAgentSessionFromServices({
+        services,
+        sessionManager,
+        sessionStartEvent,
+        tools: [
+          "read", "write", "edit", "apply_patch", "bash",
+          "spawn_subagent", "message_agent", "list_subagents", "stop_subagent", "worktree",
+        ],
+      })),
+      services,
+      diagnostics: services.diagnostics,
+    };
+  },
+  {
+    cwd,
+    agentDir: AGENT_DIR,
+    sessionManager: resume
+      ? SessionManager.continueRecent(cwd, sessionDir(cwd))
+      : SessionManager.create(cwd, sessionDir(cwd)),
+  },
+);
+
+if (sessionRuntime.modelFallbackMessage) console.error(sessionRuntime.modelFallbackMessage);
+
+const renderer = await createCliRenderer({ exitOnCtrlC: false });
+const root = createRoot(renderer);
+const shutdown = createShutdown({
+  unmount: () => root.unmount(),
+  cleanup: cleanupPendingImages,
+  dispose: () => sessionRuntime.dispose(),
+  destroy: () => renderer.destroy(),
+  exit: (code) => process.exit(code),
+});
+for (const signal of shutdownSignals()) {
+  process.on(signal, () => void shutdown(1));
+}
+
+root.render(
+  <App
+    session={sessionRuntime.session}
+    onNewSession={async () => {
+      await sessionRuntime.newSession();
+      return sessionRuntime.session;
+    }}
+    loadSessions={() => SessionManager.list(cwd, sessionDir(cwd))}
+    onSwitchSession={async (path) => {
+      await sessionRuntime.switchSession(path);
+      return sessionRuntime.session;
+    }}
+    modelRuntime={modelRuntime}
+    settings={settings}
+    searchProviders={searchProviders}
+    subagentManager={subagentManager}
+    loginRequired={loginRequired}
+    onExit={() => shutdown(0)}
+  />,
+);

package/src/login-controller.ts

@@ -0,0 +1,267 @@
+import type { AuthEvent, AuthPrompt } from "@earendil-works/pi-ai";
+import type { AgentSession, ModelRuntime } from "@earendil-works/pi-coding-agent";
+import type { LoginPage } from "./login-popup";
+import {
+  customProviderId,
+  discoverOpenAIModels,
+  persistCustomProvider,
+  providerLoginMethods,
+  refreshAndSelectModel,
+  safeError,
+  type LoginMethod,
+} from "./login-flow";
+
+export type LoginKey = {
+  name: string;
+  sequence?: string;
+  ctrl?: boolean;
+  meta?: boolean;
+  option?: boolean;
+};
+
+type PromptWaiter = {
+  prompt: AuthPrompt;
+  resolve(value: string): void;
+  reject(error: Error): void;
+};
+
+export class LoginController {
+  private page: LoginPage;
+  private controller?: AbortController;
+  private promptWaiter?: PromptWaiter;
+  private secret = "";
+  private endpoint = "";
+  private customKey = "";
+  private providerCursor = 0;
+  private retry?: () => void;
+
+  constructor(
+    private runtime: ModelRuntime,
+    private getSession: () => AgentSession,
+    private show: (page: LoginPage) => void,
+    private complete: (modelId?: string) => void,
+    private closePopup: () => void,
+  ) {
+    this.page = this.providerPage();
+  }
+
+  private setPage(page: LoginPage) {
+    this.page = page;
+    this.show(page);
+  }
+
+  private providerPage(): LoginPage {
+    const providers = (this.runtime as any).getProviders?.() ?? [];
+    const methods = providerLoginMethods(providers);
+    this.providerCursor = Math.min(this.providerCursor, methods.length);
+    return { kind: "providers", methods, cursor: this.providerCursor };
+  }
+
+  open() {
+    this.cancelOperation();
+    this.retry = undefined;
+    this.providerCursor = 0;
+    this.setPage(this.providerPage());
+  }
+
+  cancelOperation() {
+    this.controller?.abort();
+    this.controller = undefined;
+    this.promptWaiter?.reject(new Error("Login cancelled"));
+    this.promptWaiter = undefined;
+    this.secret = "";
+  }
+
+  close() {
+    this.cancelOperation();
+    this.closePopup();
+  }
+
+  private async finish(providerId: string, providerName: string) {
+    const session = this.getSession();
+    const selected = await refreshAndSelectModel(
+      this.runtime,
+      providerId,
+      (model) => session.setModel(model),
+      AbortSignal.timeout(15_000),
+      session.model,
+    );
+    this.complete(selected?.id);
+    this.setPage({
+      kind: "success",
+      message: selected
+        ? `${providerName} is ready. Selected ${selected.id}.`
+        : `${providerName} is configured. Open Settings to select an available model.`,
+    });
+  }
+
+  private startProvider(method: LoginMethod) {
+    this.retry = () => this.startProvider(method);
+    if (!method.canLogin) {
+      this.setPage({
+        kind: "error",
+        title: `${method.providerName} uses external credentials`,
+        message: "Configure the provider environment or credential files, then retry.",
+      });
+      return;
+    }
+    const controller = new AbortController();
+    this.cancelOperation();
+    this.controller = controller;
+    this.setPage({ kind: "working", providerName: method.providerName });
+    void this.runtime.login(method.providerId, method.authType, {
+      signal: controller.signal,
+      notify: (event: AuthEvent) => {
+        if (!this.promptWaiter) this.setPage({ kind: "working", providerName: method.providerName, event });
+      },
+      prompt: (prompt: AuthPrompt) => new Promise<string>((resolve, reject) => {
+        this.secret = "";
+        const rejectPrompt = (error: Error) => {
+          prompt.signal?.removeEventListener("abort", onAbort);
+          reject(error);
+        };
+        const resolvePrompt = (value: string) => {
+          prompt.signal?.removeEventListener("abort", onAbort);
+          resolve(value);
+        };
+        const onAbort = () => rejectPrompt(new Error("Login cancelled"));
+        prompt.signal?.addEventListener("abort", onAbort, { once: true });
+        this.promptWaiter = { prompt, resolve: resolvePrompt, reject: rejectPrompt };
+        this.setPage({ kind: "prompt", providerName: method.providerName, prompt, cursor: 0, value: "", secretLength: 0 });
+      }),
+    }).then(() => {
+      this.promptWaiter = undefined;
+      this.secret = "";
+      return this.finish(method.providerId, method.providerName);
+    }).catch((error) => {
+      if (controller.signal.aborted) return;
+      this.setPage({ kind: "error", title: `${method.providerName} login failed`, message: safeError(error, [this.secret]) });
+      this.secret = "";
+    });
+  }
+
+  private startCustom() {
+    const endpoint = this.endpoint;
+    const key = this.customKey;
+    this.retry = () => this.startCustom();
+    const controller = new AbortController();
+    this.cancelOperation();
+    this.controller = controller;
+    this.setPage({ kind: "custom-working", endpoint, message: "Discovering OpenAI-compatible models…" });
+    void discoverOpenAIModels(endpoint, key, { signal: controller.signal }).then(async ({ baseUrl, models }) => {
+      const providerId = customProviderId(baseUrl);
+      this.setPage({ kind: "custom-working", endpoint, message: `Saving ${models.length} discovered models…` });
+      await persistCustomProvider(providerId, baseUrl, models);
+      await this.runtime.refresh({ providers: [providerId], signal: controller.signal });
+      await this.runtime.login(providerId, "api_key", {
+        signal: controller.signal,
+        notify: () => {},
+        prompt: async () => key || "local",
+      });
+      this.customKey = "";
+      await this.finish(providerId, this.runtime.getProvider(providerId)?.name ?? providerId);
+    }).catch((error) => {
+      if (controller.signal.aborted) return;
+      this.setPage({ kind: "error", title: "Custom provider setup failed", message: safeError(error, [key]) });
+    });
+  }
+
+  private updateText(key: LoginKey, value: string, setValue: (next: string) => void): boolean {
+    if (key.name === "backspace") {
+      setValue(value.slice(0, -1));
+      return true;
+    }
+    const text = key.sequence ?? "";
+    if (!key.ctrl && !key.meta && !key.option && text.length > 0 && !/[\u0000-\u001f\u007f]/.test(text)) {
+      setValue(value + text);
+      return true;
+    }
+    return false;
+  }
+
+  handleKey(key: LoginKey): boolean {
+    const enter = key.name === "return" || key.name === "enter" || key.name === "kpenter" || key.name === "linefeed";
+    if (key.name === "escape") {
+      if (this.page.kind === "providers" || this.page.kind === "success" || this.page.kind === "error") this.close();
+      else if (this.page.kind === "custom-key") this.setPage({ kind: "custom-endpoint", endpoint: this.endpoint });
+      else {
+        this.cancelOperation();
+        this.setPage(this.providerPage());
+      }
+      return true;
+    }
+    if (this.page.kind === "providers") {
+      const count = this.page.methods.length + 1;
+      if (key.name === "up" || key.name === "down") {
+        const step = key.name === "up" ? -1 : 1;
+        this.providerCursor = (this.page.cursor + step + count) % count;
+        this.setPage({ ...this.page, cursor: this.providerCursor });
+      } else if (enter) {
+        const method = this.page.methods[this.page.cursor];
+        if (method) this.startProvider(method);
+        else this.setPage({ kind: "custom-endpoint", endpoint: this.endpoint });
+      }
+      return true;
+    }
+    if (this.page.kind === "prompt") {
+      if (this.page.prompt.type === "select") {
+        if (key.name === "up" || key.name === "down") {
+          const count = this.page.prompt.options.length;
+          if (count) this.setPage({ ...this.page, cursor: (this.page.cursor + (key.name === "up" ? -1 : 1) + count) % count });
+        } else if (enter) {
+          const option = this.page.prompt.options[this.page.cursor];
+          if (option) {
+            this.promptWaiter?.resolve(option.id);
+            this.promptWaiter = undefined;
+            this.setPage({ kind: "working", providerName: this.page.providerName });
+          }
+        }
+      } else if (enter) {
+        const value = this.page.prompt.type === "secret" ? this.secret : this.page.value;
+        this.promptWaiter?.resolve(value);
+        this.promptWaiter = undefined;
+        this.setPage({ kind: "working", providerName: this.page.providerName });
+      } else if (this.page.prompt.type === "secret") {
+        const current = this.page;
+        this.updateText(key, this.secret, (next) => {
+          this.secret = next;
+          this.setPage({ ...current, secretLength: next.length });
+        });
+      } else {
+        const current = this.page;
+        this.updateText(key, current.value, (next) => this.setPage({ ...current, value: next }));
+      }
+      return true;
+    }
+    if (this.page.kind === "custom-endpoint") {
+      if (enter) {
+        this.endpoint = this.page.endpoint;
+        this.setPage({ kind: "custom-key", endpoint: this.endpoint, secretLength: this.customKey.length });
+      } else this.updateText(key, this.page.endpoint, (next) => {
+        this.endpoint = next;
+        this.setPage({ kind: "custom-endpoint", endpoint: next });
+      });
+      return true;
+    }
+    if (this.page.kind === "custom-key") {
+      if (enter) this.startCustom();
+      else {
+        const current = this.page;
+        this.updateText(key, this.customKey, (next) => {
+          this.customKey = next;
+          this.setPage({ ...current, secretLength: next.length });
+        });
+      }
+      return true;
+    }
+    if (this.page.kind === "error" && enter) {
+      this.retry?.();
+      return true;
+    }
+    if (this.page.kind === "success" && enter) {
+      this.close();
+      return true;
+    }
+    return true;
+  }
+}

package/src/login-flow.ts

@@ -0,0 +1,170 @@
+import type { AuthType, Model, Provider } from "@earendil-works/pi-ai";
+import type { ModelRuntime } from "@earendil-works/pi-coding-agent";
+import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import { dirname } from "node:path";
+import { MODELS_PATH } from "./config";
+
+export type LoginMethod = {
+  providerId: string;
+  providerName: string;
+  authType: AuthType;
+  methodName: string;
+  loginLabel?: string;
+  canLogin: boolean;
+};
+
+export function providerLoginMethods(providers: readonly Provider[]): LoginMethod[] {
+  return providers.flatMap((provider) => {
+    const methods: LoginMethod[] = [];
+    if (provider.auth.oauth) {
+      methods.push({
+        providerId: provider.id,
+        providerName: provider.name,
+        authType: "oauth",
+        methodName: provider.auth.oauth.name,
+        loginLabel: provider.auth.oauth.loginLabel,
+        canLogin: true,
+      });
+    }
+    if (provider.auth.apiKey) {
+      methods.push({
+        providerId: provider.id,
+        providerName: provider.name,
+        authType: "api_key",
+        methodName: provider.auth.apiKey.name,
+        canLogin: typeof provider.auth.apiKey.login === "function",
+      });
+    }
+    return methods;
+  }).sort((a, b) =>
+    a.providerName.localeCompare(b.providerName) || a.authType.localeCompare(b.authType),
+  );
+}
+
+export function safeError(error: unknown, secrets: readonly string[] = []): string {
+  let message = error instanceof Error ? error.message : String(error);
+  for (const secret of secrets) {
+    if (secret) message = message.replaceAll(secret, "[redacted]");
+  }
+  message = message.replace(/\b(?:sk|key|token)-[A-Za-z0-9_.-]{8,}\b/gi, "[redacted]");
+  return message;
+}
+
+export function normalizeOpenAIEndpoint(input: string): string {
+  const raw = input.trim();
+  if (!raw) throw new Error("Enter an endpoint URL.");
+  let url: URL;
+  try {
+    url = new URL(raw);
+  } catch {
+    throw new Error("Enter a complete http:// or https:// endpoint URL.");
+  }
+  if (url.protocol !== "http:" && url.protocol !== "https:") {
+    throw new Error("The endpoint must use http:// or https://.");
+  }
+  if (url.username || url.password) throw new Error("Remove credentials from the endpoint URL.");
+  if (url.search || url.hash) throw new Error("Remove the query string and fragment from the endpoint URL.");
+  let pathname = url.pathname.replace(/\/+$/, "");
+  pathname = pathname.replace(/\/(?:models|chat\/completions|responses)$/i, "");
+  if (!/\/v\d+(?:beta)?$/i.test(pathname)) pathname += "/v1";
+  url.pathname = pathname;
+  return url.toString().replace(/\/$/, "");
+}
+
+export type DiscoveredModel = { id: string; name?: string };
+
+export async function discoverOpenAIModels(
+  endpoint: string,
+  apiKey: string,
+  options: { fetch?: typeof fetch; signal?: AbortSignal } = {},
+): Promise<{ baseUrl: string; models: DiscoveredModel[] }> {
+  const baseUrl = normalizeOpenAIEndpoint(endpoint);
+  const fetchImpl = options.fetch ?? fetch;
+  const response = await fetchImpl(`${baseUrl}/models`, {
+    headers: apiKey ? { Authorization: `Bearer ${apiKey}` } : undefined,
+    signal: options.signal,
+  });
+  if (!response.ok) {
+    throw new Error(`Model discovery failed with HTTP ${response.status}. Check the endpoint and API key.`);
+  }
+  const body = await response.json() as { data?: unknown };
+  if (!Array.isArray(body.data)) {
+    throw new Error("The endpoint did not return an OpenAI-compatible model list at /models.");
+  }
+  const models = body.data.flatMap((entry): DiscoveredModel[] => {
+    if (!entry || typeof entry !== "object") return [];
+    const id = (entry as { id?: unknown }).id;
+    if (typeof id !== "string" || !id.trim()) return [];
+    const name = (entry as { name?: unknown }).name;
+    return [{ id: id.trim(), ...(typeof name === "string" && name.trim() ? { name: name.trim() } : {}) }];
+  });
+  if (models.length === 0) throw new Error("The OpenAI-compatible model list was empty.");
+  return { baseUrl, models };
+}
+
+export function customProviderId(baseUrl: string): string {
+  const host = new URL(baseUrl).host.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+  return `custom-${host || "provider"}`;
+}
+
+type ModelsFile = { providers?: Record<string, unknown>; [key: string]: unknown };
+
+export async function persistCustomProvider(
+  providerId: string,
+  baseUrl: string,
+  models: readonly DiscoveredModel[],
+  path = MODELS_PATH,
+): Promise<void> {
+  let current: ModelsFile = {};
+  try {
+    current = JSON.parse(await readFile(path, "utf8")) as ModelsFile;
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error;
+  }
+  const next: ModelsFile = {
+    ...current,
+    providers: {
+      ...(current.providers ?? {}),
+      [providerId]: {
+        name: `Custom (${new URL(baseUrl).host})`,
+        baseUrl,
+        api: "openai-completions",
+        authHeader: true,
+        compat: {
+          supportsDeveloperRole: false,
+          supportsReasoningEffort: false,
+        },
+        models: models.map((model) => ({
+          id: model.id,
+          name: model.name ?? model.id,
+          reasoning: false,
+          input: ["text"],
+          contextWindow: 128000,
+          maxTokens: 16384,
+        })),
+      },
+    },
+  };
+  await mkdir(dirname(path), { recursive: true });
+  const temporary = `${path}.${process.pid}.${Date.now()}.tmp`;
+  await writeFile(temporary, `${JSON.stringify(next, null, 2)}\n`, { encoding: "utf8", mode: 0o600 });
+  await rename(temporary, path);
+}
+
+export async function refreshAndSelectModel(
+  runtime: ModelRuntime,
+  providerId: string,
+  setModel: (model: Model<any>) => Promise<void>,
+  signal?: AbortSignal,
+  currentModel?: Model<any>,
+): Promise<Model<any> | undefined> {
+  await runtime.refresh({ providers: [providerId], allowNetwork: true, signal });
+  const available = runtime.getAvailableSnapshot();
+  const current = currentModel && available.find((candidate) =>
+    candidate.provider === currentModel.provider && candidate.id === currentModel.id,
+  );
+  if (current) return current;
+  const model = available.find((candidate) => candidate.provider === providerId) ?? available[0];
+  if (model) await setModel(model);
+  return model;
+}