@aliou/pi-ts-aperture 0.5.1 → 0.6.1

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@aliou/pi-ts-aperture",
   "description": "Route Pi LLM providers through Tailscale Aperture",
-  "version": "0.5.1",
+  "version": "0.6.1",
   "type": "module",
   "license": "MIT",
   "private": false,
@@ -20,55 +20,65 @@
   },
   "files": [
     "src",
-    "README.md"
+    "extensions",
+    "README.md",
+    "!**/*.test.ts"
   ],
   "pi": {
     "extensions": [
-      "./src/index.ts"
+      "./extensions/aperture/index.ts"
     ],
-    "video": "https://assets.aliou.me/pi-extensions/demos/pi-ts-aperture.mp4"
+    "video": "https://assets.aliou.me/github/aliou/pi-ts-aperture/demo.mp4"
   },
   "dependencies": {
-    "@aliou/pi-utils-settings": "^0.12.0"
+    "@aliou/pi-utils-settings": "^0.17.0"
   },
   "peerDependencies": {
-    "@mariozechner/pi-ai": "0.64.0",
-    "@mariozechner/pi-coding-agent": "0.64.0",
-    "@mariozechner/pi-tui": "0.64.0"
+    "@earendil-works/pi-ai": "0.74.0",
+    "@earendil-works/pi-coding-agent": "0.74.0",
+    "@earendil-works/pi-tui": "0.74.0"
   },
   "peerDependenciesMeta": {
-    "@mariozechner/pi-coding-agent": {
+    "@earendil-works/pi-coding-agent": {
       "optional": true
     },
-    "@mariozechner/pi-ai": {
+    "@earendil-works/pi-ai": {
       "optional": true
     },
-    "@mariozechner/pi-tui": {
+    "@earendil-works/pi-tui": {
       "optional": true
     }
   },
-  "devDependencies": {
-    "@aliou/biome-plugins": "^0.3.2",
-    "@biomejs/biome": "^2.3.13",
-    "@changesets/cli": "^2.27.11",
-    "@mariozechner/pi-coding-agent": "0.64.0",
-    "@sinclair/typebox": "^0.34.48",
-    "@types/node": "^25.0.10",
-    "@vitest/coverage-v8": "^4.0.18",
-    "husky": "^9.1.7",
-    "typescript": "^5.9.3",
-    "vitest": "^4.0.18"
-  },
   "scripts": {
     "typecheck": "tsc --noEmit",
     "lint": "biome check",
     "format": "biome check --write",
     "check:lockfile": "pnpm install --frozen-lockfile --ignore-scripts",
+    "prepare": "[ -d .git ] && husky || true",
     "changeset": "changeset",
     "version": "changeset version",
     "release": "pnpm changeset publish",
     "test": "vitest run",
-    "test:watch": "vitest",
-    "test:e2e": "vitest run tests/e2e.test.ts"
-  }
-}
+    "test:watch": "vitest"
+  },
+  "devDependencies": {
+    "@aliou/biome-plugins": "^0.8.1",
+    "@aliou/pi-utils-ui": "^0.4.1",
+    "@biomejs/biome": "^2.4.15",
+    "@changesets/cli": "^2.27.11",
+    "@earendil-works/pi-coding-agent": "0.74.0",
+    "typebox": "^1.0.0",
+    "@types/node": "^25.0.10",
+    "@vitest/coverage-v8": "^4.0.18",
+    "husky": "^9.1.7",
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.18"
+  },
+  "pnpm": {
+    "overrides": {
+      "@earendil-works/pi-ai": "$@earendil-works/pi-coding-agent",
+      "@earendil-works/pi-tui": "$@earendil-works/pi-coding-agent"
+    }
+  },
+  "packageManager": "pnpm@10.26.1"
+}

package/src/api/client.ts

