@aliou/pi-ts-aperture 0.5.1 → 0.6.1

package/extensions/aperture/onboarding/setup-command.ts

@@ -0,0 +1,53 @@
+import type {
+  ExtensionAPI,
+  ExtensionCommandContext,
+} from "@earendil-works/pi-coding-agent";
+import { configLoader } from "../shared/config/loader";
+import {
+  buildOnboardedConfig,
+  createOnboardingWizard,
+  type OnboardingResult,
+} from "./onboarding";
+
+export function registerOnboardingCommand(pi: ExtensionAPI): void {
+  pi.registerCommand("aperture:onboarding", {
+    description: "First-time setup for Tailscale Aperture integration",
+    handler: async (_args, ctx: ExtensionCommandContext) => {
+      if (!ctx.hasUI) {
+        ctx.ui.notify(
+          "[aperture] onboarding requires an interactive terminal",
+          "error",
+        );
+        return;
+      }
+
+      const globalConfig = configLoader.getRawConfig("global");
+      const knownModels = ctx.modelRegistry.getAll();
+
+      const result = await ctx.ui.custom<OnboardingResult>(
+        (tui, theme, _kb, done) =>
+          createOnboardingWizard(theme, tui, done, knownModels, globalConfig),
+        { overlay: true },
+      );
+
+      if (!result.completed) {
+        ctx.ui.notify("[aperture] onboarding cancelled.", "warning");
+        return;
+      }
+
+      await configLoader.save(
+        "global",
+        buildOnboardedConfig(
+          result.baseUrl,
+          result.proxyEnabled,
+          result.dedicatedEnabled,
+          result.upstreamProviders,
+          result.dedicatedProviders,
+        ),
+      );
+      await configLoader.load();
+      ctx.ui.notify("[aperture] onboarding completed. Reloading...", "info");
+      await ctx.reload();
+    },
+  });
+}

package/extensions/aperture/onboarding/setup-wizard.ts

