@aliou/pi-ts-aperture 0.5.1 → 0.6.0

package/src/commands/setup.ts

@@ -1,232 +0,0 @@
-/**
- * aperture:setup -- interactive wizard for configuring Aperture.
- *
- * Steps:
- * 1. URL input (health check runs inline on Enter, auto-advances on success)
- * 2. Provider selection with per-provider "verify models" sub-option
- */
-
-import {
-  FuzzyMultiSelector,
-  type FuzzyMultiSelectorItem,
-  getSettingsTheme,
-  type SettingsTheme,
-  Wizard,
-  type WizardStepContext,
-} from "@aliou/pi-utils-settings";
-import type {
-  ExtensionAPI,
-  ExtensionContext,
-} from "@mariozechner/pi-coding-agent";
-import type { Component, TUI } from "@mariozechner/pi-tui";
-import { Input } from "@mariozechner/pi-tui";
-import { configLoader } from "../lib/config";
-import { checkApertureHealth } from "../lib/gateway";
-import { normalizeInputUrl } from "../lib/url";
-
-const SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
-
-// ---------------------------------------------------------------------------
-// Step 1: URL input with inline health check
-// ---------------------------------------------------------------------------
-
-class UrlStep implements Component {
-  private input: Input;
-  private theme: SettingsTheme;
-  private tui: TUI;
-  private wizCtx: WizardStepContext;
-  private onUrl: (url: string) => void;
-  private readonly placeholder = "ai.pango-lin.ts.net";
-
-  private state: "idle" | "checking" | "ok" | "error" = "idle";
-  private errorMessage = "";
-  private frame = 0;
-  private timer: ReturnType<typeof setInterval> | null = null;
-
-  constructor(
-    theme: SettingsTheme,
-    tui: TUI,
-    currentValue: string,
-    wizCtx: WizardStepContext,
-    onUrl: (url: string) => void,
-  ) {
-    this.theme = theme;
-    this.tui = tui;
-    this.wizCtx = wizCtx;
-    this.onUrl = onUrl;
-    this.input = new Input();
-    if (currentValue) {
-      this.input.setValue(currentValue);
-    }
-    this.input.onSubmit = () => this.submit();
-  }
-
-  private submit(): void {
-    const value = this.input.getValue().trim();
-    if (!value || this.state === "checking") return;
-
-    const url = normalizeInputUrl(value);
-    this.state = "checking";
-    this.frame = 0;
-
-    this.timer = setInterval(() => {
-      this.frame = (this.frame + 1) % SPINNER_FRAMES.length;
-      this.tui.requestRender();
-    }, 80);
-
-    checkApertureHealth(url).then((res) => {
-      if (this.timer) clearInterval(this.timer);
-      this.timer = null;
-
-      if (res.ok) {
-        this.state = "ok";
-        this.onUrl(url);
-        this.wizCtx.markComplete();
-        this.tui.requestRender();
-        setTimeout(() => this.wizCtx.goNext(), 400);
-      } else {
-        this.state = "error";
-        this.errorMessage = res.error ?? "unknown error";
-        this.tui.requestRender();
-      }
-    });
-  }
-
-  render(width: number): string[] {
-    const lines: string[] = [];
-
-    lines.push(
-      this.theme.hint(`  Aperture base URL (e.g. ${this.placeholder}):`),
-    );
-    lines.push(`  ${this.input.render(width - 4).join("")}`);
-    lines.push("");
-
-    if (this.state === "checking") {
-      const spinner = SPINNER_FRAMES[this.frame];
-      lines.push(this.theme.hint(`  ${spinner} Checking connection...`));
-    } else if (this.state === "ok") {
-      lines.push(this.theme.hint("  Connected."));
-    } else if (this.state === "error") {
-      lines.push(this.theme.hint(`  Could not connect: ${this.errorMessage}`));
-      lines.push(this.theme.hint("  Fix the URL and press Enter to retry."));
-    }
-
-    return lines;
-  }
-
-  invalidate(): void {}
-
-  handleInput(data: string): void {
-    if (this.state === "checking") return;
-    this.state = "idle";
-    this.input.handleInput(data);
-  }
-
-  dispose(): void {
-    if (this.timer) clearInterval(this.timer);
-  }
-}
-
-// ---------------------------------------------------------------------------
-// Command registration
-// ---------------------------------------------------------------------------
-
-export function registerSetupCommand(
-  pi: ExtensionAPI,
-  onSync: (ctx: ExtensionContext) => void,
-): void {
-  pi.registerCommand("aperture:setup", {
-    description: "Configure Tailscale Aperture integration",
-    handler: async (_args, ctx) => {
-      if (!ctx.hasUI) {
-        ctx.ui.notify(
-          "aperture:setup requires an interactive terminal",
-          "error",
-        );
-        return;
-      }
-
-      const config = configLoader.getConfig();
-      const checkGatewayProviders = config.checkGatewayModels ?? [];
-
-      const knownProviders = Array.from(
-        new Set(ctx.modelRegistry.getAll().map((model) => model.provider)),
-      ).sort((a, b) => a.localeCompare(b));
-
-      let baseUrl = config.baseUrl;
-
-      const providerItems: FuzzyMultiSelectorItem[] = knownProviders.map(
-        (p) => ({
-          label: p,
-          checked: config.providers.includes(p),
-          subOptions: [
-            {
-              label: "verify models on gateway",
-              description:
-                "Warn at startup if this provider's models are missing from the Aperture gateway",
-              checked: checkGatewayProviders.includes(p),
-            },
-          ],
-        }),
-      );
-
-      const confirmed = await ctx.ui.custom<boolean | undefined>(
-        (tui, theme, _kb, done) => {
-          const settingsTheme = getSettingsTheme(theme);
-
-          return new Wizard({
-            title: "Aperture Setup",
-            theme: settingsTheme,
-            minContentHeight: 16,
-            steps: [
-              {
-                label: "URL",
-                build: (wCtx: WizardStepContext) =>
-                  new UrlStep(settingsTheme, tui, baseUrl, wCtx, (url) => {
-                    baseUrl = url;
-                  }),
-              },
-              {
-                label: "Providers",
-                build: (wCtx: WizardStepContext) => {
-                  wCtx.markComplete();
-                  return new FuzzyMultiSelector({
-                    label: "Providers to route through Aperture",
-                    items: providerItems,
-                    theme: settingsTheme,
-                    showHints: false,
-                    showCount: false,
-                    maxVisible: 7,
-                  });
-                },
-              },
-            ],
-            onComplete: () => done(true),
-            onCancel: () => done(undefined),
-          });
-        },
-      );
-
-      if (!confirmed) return;
-
-      const providers = providerItems
-        .filter((i) => i.checked)
-        .map((i) => i.label);
-
-      const checkGatewayModels = providerItems
-        .filter((i) => i.checked && i.subOptions?.[0]?.checked)
-        .map((i) => i.label);
-
-      await configLoader.save("global", {
-        baseUrl,
-        providers,
-        checkGatewayModels,
-      });
-      onSync(ctx);
-      ctx.ui.notify(
-        `Aperture configured: ${providers.length} provider(s) via ${baseUrl}`,
-        "info",
-      );
-    },
-  });
-}

