pi-llama-cpp 0.12.0 → 0.14.0

package/src/sse/fetch.ts

@@ -0,0 +1,43 @@
+/**
+ * Auth and stream plumbing for llama-server's SSE endpoint.
+ *
+ * llama-server validates the API key from the `Authorization` (or
+ * `X-Api-Key`) header only — it no longer accepts it as a query parameter —
+ * and `EventSource` cannot send custom headers. The stream is therefore
+ * consumed with `fetch` and parsed manually by {@link SSEClient}.
+ *
+ * `buildAuthHeaders` is shared by {@link SSEClient} and
+ * {@link SSEManager.probeSSE} so the two can't drift.
+ */
+
+/**
+ * Builds the auth headers for a llama-server request, including the API key
+ * as an `Authorization: Bearer` header when one is set.
+ */
+export const buildAuthHeaders = (apiKey?: string): Record<string, string> =>
+  apiKey ? { Authorization: `Bearer ${apiKey}` } : {};
+
+/**
+ * Opens the SSE stream at the given endpoint, authenticating via headers.
+ *
+ * @returns the response body as a stream of raw bytes
+ * @throws if the request fails or the server responds with an error status
+ */
+export const openSSEStream = async (
+  endpoint: string,
+  apiKey?: string,
+  signal?: AbortSignal,
+): Promise<ReadableStream<Uint8Array>> => {
+  const response = await fetch(endpoint, {
+    method: "GET",
+    headers: buildAuthHeaders(apiKey),
+    signal,
+  });
+
+  if (!response.ok || !response.body) {
+    await response.body?.cancel();
+    throw new Error(`SSE connection failed: HTTP ${response.status}`);
+  }
+
+  return response.body;
+};

package/src/sse/manager.ts

@@ -1,5 +1,6 @@
 import type { Server } from "../server";