@@ -0,0 +1,134 @@
+/**
+ * UrlStep -- TUI component for the Aperture URL input with inline health check.
+ */
+
+import type {
+  SettingsTheme,
+  WizardStepContext,
+} from "@aliou/pi-utils-settings";
+import type { Component, TUI } from "@earendil-works/pi-tui";
+import { Input, Key, matchesKey } from "@earendil-works/pi-tui";
+import { ApertureClient } from "../../../src/api/client";
+import { normalizeInputUrl } from "../../../src/url";
+
+export const SPINNER_FRAMES = [
+  "⠋",
+  "⠙",
+  "⠹",
+  "⠸",
+  "⠼",
+  "⠴",
+  "⠦",
+  "⠧",
+  "⠇",
+  "⠏",
+];
+
+export 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" || this.state === "ok") 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);
+
+    new ApertureClient(url)
+      .health()
+      .then(() => {
+        if (this.timer) clearInterval(this.timer);
+        this.timer = null;
+        this.state = "ok";
+        this.onUrl(url);
+        this.wizCtx.markComplete();
+        this.wizCtx.goNext();
+        this.tui.requestRender();
+      })
+      .catch((error: unknown) => {
+        if (this.timer) clearInterval(this.timer);
+        this.timer = null;
+        this.state = "error";
+        this.errorMessage =
+          error instanceof Error ? error.message : String(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;
+
+    if (this.state === "ok") {
+      // Only Enter advances from the "ok" state. No re-submission.
+      if (matchesKey(data, Key.enter)) {
+        this.wizCtx.goNext();
+      }
+      return;
+    }
+
+    this.state = "idle";
+    this.input.handleInput(data);
+  }
+
+  dispose(): void {
+    if (this.timer) clearInterval(this.timer);
+  }
+}

package/extensions/aperture/proxy/runtime.ts

@@ -0,0 +1,164 @@
+import { getApiProvider } from "@earendil-works/pi-ai";
+import { ApertureClient } from "../../../src/api/client";
+import type { ApertureProvider } from "../../../src/api/types";
+import { resolveGatewayUrl, resolveProviderBaseUrl } from "../../../src/url";
+import { configLoader } from "../shared/config/loader";
+import type {
+  Api,
+  AssistantMessageEventStream,
+  CheckDeps,
+  Context,
+  Model,
+  SimpleStreamOptions,
+  SyncDeps,
+} from "../shared/types";
+
+const APERTURE_PROVENANCE_HEADERS = {
+  Referer: "https://pi.dev",
+  "X-Title": "npm:@aliou/pi-ts-aperture",
+};
+
+const MAX_MISSING_MODELS_PER_PROVIDER = 5;
+
+const ROOT_BASE_URL_APIS = new Set<Api>([
+  // Pi's Codex adapter appends /codex/responses itself. Registering /v1
+  // would produce /v1/codex/responses, which Aperture does not expose.
+  "openai-codex-responses",
+]);
+
+export function shouldUseGatewayRootForProxy(api: Api): boolean {
+  return ROOT_BASE_URL_APIS.has(api);
+}
+
+function resolveProviderHeaders(
+  models: Model<Api>[],
+  sessionId: string,
+): Record<string, string> {
+  const modelHeaders = models.find((m) => m.headers)?.headers ?? {};
+  return {
+    ...APERTURE_PROVENANCE_HEADERS,
+    ...modelHeaders,
+    "x-session-id": sessionId,
+  };
+}
+
+export class ApertureRuntime {
+  async sync(deps: SyncDeps): Promise<void> {
+    const config = configLoader.getConfig();
+    if (!config.proxy.enabled) return;
+    if (!config.baseUrl || config.proxy.upstreamProviders.length === 0) return;
+
+    const baseUrl = resolveProviderBaseUrl(config);
+    if (!baseUrl) return;
+
+    const allModels = deps.getModels();
+    const providerIds = config.proxy.upstreamProviders
+      .map((p) => p.id)
+      .filter((id) => id !== "aperture");
+
+    for (const providerName of providerIds) {
+      const providerModels = allModels.filter(
+        (m) => m.provider === providerName,
+      );
+      if (providerModels.length === 0) continue;
+
+      const api = providerModels[0].api ?? "openai-completions";
+      const builtIn = getApiProvider(api);
+
+      const providerBaseUrl = shouldUseGatewayRootForProxy(api)
+        ? resolveGatewayUrl(config)
+        : baseUrl;
+      if (!providerBaseUrl) continue;
+
+      deps.registerProvider(providerName, {
+        baseUrl: providerBaseUrl,
+        apiKey: "-",
+        headers: resolveProviderHeaders(providerModels, deps.getSessionId()),
+        api,
+        streamSimple: builtIn
+          ? (
+              model: Model<Api>,
+              context: Context,
+              options?: SimpleStreamOptions,
+            ): AssistantMessageEventStream => {
+              return builtIn.streamSimple(model, context, {
+                ...options,
+                headers: {
+                  ...options?.headers,
+                  "x-session-id": options?.sessionId ?? "",
+                },
+              });
+            }
+          : undefined,
+      });
+    }
+  }
+
+  async checkMissingModels(
+    deps: CheckDeps,
+    providers?: ApertureProvider[],
+  ): Promise<void> {
+    const config = configLoader.getConfig();
+    if (!config.proxy.enabled) return;
+
+    const checkedProviderIds = config.proxy.upstreamProviders
+      .filter((p) => p.shouldCheckGatewayModels)
+      .map((p) => p.id);
+    if (checkedProviderIds.length === 0) return;
+
+    const gatewayUrl = resolveGatewayUrl(config);
+    if (!gatewayUrl && !providers) return;
+
+    const gatewayProviders =
+      providers ?? (await new ApertureClient(gatewayUrl as string).providers());
+    if (gatewayProviders.length === 0) return;
+
+    const modelIdsByProvider = new Map(
+      gatewayProviders.map((provider) => [
+        provider.id,
+        new Set(provider.models),
+      ]),
+    );
+
+    const allModels = deps.getModels();
+    const checkedProviders = new Set(checkedProviderIds);
+    const routedModels = allModels.filter((m) =>
+      checkedProviders.has(m.provider),
+    );
+    const missingModels = routedModels.filter(
+      (m) => !modelIdsByProvider.get(m.provider)?.has(m.id),
+    );
+
+    if (missingModels.length === 0) return;
+
+    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",
+    );
+  }
+
+  getProvidersToUnregister(
+    prevProviders: string[],
+    nextProviders: string[],
+  ): string[] {
+    return prevProviders.filter((p) => !nextProviders.includes(p));
+  }
+}