package/src/extension/runtime.test.ts

@@ -1,121 +0,0 @@
-import { beforeEach, describe, expect, test, vi } from "vitest";
-import { configLoader } from "../lib/config";
-import { fetchGatewayModels } from "../lib/gateway";
-import type { Api, Model } from "../lib/types";
-import { ApertureRuntime } from "./runtime";
-
-vi.mock("../lib/config", () => ({
-  configLoader: {
-    getConfig: vi.fn(),
-  },
-}));
-
-vi.mock("../lib/gateway", () => ({
-  fetchGatewayModels: vi.fn(),
-}));
-
-const getConfig = vi.mocked(configLoader.getConfig);
-const fetchModels = vi.mocked(fetchGatewayModels);
-
-function model(provider: string, id: string): Model<Api> {
-  return { provider, id } as Model<Api>;
-}
-
-async function check(models: Model<Api>[]) {
-  const notify = vi.fn();
-  const runtime = new ApertureRuntime();
-
-  await runtime.checkMissingModels(
-    {
-      getModels: () => models,
-      notify,
-    },
-    "http://gateway.test",
-  );
-
-  return notify;
-}
-
-describe("ApertureRuntime.checkMissingModels", () => {
-  beforeEach(() => {
-    getConfig.mockReturnValue({
-      baseUrl: "http://gateway.test",
-      providers: [],
-      checkGatewayModels: ["synthetic"],
-    });
-    fetchModels.mockResolvedValue([]);
-  });
-
-  test("matches gateway models by provider and id", async () => {
-    fetchModels.mockResolvedValue([{ providerId: "openrouter", id: "foo" }]);
-
-    const notify = await check([
-      model("synthetic", "foo"),
-      model("openrouter", "foo"),
-    ]);
-
-    expect(notify).toHaveBeenCalledOnce();
-    expect(notify.mock.calls[0][0]).toContain("synthetic: foo");
-  });
-
-  test("only checks configured providers", async () => {
-    getConfig.mockReturnValue({
-      baseUrl: "http://gateway.test",
-      providers: [],
-      checkGatewayModels: ["synthetic"],
-    });
-    fetchModels.mockResolvedValue([{ providerId: "synthetic", id: "foo" }]);
-
-    const notify = await check([
-      model("synthetic", "foo"),
-      model("openrouter", "missing-openrouter"),
-    ]);
-
-    expect(notify).not.toHaveBeenCalled();
-  });
-
-  test("truncates missing models per provider", async () => {
-    getConfig.mockReturnValue({
-      baseUrl: "http://gateway.test",
-      providers: [],
-      checkGatewayModels: ["openrouter", "synthetic"],
-    });
-    fetchModels.mockResolvedValue([{ providerId: "synthetic", id: "syn-1" }]);
-
-    const notify = await check([
-      model("openrouter", "or-1"),
-      model("openrouter", "or-2"),
-      model("openrouter", "or-3"),
-      model("openrouter", "or-4"),
-      model("openrouter", "or-5"),
-      model("openrouter", "or-6"),
-      model("openrouter", "or-7"),
-      model("synthetic", "syn-1"),
-      model("synthetic", "syn-2"),
-      model("synthetic", "syn-3"),
-    ]);
-
-    expect(notify).toHaveBeenCalledOnce();
-    const message = notify.mock.calls[0][0];
-    expect(message).toContain(
-      "openrouter: or-1, or-2, or-3, or-4, or-5, 2 more",
-    );
-    expect(message).not.toContain("or-6");
-    expect(message).not.toContain("or-7");
-    expect(message).toContain("synthetic: syn-2, syn-3");
-  });
-
-  test("does not warn when all checked provider models exist", async () => {
-    fetchModels.mockResolvedValue([
-      { providerId: "synthetic", id: "foo" },
-      { providerId: "synthetic", id: "bar" },
-    ]);
-
-    const notify = await check([
-      model("synthetic", "foo"),
-      model("synthetic", "bar"),
-    ]);
-
-    expect(notify).not.toHaveBeenCalled();
-  });
-});