-import { SSEClient, buildSSEUrl } from "./client";
+import { SSEClient } from "./client";
+import { buildAuthHeaders } from "./fetch";
 import {
   DownloadProgressData,
   ProgressData,
@@ -14,7 +15,7 @@ import {
  * Manages SSE connections and event routing for a single llama-server instance.
  *
  * Handles:
- * - Shared EventSource connection
+ * - Shared SSE connection
  * - Model-based event subscription with callback aggregation
  * - Progress parsing and callback dispatch
  */
@@ -24,26 +25,7 @@ export class SSEManager {
   private modelCallbacks: Map<string, SSECallback[]> = new Map();
   private sseSupported: boolean | null = null;
 
-  constructor(
-    private readonly server: Server,
-    private readonly apiKey: string,
-  ) {}
-
-  /**
-   * Maximum time (ms) for server verification and SSE support probe.
-   * Delegates to the owning {@link Server}.
-   */
-  async getServerTimeout(): Promise<number> {
-    return this.server.getServerTimeout();
-  }
-
-  /**
-   * Maximum time (ms) to wait for model loading before giving up.
-   * Delegates to the owning {@link Server}.
-   */
-  async getPollingTimeout(): Promise<number> {
-    return this.server.getPollingTimeout();
-  }
+  constructor(private readonly server: Server) {}
 
   /**
    * The SSE endpoint URL.
@@ -62,10 +44,10 @@ export class SSEManager {
     if (this.sseSupported !== null) return this.sseSupported;
 
     try {
-      const url = buildSSEUrl(this.sseEndpoint, this.apiKey);
-      const response = await fetch(url, {
+      const response = await fetch(this.sseEndpoint, {
         method: "GET",
-        signal: AbortSignal.timeout(await this.getServerTimeout()),
+        headers: buildAuthHeaders(this.server.getApiKey()),
+        signal: AbortSignal.timeout(await this.server.getServerTimeout()),
       });
       this.sseSupported =
         response.ok &&
@@ -96,7 +78,7 @@ export class SSEManager {
     this.modelCallbacks.set(modelId, callbacks);
 
     // Create SSE client if not already created
-    this.sseClient ??= new SSEClient(this.sseEndpoint, this.apiKey);
+    this.sseClient ??= new SSEClient(this.sseEndpoint, this.server.getApiKey());
 
     // Subscribe a single dispatching callback to the SSE client
     if (!this.sseSubscribers.has(modelId)) {
@@ -181,7 +163,7 @@ export class SSEManager {
    */
   async subscribeToStatus(modelId: string): Promise<StatusChangeData> {
     return new Promise(async (resolve, reject) => {
-      const pollingTimeout = await this.getPollingTimeout();
+      const pollingTimeout = await this.server.getPollingTimeout();
       const timeout = setTimeout(
         () => reject(new Error(`SSE status timeout for model: ${modelId}`)),
         pollingTimeout,

package/src/sse/types.ts

@@ -8,10 +8,6 @@
 export const SSEEventType = {
   status_change: "status_change",
   download_progress: "download_progress",
-  download_finished: "download_finished",
-  download_failed: "download_failed",
-  models_reload: "models_reload",
-  model_remove: "model_remove",
 } as const;
 
 export type SSEEventType = (typeof SSEEventType)[keyof typeof SSEEventType];

package/src/ui/dialog/base.ts

@@ -0,0 +1,118 @@
+import { DynamicBorder, type Theme } from "@earendil-works/pi-coding-agent";
+import type {
+  Component,
+  Keybinding,
+  SelectListTheme,
+  TUI,
+} from "@earendil-works/pi-tui";
+import {
+  Container,
+  getKeybindings,
+  Spacer,
+  Text,
+} from "@earendil-works/pi-tui";
+
+/**
+ * Base dialog class encapsulating the shared Component plumbing (framed
+ * container, input delegation, themes) so concrete dialogs only declare
+ * their body and their input target — they don't repeat the
+ * `invalidate`/`render`/`handleInput` delegation code.
+ */
+export abstract class BaseDialog {
+  protected theme: Theme;
+  protected tui: TUI;
+  /** The framed container every concrete dialog renders into. */
+  private readonly frame = new Container();
+
+  constructor(theme: Theme, tui: TUI) {
+    this.theme = theme;
+    this.tui = tui;
+  }
+
+  // -- Component -------------------------------------------------------------
+
+  invalidate(): void {
+    this.frame.invalidate();
+  }
+
+  /** Routes input to the concrete dialog's interactive child. */
+  handleInput(data: string): void {
+    this.inputTarget.handleInput(data);
+    this.tui.requestRender();
+  }
+
+  render(width: number): string[] {
+    return this.frame.render(width);
+  }
+
+  // -- Focusable -------------------------------------------------------------
+
+  private isFocused = false;
+
+  get focused(): boolean {
+    return this.isFocused;
+  }
+
+  set focused(value: boolean) {
+    this.isFocused = value;
+    // Forward to the interactive child when it manages focus (e.g. the
+    // text `Input`); plain select lists don't have a `focused` flag.
+    const target = this.inputTarget as { focused?: boolean };
+    if ("focused" in target) target.focused = value;
+  }
+
+  // -- shared utilities ------------------------------------------------------
+
+  /** The component keystrokes are routed to (e.g. the text input or the
+   * option list). */
+  protected abstract get inputTarget(): {
+    handleInput(data: string): void;
+  };
+
+  /**
+   * Builds the framed chrome (borders, title, footer) around `body`.
+   * Concrete dialogs call this once from their constructor, after
+   * assembling the body.
+   */
+  protected setFrame(title: string, body: Component[], footer?: string): void {
+    this.frame.addChild(
+      new DynamicBorder((text) => this.theme.fg("accent", text)),
+    );
+    this.frame.addChild(
+      new Text(this.theme.fg("accent", this.theme.bold(title)), 1, 0),
+    );
+    for (const child of body) this.frame.addChild(child);
+    if (footer) {
+      this.frame.addChild(new Spacer(1));
+      this.frame.addChild(new Text(this.theme.fg("dim", footer), 1, 0));
+    }
+    this.frame.addChild(
+      new DynamicBorder((text) => this.theme.fg("accent", text)),
+    );
+  }
+
+  protected selectListTheme(): SelectListTheme {
+    return {
+      selectedPrefix: (text) => this.theme.fg("accent", text),
+      selectedText: (text) => this.theme.fg("accent", text),
+      description: (text) => this.theme.fg("muted", text),
+      scrollInfo: (text) => this.theme.fg("dim", text),
+      noMatch: (text) => this.theme.fg("warning", text),
+    };
+  }
+
+  protected hint(action: Keybinding, description: string): string {
+    const keys = getKeybindings().getKeys(action).join("/");
+    return (
+      this.theme.fg("dim", keys) + this.theme.fg("muted", ` ${description}`)
+    );
+  }
+
+  protected inputFooter(): string {
+    return `${this.hint("tui.select.confirm", "save")} • ${this.hint("tui.select.cancel", "cancel")}`;
+  }
+
+  protected selectFooter(): string {
+    return `${this.hint("tui.select.confirm", "select")} • ${this.hint("tui.select.cancel", "cancel")}`;
+  }
+}

package/src/ui/dialog/confirm.ts

@@ -0,0 +1,45 @@
+import { SelectList, Spacer, Text } from "@earendil-works/pi-tui";
+import { BaseDialog } from "./base";
+import type { ConfirmDialogOptions } from "./options";
+
+/**
+ * A framed confirmation dialog with a two-option `SelectList`
+ * (Delete / Cancel), matching the confirm pattern of pi's `/llama` view.
+ */
+export class ConfirmDialog extends BaseDialog {
+  private readonly list: SelectList;
+
+  constructor(options: ConfirmDialogOptions) {
+    super(options.theme, options.tui);
+
+    this.list = new SelectList(
+      [
+        { value: "confirm", label: "Delete" },
+        { value: "cancel", label: "Cancel" },
+      ],
+      2,
+      this.selectListTheme(),
+    );
+    this.list.onSelect = (item) => {
+      if (item.value === "confirm") options.onConfirm();
+      else options.onCancel();
+    };
+    this.list.onCancel = () => options.onCancel();
+
+    this.setFrame(
+      options.title,
+      [
+        new Text(this.theme.fg("text", options.message), 1, 0),
+        new Spacer(1),
+        this.list,
+      ],
+      this.selectFooter(),
+    );
+  }
+
+  // -- helpers -------------------------------------------------------------------
+
+  protected get inputTarget() {
+    return this.list;
+  }
+}

package/src/ui/dialog/factory.ts

@@ -0,0 +1,111 @@
+import type { Theme } from "@earendil-works/pi-coding-agent";
+import type { SettingItem, TUI } from "@earendil-works/pi-tui";
+import { ConfirmDialog } from "./confirm";
+import { InputDialog } from "./input";
+import type { ConfirmDialogOptions, InputDialogOptions } from "./options";
+
+/** `InputDialog` options minus the deps the factory injects. */
+type InputOptions = Omit<InputDialogOptions, "theme" | "tui">;
+
+/** `ConfirmDialog` options minus the deps the factory injects. */
+type ConfirmOptions = Omit<ConfirmDialogOptions, "theme" | "tui">;
+
+/**
+ * Single factory for constructing dialogs. Holds `theme` and `tui` once
+ * in the constructor so callers never thread the `{ theme, tui }` deps
+ * tuple by hand, and so all dialog construction idioms (raw constructors,
+ * static factories, per-field submenu builders) live in one place.
+ *
+ * Usage:
+ * ```ts
+ * const dialogs = new DialogFactory(theme, tui);
+ * dialogs.input({ title, message, onSubmit, onCancel });
+ * dialogs.confirmDelete(TITLES.deleteServer, name, onConfirm, onCancel);
+ * dialogs.inputSubmenu(TITLES.edit(label), message, placeholder, validate);
+ * ```
+ */
+export class DialogFactory {
+  constructor(
+    private readonly theme: Theme,
+    /** Used internally to request re-renders after async dialog commits
+     * (e.g. the wizard). */
+    private readonly tui: TUI,
+  ) {}
+
+  /** Requests a UI re-render. Used by callers that need to update the
+   * display asynchronously after a dialog commit. */
+  requestRender(): void {
+    this.tui.requestRender();
+  }
+
+  /** Creates a framed text-input dialog: Enter commits, Esc cancels. */
+  input(options: InputOptions): InputDialog {
+    return new InputDialog({ ...options, theme: this.theme, tui: this.tui });
+  }
+
+  /** Creates a framed confirmation dialog with a two-option select list. */
+  confirm(options: ConfirmOptions): ConfirmDialog {
+    return new ConfirmDialog({
+      ...options,
+      theme: this.theme,
+      tui: this.tui,
+    });
+  }
+
+  /**
+   * Creates a delete confirmation dialog.
+   *
+   * @param title — Dialog title (e.g. `TITLES.deleteServer` or `TITLES.deleteOverride`).
+   * @param name — The name of the entry being deleted.
+   * @param onConfirm — Callback when the user confirms.
+   * @param onCancel — Callback when the user cancels.
+   */
+  confirmDelete(
+    title: string,
+    name: string,
+    onConfirm: () => void,
+    onCancel: () => void,
+  ): ConfirmDialog {
+    return this.confirm({
+      title,
+      message: `Delete "${name}"?`,
+      onConfirm,
+      onCancel,
+    });
+  }
+
+  /**
+   * Builds a `SettingItem.submenu` factory that opens an `InputDialog`
+   * (absorbs the former `InputSubmenuFactory`).
+   *
+   * The produced submenu prefills from the `currentValue` the containing
+   * `SettingsList` passes at activation time — not a value captured at
+   * build time — so re-entering a field after a commit shows the
+   * just-saved value.
+   *
+   * @param title — Dialog title (e.g. `TITLES.edit(field.label)`).
+   * @param message — Prompt shown inside the dialog.
+   * @param placeholder — Optional example value shown dim in the dialog.
+   * @param validate — Optional validation function for committed values.
+   */
+  inputSubmenu(
+    title: string,
+    message: string,
+    placeholder?: string,
+    validate?: (raw: string) => string | null,
+  ): SettingItem["submenu"] {
+    return (currentValue, done) => {
+      const dialog = this.input({
+        title,
+        message,
+        placeholder,
+        initialValue: currentValue,
+        validate,
+        onSubmit: (value) => done(value),
+        onCancel: () => done(undefined),
+      });
+      dialog.focused = true;
+      return dialog;
+    };
+  }
+}

package/src/ui/dialog/input.ts

@@ -0,0 +1,63 @@
+import { Container, Input, Text } from "@earendil-works/pi-tui";
+import { BaseDialog } from "./base";
+import type { InputDialogOptions } from "./options";
+
+/**
+ * Framed text-input dialog: Enter commits the validated value, Esc cancels.
+ */
+export class InputDialog extends BaseDialog {
+  private readonly options: InputDialogOptions;
+  private readonly body = new Container();
+  private readonly input = new Input();
+  private errorText: Text | undefined;
+
+  constructor(options: InputDialogOptions) {
+    super(options.theme, options.tui);
+    this.options = options;
+
+    const initial = options.initialValue ?? "";
+    this.input.setValue(initial);
+    for (let i = 0; i < [...initial].length; i++) {
+      this.input.handleInput("\x1b[C");
+    }
+    this.input.onSubmit = (value) => this.submit(value);
+    this.input.onEscape = () => options.onCancel();
+
+    this.body.addChild(new Text(this.theme.fg("text", options.message), 1, 0));
+    if (options.placeholder) {
+      this.body.addChild(
+        new Text(this.theme.fg("dim", `e.g., ${options.placeholder}`), 1, 0),
+      );
+    }
+    this.body.addChild(this.input);
+
+    this.setFrame(options.title, [this.body], this.inputFooter());
+  }
+
+  // -- helpers -------------------------------------------------------------------
+
+  protected get inputTarget() {
+    return this.input;
+  }
+
+  private submit(raw: string): void {
+    const validated = this.options.validate ? this.options.validate(raw) : raw;
+    if (validated === null) {
+      this.setError(`Invalid value "${raw}"`);
+      return;
+    }
+    this.options.onSubmit(validated);
+  }
+
+  private setError(message: string | undefined): void {
+    if (this.errorText) {
+      this.body.removeChild(this.errorText);
+      this.errorText = undefined;
+    }
+    if (message) {
+      this.errorText = new Text(this.theme.fg("error", message), 1, 0);
+      this.body.addChild(this.errorText);
+    }
+    this.tui.requestRender();
+  }
+}

package/src/ui/dialog/options.ts

@@ -0,0 +1,23 @@
+import type { Theme } from "@earendil-works/pi-coding-agent";
+import type { TUI } from "@earendil-works/pi-tui";
+
+export interface ConfirmDialogOptions {
+  theme: Theme;
+  tui: TUI;
+  title: string;
+  message: string;
+  onConfirm: () => void;
+  onCancel: () => void;
+}
+
+export interface InputDialogOptions {
+  theme: Theme;
+  tui: TUI;
+  title: string;
+  message: string;
+  placeholder?: string;
+  initialValue?: string;
+  validate?: (raw: string) => string | null;
+  onSubmit: (value: string) => void;
+  onCancel: () => void;
+}

package/src/ui/editors/editorOptions.ts

@@ -0,0 +1,43 @@
+import type { Theme } from "@earendil-works/pi-coding-agent";
+import type { KeybindingsManager, TUI } from "@earendil-works/pi-tui";
+import type { LlamaServer } from "../../interfaces/settings";
+
+/**
+ * Shared options for SettingsList-based editors that operate on
+ * `LlamaServer[]`. Subtypes add editor-specific fields.
+ */
+export interface SettingsListEditorOptions {
+  /** TUI instance, used to request re-renders after async persists */
+  tui: TUI;
+  /** Theme for dialogs (from the ctx.ui.custom factory) */
+  theme: Theme;
+  /** App keybindings manager (injected by ctx.ui.custom) */
+  keybindings: KeybindingsManager;
+  /**
+   * Snapshot of the merged `llamaSettings.servers` to edit. Replaced
+   * in place (`options.servers = next`) after every successful persist.
+   */
+  servers: LlamaServer[];
+  /** Persists a new server list; a rejection keeps the current list */
+  persist: (next: LlamaServer[]) => Promise<void>;
+  /** Closes the editor (called on Esc in the server list) */
+  done: () => void;
+  /** Notifies about persistence errors */
+  onError: (message: string) => void;
+}
+
+/**
+ * Options for the SettingsList-based server editor.
+ */
+export interface ServerSettingsListOptions extends SettingsListEditorOptions {
+  /** Timeout (ms) for health checks. Defaults to 1000ms if not provided. */
+  serverTimeout?: number;
+}
+
+/**
+ * Options for the SettingsList-based overrides editor.
+ */
+export interface OverrideSettingsListOptions extends SettingsListEditorOptions {
+  /** Called after a successful add/edit/delete */
+  onChanged: () => void;
+}

package/src/ui/editors/itemBuilder.ts

@@ -0,0 +1,47 @@
+import type { SettingItem } from "@earendil-works/pi-tui";
+import type { DialogFactory } from "../dialog/factory";
+import type { SettingField } from "./settingField";
+
+/**
+ * Base class for building `SettingItem` arrays from a declarative field
+ * registry (Template Method): {@link buildFieldItems} maps the ordered
+ * {@link fields} registry over {@link buildItem}, which fills the common
+ * columns from the field and delegates field-type-specific columns (e.g.
+ * submenu or fixed values) to {@link decorate}.
+ *
+ * Injects a {@link DialogFactory} once in the constructor so subclasses
+ * can build input submenus without threading `theme`/`tui` around.
+ */
+export abstract class ItemBuilder<TEntry, TField extends SettingField<TEntry>> {
+  constructor(protected readonly dialogs: DialogFactory) {}
+
+  /** The ordered field registry; order defines the row order in the list. */
+  protected abstract get fields(): readonly TField[];
+
+  /**
+   * Builds the `SettingItem` for one field of an entry: fills the common
+   * columns from the field, then hands the partial item to
+   * {@link decorate}.
+   */
+  private buildItem(def: TField, entry: TEntry): SettingItem {
+    const base: SettingItem = {
+      id: def.id,
+      label: def.label,
+      description: def.description,
+      currentValue: def.currentValue(entry),
+    };
+    return this.decorate(def, entry, base);
+  }
+
+  /** Builds the `SettingItem` array for one entry's editable fields. */
+  buildFieldItems(entry: TEntry): SettingItem[] {
+    return this.fields.map((def) => this.buildItem(def, entry));
+  }
+
+  /** Adds field-type-specific columns (e.g. submenu or fixed values). */
+  protected abstract decorate(
+    def: TField,
+    entry: TEntry,
+    base: SettingItem,
+  ): SettingItem;
+}