@@ -0,0 +1,139 @@
+import type { ApertureProvider, ApertureProviderConfigInfo } from "./types";
+
+interface ProvidersResponse {
+  providers?: unknown;
+}
+
+interface ConfigResponse {
+  config?: unknown;
+}
+
+function parseProvider(
+  value: unknown,
+  fallbackId?: string,
+): ApertureProvider | null {
+  if (!value || typeof value !== "object") return null;
+  const record = value as Record<string, unknown>;
+  const id = typeof record.id === "string" ? record.id : fallbackId;
+  if (!id) return null;
+  return {
+    id,
+    name: typeof record.name === "string" ? record.name : id,
+    description:
+      typeof record.description === "string" ? record.description : undefined,
+    baseUrl:
+      typeof record.baseUrl === "string"
+        ? record.baseUrl
+        : typeof record.base_url === "string"
+          ? record.base_url
+          : typeof record.baseurl === "string"
+            ? record.baseurl
+            : undefined,
+    models: Array.isArray(record.models)
+      ? record.models.filter(
+          (model): model is string => typeof model === "string",
+        )
+      : [],
+    compatibility:
+      record.compatibility && typeof record.compatibility === "object"
+        ? (record.compatibility as ApertureProvider["compatibility"])
+        : {},
+  };
+}
+
+export class ApertureClient {
+  constructor(private readonly baseUrl: string) {}
+
+  async providers(signal?: AbortSignal): Promise<ApertureProvider[]> {
+    const res = await fetch(
+      `${this.baseUrl.replace(/\/+$/, "")}/api/providers`,
+      {
+        method: "GET",
+        signal: signal ?? AbortSignal.timeout(5000),
+      },
+    );
+    if (!res.ok) {
+      throw new Error(
+        `Aperture providers request failed: HTTP ${res.status} ${res.statusText}`,
+      );
+    }
+
+    const body = (await res.json()) as ProvidersResponse | unknown[];
+    if (Array.isArray(body)) {
+      return body
+        .map((provider) => parseProvider(provider))
+        .filter((p): p is ApertureProvider => p !== null);
+    }
+
+    const providers = (body as ProvidersResponse).providers;
+    if (Array.isArray(providers)) {
+      return providers
+        .map((provider) => parseProvider(provider))
+        .filter((p): p is ApertureProvider => p !== null);
+    }
+    if (providers && typeof providers === "object") {
+      return Object.entries(providers).flatMap(([id, provider]) => {
+        const parsed = parseProvider(provider, id);
+        return parsed ? [parsed] : [];
+      });
+    }
+
+    return [];
+  }
+
+  async providerConfigInfos(
+    signal?: AbortSignal,
+  ): Promise<Map<string, ApertureProviderConfigInfo>> {
+    const res = await fetch(
+      `${this.baseUrl.replace(/\/+$/, "")}/aperture/config`,
+      {
+        method: "GET",
+        signal: signal ?? AbortSignal.timeout(5000),
+      },
+    );
+    if (!res.ok) {
+      throw new Error(
+        `Aperture config request failed: HTTP ${res.status} ${res.statusText}`,
+      );
+    }
+
+    const body = (await res.json()) as ConfigResponse;
+    const config =
+      typeof body.config === "string" ? JSON.parse(body.config) : body.config;
+    if (!config || typeof config !== "object") return new Map();
+
+    const providers = (config as { providers?: unknown }).providers;
+    if (!providers || typeof providers !== "object") return new Map();
+
+    const result = new Map<string, ApertureProviderConfigInfo>();
+    for (const [id, provider] of Object.entries(providers)) {
+      if (!provider || typeof provider !== "object") continue;
+      const record = provider as Record<string, unknown>;
+      const baseUrl =
+        typeof record.baseurl === "string"
+          ? record.baseurl
+          : typeof record.baseUrl === "string"
+            ? record.baseUrl
+            : typeof record.base_url === "string"
+              ? record.base_url
+              : undefined;
+      if (baseUrl) {
+        result.set(id, {
+          id,
+          baseUrl,
+          name: typeof record.name === "string" ? record.name : undefined,
+        });
+      }
+    }
+    return result;
+  }
+
+  async providerBaseUrls(signal?: AbortSignal): Promise<Map<string, string>> {
+    const infos = await this.providerConfigInfos(signal);
+    return new Map([...infos].map(([id, info]) => [id, info.baseUrl]));
+  }
+
+  async health(signal?: AbortSignal): Promise<void> {
+    await this.providers(signal);
+  }
+}

package/src/api/types.ts

@@ -0,0 +1,26 @@
+export interface ProviderCompatibility {
+  openai_chat?: boolean;
+  openai_responses?: boolean;
+  anthropic_messages?: boolean;
+  gemini_generate_content?: boolean;
+  google_generate_content?: boolean;
+  google_raw_predict?: boolean;
+  bedrock_model_invoke?: boolean;
+  bedrock_converse?: boolean;
+  experimental_gemini_cli_vertex_compat?: boolean;
+}
+
+export interface ApertureProviderConfigInfo {
+  id: string;
+  name?: string;
+  baseUrl: string;
+}
+
+export interface ApertureProvider {
+  id: string;
+  name: string;
+  description?: string;
+  baseUrl?: string;
+  models: string[];
+  compatibility: ProviderCompatibility;
+}

package/src/provider-mapping.ts