package/src/extension/runtime.ts

@@ -1,144 +0,0 @@
-/**
- * ApertureRuntime -- core extension runtime logic.
- *
- * Handles provider registration, unregistration, and gateway model checking.
- */
-
-import { getApiProvider } from "@mariozechner/pi-ai";
-import { configLoader } from "../lib/config";
-import { fetchGatewayModels } from "../lib/gateway";
-import type {
-  Api,
-  AssistantMessageEventStream,
-  CheckDeps,
-  Context,
-  Model,
-  SimpleStreamOptions,
-  SyncDeps,
-} from "../lib/types";
-import { resolveProviderBaseUrl } from "../lib/url";
-
-/**
- * Preserve provenance similarly to pi-synthetic so downstream providers can
- * attribute traffic to Pi / this extension.
- */
-const APERTURE_PROVENANCE_HEADERS = {
-  Referer: "https://pi.dev",
-  "X-Title": "npm:@aliou/pi-ts-aperture",
-};
-
-const MAX_MISSING_MODELS_PER_PROVIDER = 5;
-
-function resolveProviderHeaders(models: Model<Api>[]): Record<string, string> {
-  const modelHeaders = models.find((m) => m.headers)?.headers ?? {};
-  return {
-    ...APERTURE_PROVENANCE_HEADERS,
-    ...modelHeaders,
-  };
-}
-
-export class ApertureRuntime {
-  private registeredProviders = new Set<string>();
-
-  async sync(deps: SyncDeps): Promise<void> {
-    const config = configLoader.getConfig();
-    if (!config.baseUrl || config.providers.length === 0) {
-      return;
-    }
-
-    const baseUrl = resolveProviderBaseUrl(config);
-    if (!baseUrl) return;
-
-    const allModels = deps.getModels();
-
-    for (const providerName of config.providers) {
-      const providerModels = allModels.filter(
-        (m) => m.provider === providerName,
-      );
-      if (providerModels.length === 0) continue;
-
-      const api = providerModels[0].api ?? "openai-completions";
-      const builtIn = getApiProvider(api);
-
-      deps.registerProvider(providerName, {
-        baseUrl,
-        apiKey: "-",
-        headers: resolveProviderHeaders(providerModels),
-        api,
-        streamSimple: builtIn
-          ? (
-              model: Model<Api>,
-              context: Context,
-              options?: SimpleStreamOptions,
-            ): AssistantMessageEventStream =>
-              builtIn.streamSimple(model, context, {
-                ...options,
-                headers: {
-                  ...options?.headers,
-                  "x-session-id": options?.sessionId ?? "",
-                },
-              })
-          : undefined,
-      });
-
-      this.registeredProviders.add(providerName);
-    }
-  }
-
-  async checkMissingModels(deps: CheckDeps, gatewayUrl: string): Promise<void> {
-    const config = configLoader.getConfig();
-    if (config.checkGatewayModels.length === 0) return;
-
-    const gatewayModels = await fetchGatewayModels(gatewayUrl);
-    if (gatewayModels.length === 0) return;
-
-    const allModels = deps.getModels();
-    const checkedProviders = new Set(config.checkGatewayModels);
-    const gatewayModelKeys = new Set(
-      gatewayModels.map((m) => `${m.providerId}:${m.id}`),
-    );
-
-    const routedModels = allModels.filter((m) =>
-      checkedProviders.has(m.provider),
-    );
-    const missingModels = routedModels.filter(
-      (m) => !gatewayModelKeys.has(`${m.provider}:${m.id}`),
-    );
-
-    if (missingModels.length > 0) {
-      const missingByProvider = new Map<string, Model<Api>[]>();
-      for (const model of missingModels) {
-        const providerModels = missingByProvider.get(model.provider) ?? [];
-        providerModels.push(model);
-        missingByProvider.set(model.provider, providerModels);
-      }
-
-      const summary = Array.from(missingByProvider.entries())
-        .map(([provider, models]) => {
-          const shownModels = models
-            .slice(0, MAX_MISSING_MODELS_PER_PROVIDER)
-            .map((m) => m.id);
-          const remainingCount = models.length - shownModels.length;
-          const more = remainingCount > 0 ? `, ${remainingCount} more` : "";
-          return `${provider}: ${shownModels.join(", ")}${more}`;
-        })
-        .join("; ");
-
-      deps.notify(
-        `[aperture] models not available on gateway: ${summary}. Add them to the gateway configuration.`,
-        "warning",
-      );
-    }
-  }
-
-  /**
-   * Returns providers that should be unregistered based on config changes.
-   * Compares previous providers with new ones.
-   */
-  getProvidersToUnregister(
-    prevProviders: string[],
-    nextProviders: string[],
-  ): string[] {
-    return prevProviders.filter((p) => !nextProviders.includes(p));
-  }
-}

