@aliou/pi-ts-aperture 0.1.0 → 0.2.0

package/.github/workflows/publish.yml

@@ -57,14 +57,10 @@ jobs:
 
           let title = 'Version Packages';
           let commit = 'Version Packages';
-          if (releases.length === 1) {
-            const { name, newVersion } = releases[0];
-            title = 'Updating ' + name + ' to version ' + newVersion;
-            commit = name + '@' + newVersion;
-          } else if (releases.length > 1) {
-            const summary = releases.map(r => r.name + '@' + r.newVersion).join(', ');
-            title = 'Updating ' + summary;
-            commit = summary;
+          if (releases.length >= 1) {
+            const version = releases[0].newVersion;
+            title = version;
+            commit = version;
           }
 
           fs.appendFileSync(process.env.GITHUB_OUTPUT, 'title=' + title + '\n');

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # @aliou/pi-ts-aperture
 
+## 0.2.0
+
+### Minor Changes
+
+- 926f0a9: Improve `/aperture:setup` provider and connectivity flow.
+
+  - Add URL health check during setup (`/v1/models`) before provider selection, with retry/cancel UX.
+  - Build provider choices from Pi's runtime model registry so extension-registered providers (for example `pi-synthetic`) appear in the setup list.
+
+### Patch Changes
+
+- 2263fc2: mark pi SDK peer deps as optional to prevent koffi OOM in Gondolin VMs
+
 ## 0.1.0
 
 ### Minor Changes

package/README.md

@@ -7,7 +7,7 @@ Aperture handles API key injection and request routing server-side. This extensi
 ## Setup
 
 ```bash
-pi install @aliou/pi-ts-aperture
+pi install npm:@aliou/pi-ts-aperture
 ```
 
 Then run the setup wizard:

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@aliou/pi-ts-aperture",
   "description": "Route Pi LLM providers through Tailscale Aperture",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "repository": {
     "type": "git",
     "url": "https://github.com/aliou/pi-ts-aperture"
@@ -36,6 +36,14 @@
     "husky": "^9.1.7",
     "typescript": "^5.9.3"
   },
+  "peerDependenciesMeta": {
+    "@mariozechner/pi-coding-agent": {
+      "optional": true
+    },
+    "@mariozechner/pi-ai": {
+      "optional": true
+    }
+  },
   "scripts": {
     "typecheck": "tsc --noEmit",
     "lint": "biome check",

package/src/commands/setup.ts

@@ -8,15 +8,15 @@
  */
 
 import { FuzzySelector } from "@aliou/pi-utils-settings";
-import { getProviders } from "@mariozechner/pi-ai";
 import type {
   ExtensionAPI,
   ExtensionContext,
 } from "@mariozechner/pi-coding-agent";
 import { getSettingsListTheme } from "@mariozechner/pi-coding-agent";
-import type { Component } from "@mariozechner/pi-tui";
+import type { Component, TUI } from "@mariozechner/pi-tui";
 import { Input, Key, matchesKey } from "@mariozechner/pi-tui";
 import { configLoader } from "../config";
+import { checkApertureHealth } from "../lib/health";
 
 function normalizeUrl(url: string): string {
   let result = url.trim();
@@ -27,6 +27,102 @@ function normalizeUrl(url: string): string {
   return result.replace(/\/v1\/?$/, "").replace(/\/+$/, "");
 }
 
+const SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+
+/**
+ * Shows a spinner while verifying the Aperture URL is reachable.
+ * Kicks off the health check on construction and resolves done(boolean)
+ * when the check completes.
+ */
+class HealthCheckSpinner implements Component {
+  private theme: ReturnType<typeof getSettingsListTheme>;
+  private url: string;
+  private tui: TUI;
+  // true = healthy, false = failed (retry), undefined = cancelled
+  private done: (result: boolean | undefined) => void;
+  private frame = 0;
+  private timer: ReturnType<typeof setInterval>;
+  private result: { ok: boolean; error?: string } | null = null;
+
+  constructor(
+    theme: ReturnType<typeof getSettingsListTheme>,
+    url: string,
+    tui: TUI,
+    done: (result: boolean | undefined) => void,
+  ) {
+    this.theme = theme;
+    this.url = url;
+    this.tui = tui;
+    this.done = done;
+
+    // Animate spinner at ~80ms per frame.
+    this.timer = setInterval(() => {
+      this.frame = (this.frame + 1) % SPINNER_FRAMES.length;
+      this.tui.requestRender();
+    }, 80);
+
+    // Fire the check.
+    checkApertureHealth(url).then((res) => {
+      clearInterval(this.timer);
+      this.result = res;
+      this.tui.requestRender();
+
+      // On success, auto-advance after a brief pause.
+      // On failure, wait for user input (see handleInput).
+      if (res.ok) {
+        setTimeout(() => this.done(true), 600);
+      }
+    });
+  }
+
+  render(_width: number): string[] {
+    const lines: string[] = [];
+    lines.push(this.theme.label(" Aperture Setup", true));
+    lines.push("");
+
+    if (!this.result) {
+      const spinner = SPINNER_FRAMES[this.frame];
+      lines.push(
+        this.theme.hint(`  ${spinner} Checking connection to ${this.url}...`),
+      );
+    } else if (this.result.ok) {
+      lines.push(this.theme.hint(`  Connected to ${this.url}`));
+    } else {
+      lines.push(
+        this.theme.hint(`  Could not reach ${this.url}: ${this.result.error}`),
+      );
+      lines.push("");
+      lines.push(
+        this.theme.hint(
+          "  Make sure the URL is correct and you are connected to the tailnet.",
+        ),
+      );
+      lines.push("");
+      lines.push(this.theme.hint("  Enter: try another URL · Esc: cancel"));
+    }
+
+    lines.push("");
+    return lines;
+  }
+
+  invalidate() {}
+
+  handleInput(data: string) {
+    // Only handle input after a failed check.
+    if (!this.result || this.result.ok) return;
+
+    if (matchesKey(data, Key.enter)) {
+      this.done(false); // retry
+    } else if (matchesKey(data, Key.escape)) {
+      this.done(undefined); // cancel wizard
+    }
+  }
+
+  dispose() {
+    clearInterval(this.timer);
+  }
+}
+
 /**
  * Simple input prompt component for the base URL step.
  */
@@ -171,17 +267,39 @@ export function registerSetupCommand(
       const config = configLoader.getConfig();
       const settingsTheme = getSettingsListTheme();
 
-      // Step 1: base URL
-      const baseUrl = await ctx.ui.custom<string | undefined>(
-        (_tui, _theme, _kb, done) => {
-          return new UrlPrompt(settingsTheme, config.baseUrl, done);
-        },
-      );
+      // Step 1: base URL + health check loop.
+      // On failure, loop back to the URL prompt so the user can retry.
+      let baseUrl: string | undefined;
+      while (true) {
+        baseUrl = await ctx.ui.custom<string | undefined>(
+          (_tui, _theme, _kb, done) => {
+            return new UrlPrompt(
+              settingsTheme,
+              baseUrl ?? config.baseUrl,
+              done,
+            );
+          },
+        );
+
+        if (!baseUrl) return;
+        const urlToCheck = baseUrl;
+
+        const result = await ctx.ui.custom<boolean | undefined>(
+          (tui, _theme, _kb, done) => {
+            return new HealthCheckSpinner(settingsTheme, urlToCheck, tui, done);
+          },
+        );
 
-      if (!baseUrl) return;
+        if (result === true) break; // healthy, proceed
+        if (result === undefined) return; // cancelled
+      }
 
       // Step 2: select providers
-      const knownProviders = getProviders();
+      // Use model registry so custom/extension providers are included.
+      const knownProviders = Array.from(
+        new Set(ctx.modelRegistry.getAll().map((model) => model.provider)),
+      ).sort((a, b) => a.localeCompare(b));
+
       const providers = await ctx.ui.custom<string[] | undefined>(
         (_tui, _theme, _kb, done) => {
           return new ProviderMultiSelect(

package/src/lib/health.ts

@@ -0,0 +1,30 @@
+/**
+ * Health check for the Aperture gateway.
+ *
+ * Hits GET <baseUrl>/v1/models to verify the gateway is reachable.
+ * Uses native fetch (no extra dependencies).
+ */
+
+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 };
+  }
+}