@@ -0,0 +1,91 @@
+import type { Api, Model } from "@earendil-works/pi-ai";
+import type { DedicatedProviderConfig } from "../extensions/aperture/shared/config/loader";
+import type { ApertureProvider, ApertureProviderConfigInfo } from "./api/types";
+
+function normalizeProviderBaseUrl(url: string): string[] {
+  const normalized = url.replace(/\/+$/, "");
+  return [normalized, normalized.replace(/\/v1\/?$/, "")];
+}
+
+function isSameOrChildUrl(parent: string, candidate: string): boolean {
+  return candidate === parent || candidate.startsWith(`${parent}/`);
+}
+
+function hasMatchingBaseUrl(
+  baseUrls: string[],
+  apertureBaseUrls: Set<string>,
+): boolean {
+  const apertureUrls = [...apertureBaseUrls];
+  return baseUrls.some((baseUrl) =>
+    normalizeProviderBaseUrl(baseUrl).some((localUrl) =>
+      apertureUrls.some((apertureUrl) =>
+        isSameOrChildUrl(localUrl, apertureUrl),
+      ),
+    ),
+  );
+}
+
+function collectLocalProviders(models: readonly Model<Api>[]) {
+  return Array.from(
+    models.reduce((providers, model) => {
+      if (model.provider === "aperture") return providers;
+      const baseUrls = providers.get(model.provider) ?? new Set<string>();
+      if (model.baseUrl) baseUrls.add(model.baseUrl);
+      providers.set(model.provider, baseUrls);
+      return providers;
+    }, new Map<string, Set<string>>()),
+  )
+    .map(([id, baseUrls]) => ({ id, baseUrls: [...baseUrls] }))
+    .sort((a, b) => a.id.localeCompare(b.id));
+}
+
+export function mapProxyProviders(
+  localModels: readonly Model<Api>[],
+  providerInfos: Map<string, ApertureProviderConfigInfo>,
+  gatewayProviders: ApertureProvider[],
+  existingProviders: { id: string; shouldCheckGatewayModels?: boolean }[],
+) {
+  const names = new Map(
+    gatewayProviders.map((provider) => [provider.id, provider.name]),
+  );
+  const apertureBaseUrls = new Set(
+    [...providerInfos.values()].flatMap((provider) =>
+      normalizeProviderBaseUrl(provider.baseUrl),
+    ),
+  );
+  const existing = new Map(
+    existingProviders.map((provider) => [provider.id, provider]),
+  );
+  const gatewayProviderIds = new Set([
+    ...providerInfos.keys(),
+    ...gatewayProviders.map((provider) => provider.id),
+  ]);
+
+  return collectLocalProviders(localModels)
+    .filter(
+      (provider) =>
+        hasMatchingBaseUrl(provider.baseUrls, apertureBaseUrls) ||
+        gatewayProviderIds.has(provider.id),
+    )
+    .map((provider) => ({
+      ...provider,
+      name: names.get(provider.id) ?? providerInfos.get(provider.id)?.name,
+      shouldCheckGatewayModels:
+        existing.get(provider.id)?.shouldCheckGatewayModels ?? true,
+    }));
+}
+
+export function mapDedicatedProviders(
+  gatewayProviders: ApertureProvider[],
+  existingProviders: DedicatedProviderConfig[],
+): DedicatedProviderConfig[] {
+  const existing = new Map(
+    existingProviders.map((provider) => [provider.id, provider]),
+  );
+
+  return gatewayProviders.map((provider) => ({
+    id: provider.id,
+    name: provider.name,
+    enabled: existing.get(provider.id)?.enabled ?? true,
+  }));
+}

package/src/url.ts

@@ -0,0 +1,52 @@
+/**
+ * Pure URL helpers.
+ */
+
+interface UrlConfig {
+  baseUrl?: string;
+}
+
+/**
+ * Normalizes a user-input URL:
+ * - Trims whitespace
+ * - Adds http:// scheme if missing
+ * - Parses with URL constructor and extracts origin (scheme + host + port)
+ * - This handles full URLs like "http://ai.host.ts.net/v1/models" -> "http://ai.host.ts.net"
+ * - Also handles bare hosts like "ai.host.ts.net" -> "http://ai.host.ts.net"
+ */
+export function normalizeInputUrl(raw: string): string {
+  let result = raw.trim();
+  if (!result) return result;
+  if (!result.startsWith("http://") && !result.startsWith("https://")) {
+    result = `http://${result}`;
+  }
+  try {
+    const parsed = new URL(result);
+    // Return just the origin (scheme + host + port), discarding path/query/fragment
+    return parsed.origin;
+  } catch {
+    // Fallback for unparseable input: strip /v1 and trailing slashes
+    return result.replace(/\/v1\/?$/, "").replace(/\/+$/, "");
+  }
+}
+
+/**
+ * Returns configured gateway URL without trailing slash.
+ * Returns null when baseUrl is empty.
+ */
+export function resolveGatewayUrl(config: UrlConfig): string | null {
+  const { baseUrl } = config;
+  if (!baseUrl) return null;
+  return baseUrl.replace(/\/v1\/?$/, "").replace(/\/+$/, "");
+}
+
+/**
+ * Returns the Aperture provider base URL used for provider registration.
+ * Appends /v1 to the gateway URL.
+ * Returns null when gateway URL cannot be resolved.
+ */
+export function resolveProviderBaseUrl(config: UrlConfig): string | null {
+  const gateway = resolveGatewayUrl(config);
+  if (!gateway) return null;
+  return `${gateway}/v1`;
+}