package/src/index.ts

@@ -1,97 +0,0 @@
-/**
- * Pi extension for Tailscale Aperture integration.
- *
- * Entry point orchestration:
- * - Load config
- * - Register session_start hook for provider registration
- * - Register user commands
- */
-
-import type {
-  ExtensionAPI,
-  ExtensionContext,
-} from "@mariozechner/pi-coding-agent";
-import { registerApertureSettings } from "./commands/settings";
-import { registerSetupCommand } from "./commands/setup";
-import { ApertureRuntime } from "./extension/runtime";
-import { configLoader } from "./lib/config";
-import { resolveGatewayUrl } from "./lib/url";
-
-export default async function (pi: ExtensionAPI): Promise<void> {
-  await configLoader.load();
-
-  const runtime = new ApertureRuntime();
-  let lastRegisteredProviders: string[] = [
-    ...configLoader.getConfig().providers,
-  ];
-
-  // Sync function used by commands after config changes
-  const onSync = (ctx: ExtensionContext): void => {
-    const config = configLoader.getConfig();
-
-    // Unregister providers that were removed from config
-    const prevProviders = lastRegisteredProviders;
-    const nextProviders = config.providers;
-    const toRemove = runtime.getProvidersToUnregister(
-      prevProviders,
-      nextProviders,
-    );
-    for (const provider of toRemove) {
-      pi.unregisterProvider(provider);
-      ctx.ui.notify(
-        `[aperture] unregistered ${provider}. Run /reload to use the native provider.`,
-        "info",
-      );
-    }
-
-    // Re-register providers
-    void runtime
-      .sync({
-        registerProvider: pi.registerProvider.bind(pi),
-        getModels: () => ctx.modelRegistry.getAll(),
-      })
-      .then(() => {
-        // Refresh active model if it's from a registered provider
-        if (
-          ctx.model &&
-          ctx.modelRegistry.find(ctx.model.provider, ctx.model.id)
-        ) {
-          const updated = ctx.modelRegistry.find(
-            ctx.model.provider,
-            ctx.model.id,
-          );
-          if (updated && config.providers.includes(ctx.model.provider)) {
-            void pi.setModel(updated);
-          }
-        }
-      });
-
-    // Check for missing models on gateway if configured
-    if (config.checkGatewayModels.length > 0) {
-      const gatewayUrl = resolveGatewayUrl(config);
-      if (gatewayUrl) {
-        void runtime.checkMissingModels(
-          {
-            getModels: () => ctx.modelRegistry.getAll(),
-            notify: (msg, type) => ctx.ui.notify(msg, type),
-          },
-          gatewayUrl,
-        );
-      }
-    }
-
-    lastRegisteredProviders = [...nextProviders];
-  };
-
-  // Register providers at session start (for new sessions)
-  pi.on("session_start", (_event, ctx) => {
-    lastRegisteredProviders = [...configLoader.getConfig().providers];
-    void runtime.sync({
-      registerProvider: pi.registerProvider.bind(pi),
-      getModels: () => ctx.modelRegistry.getAll(),
-    });
-  });
-
-  registerSetupCommand(pi, onSync);
-  registerApertureSettings(pi, onSync);
-}