package/src/commands/settings.ts

@@ -1,135 +0,0 @@
-/**
- * aperture:settings -- settings UI for Aperture configuration.
- *
- * Sections:
- * - Connection: base URL
- * - Providers: list of providers routed through Aperture
- */
-
-import {
-  ArrayEditor,
-  registerSettingsCommand,
-  type SettingsSection,
-  setNestedValue,
-} from "@aliou/pi-utils-settings";
-import type {
-  ExtensionAPI,
-  ExtensionContext,
-} from "@mariozechner/pi-coding-agent";
-import { getSettingsListTheme } from "@mariozechner/pi-coding-agent";
-import type { ApertureConfig, ResolvedConfig } from "../lib/config";
-import { configLoader } from "../lib/config";
-
-export function registerApertureSettings(
-  pi: ExtensionAPI,
-  onSync: (ctx: ExtensionContext) => void,
-): void {
-  registerSettingsCommand<ApertureConfig, ResolvedConfig>(pi, {
-    commandName: "aperture:settings",
-    title: "Aperture Settings",
-    configStore: configLoader,
-    buildSections: (
-      tabConfig: ApertureConfig | null,
-      resolved: ResolvedConfig,
-      { setDraft },
-    ): SettingsSection[] => {
-      const settingsTheme = getSettingsListTheme();
-
-      const providers = tabConfig?.providers ?? resolved.providers;
-
-      const checkGatewayModels: string[] =
-        tabConfig?.checkGatewayModels ?? resolved.checkGatewayModels;
-
-      return [
-        {
-          label: "Connection",
-          items: [
-            {
-              id: "baseUrl",
-              label: "Base URL",
-              description:
-                "Aperture gateway URL on your tailnet (e.g. http://ai.pango-lin.ts.net)",
-              currentValue:
-                (tabConfig?.baseUrl ?? resolved.baseUrl) || "(not set)",
-              values: undefined,
-              submenu: undefined,
-            },
-            {
-              id: "checkGatewayModels",
-              label: "Gateway model checking",
-              description:
-                "Providers for which gateway model availability is checked",
-              currentValue:
-                checkGatewayModels.length > 0
-                  ? `${checkGatewayModels.length} provider(s)`
-                  : "disabled",
-              values: undefined,
-              submenu: (_val, submenuDone) => {
-                let latest = [...checkGatewayModels];
-                return new ArrayEditor({
-                  label: "Gateway-checked providers",
-                  items: [...checkGatewayModels],
-                  theme: settingsTheme,
-                  onSave: (items) => {
-                    latest = items;
-                    const updated = structuredClone(
-                      tabConfig ?? {},
-                    ) as ApertureConfig;
-                    setNestedValue(updated, "checkGatewayModels", items);
-                    setDraft(updated);
-                  },
-                  onDone: () =>
-                    submenuDone(
-                      latest.length > 0
-                        ? `${latest.length} provider(s)`
-                        : "disabled",
-                    ),
-                });
-              },
-            },
-          ],
-        },
-        {
-          label: "Providers",
-          items: [
-            {
-              id: "providers",
-              label: "Routed providers",
-              description: "LLM providers routed through Aperture",
-              currentValue: `${providers.length} provider(s)`,
-              submenu: (_val, submenuDone) => {
-                let latest = [...providers];
-                return new ArrayEditor({
-                  label: "Providers",
-                  items: [...providers],
-                  theme: settingsTheme,
-                  onSave: (items) => {
-                    latest = items;
-                    const updated = structuredClone(
-                      tabConfig ?? {},
-                    ) as ApertureConfig;
-                    setNestedValue(updated, "providers", items);
-                    setDraft(updated);
-                  },
-                  onDone: () => submenuDone(`${latest.length} provider(s)`),
-                });
-              },
-            },
-          ],
-        },
-      ];
-    },
-    onSettingChange: (id, newValue, config) => {
-      const updated = structuredClone(config);
-      if (id === "baseUrl") {
-        updated.baseUrl = newValue;
-      } else {
-        setNestedValue(updated, id, newValue);
-      }
-      return updated;
-    },
-    onSave: (ctx) => {
-      onSync(ctx);
-    },
-  });
-}