package/src/lib/config.ts

@@ -1,32 +0,0 @@
-/**
- * Configuration schema and loader for the Aperture extension.
- *
- * ApertureConfig is the user-facing schema (all fields optional).
- * ResolvedConfig is the internal schema (all fields required, defaults applied).
- */
-
-import { ConfigLoader } from "@aliou/pi-utils-settings";
-
-export interface ApertureConfig {
-  baseUrl?: string;
-  providers?: string[];
-  checkGatewayModels?: string[];
-}
-
-export interface ResolvedConfig {
-  baseUrl: string;
-  providers: string[];
-  checkGatewayModels: string[];
-}
-
-const DEFAULT_CONFIG: ResolvedConfig = {
-  baseUrl: "",
-  providers: [],
-  checkGatewayModels: [],
-};
-
-export const configLoader = new ConfigLoader<ApertureConfig, ResolvedConfig>(
-  "aperture",
-  DEFAULT_CONFIG,
-  { scopes: ["global"] },
-);

package/src/lib/gateway.ts

@@ -1,61 +0,0 @@
-/**
- * Gateway health and model checking.
- */
-
-export interface HealthCheckResult {
-  ok: boolean;
-  error?: string;
-}
-
-export async function checkApertureHealth(
-  baseUrl: string,
-): Promise<HealthCheckResult> {
-  const url = `${baseUrl.replace(/\/+$/, "")}/v1/models`;
-  try {
-    const res = await fetch(url, {
-      method: "GET",
-      signal: AbortSignal.timeout(5000),
-    });
-    if (!res.ok) {
-      return { ok: false, error: `HTTP ${res.status} ${res.statusText}` };
-    }
-    return { ok: true };
-  } catch (e: unknown) {
-    const msg = e instanceof Error ? e.message : String(e);
-    return { ok: false, error: msg };
-  }
-}
-
-export interface GatewayModel {
-  id: string;
-  providerId: string;
-}
-
-export async function fetchGatewayModels(
-  baseUrl: string,
-): Promise<GatewayModel[]> {
-  const url = `${baseUrl.replace(/\/+$/, "")}/v1/models`;
-  try {
-    const res = await fetch(url, {
-      method: "GET",
-      signal: AbortSignal.timeout(5000),
-    });
-    if (!res.ok) return [];
-    const body = (await res.json()) as {
-      data?: {
-        id: string;
-        metadata?: { provider?: { id?: string } };
-      }[];
-    };
-    return (
-      body.data
-        ?.map((m) => ({
-          id: m.id,
-          providerId: m.metadata?.provider?.id ?? "",
-        }))
-        .filter((m) => m.providerId.length > 0) ?? []
-    );
-  } catch {
-    return [];
-  }
-}