@aliou/pi-ts-aperture 0.5.1 → 0.6.0

package/extensions/aperture/settings-command.ts

@@ -0,0 +1,369 @@
+import {
+  registerSettingsCommand,
+  SettingsDetailEditor,
+  type SettingsDetailField,
+  type SettingsSection,
+} from "@aliou/pi-utils-settings";
+import type { Api, Model } from "@earendil-works/pi-ai";
+import type {
+  ExtensionAPI,
+  ExtensionContext,
+} from "@earendil-works/pi-coding-agent";
+import { getSettingsListTheme } from "@earendil-works/pi-coding-agent";
+import type { Component } from "@earendil-works/pi-tui";
+import { ApertureClient } from "../../src/api/client";
+import {
+  mapDedicatedProviders,
+  mapProxyProviders,
+} from "../../src/provider-mapping";
+import { normalizeInputUrl } from "../../src/url";
+import type {
+  ApertureConfig,
+  DedicatedProviderConfig,
+  ResolvedConfig,
+} from "./shared/config/loader";
+import { configLoader } from "./shared/config/loader";
+
+function boolLabel(value: boolean): string {
+  return value ? "enabled" : "disabled";
+}
+
+class AsyncEditor implements Component {
+  private editor: Component | null = null;
+  private error = "";
+
+  constructor(loader: () => Promise<Component>) {
+    void loader()
+      .then((editor) => {
+        this.editor = editor;
+      })
+      .catch((error: unknown) => {
+        this.error = error instanceof Error ? error.message : String(error);
+      });
+  }
+
+  render(width: number): string[] {
+    if (this.editor) return this.editor.render(width);
+    if (this.error) return [`Failed to refresh providers: ${this.error}`];
+    return ["Refreshing providers from Aperture..."];
+  }
+
+  invalidate(): void {
+    this.editor?.invalidate?.();
+  }
+
+  handleInput(data: string): void {
+    this.editor?.handleInput?.(data);
+  }
+}
+
+export function registerApertureSettings(
+  pi: ExtensionAPI,
+  onSync: (ctx: ExtensionContext) => void,
+  getKnownModels: () => Model<Api>[],
+): void {
+  registerSettingsCommand<ApertureConfig, ResolvedConfig>(pi, {
+    commandName: "aperture:settings",
+    title: "Aperture Settings",
+    configStore: configLoader,
+    buildSections: (tabConfig, resolved, { setDraft }): SettingsSection[] => {
+      const draft = tabConfig ?? {};
+      const baseUrl = draft.baseUrl ?? resolved.baseUrl;
+      const proxyEnabled = draft.proxy?.enabled ?? resolved.proxy.enabled;
+      const dedicatedEnabled =
+        draft.dedicated?.enabled ?? resolved.dedicated.enabled;
+      const upstreamProviders =
+        draft.proxy?.upstreamProviders ?? resolved.proxy.upstreamProviders;
+      const dedicatedProviders =
+        draft.dedicated?.providers ?? resolved.dedicated.providers;
+      const onboardingDone = draft.onboardingDone ?? resolved.onboardingDone;
+      const onboardingEnabled =
+        draft.onboarding?.enabled ?? resolved.onboarding.enabled;
+
+      return [
+        {
+          label: "Connection",
+          items: [
+            {
+              id: "baseUrl",
+              label: "Base URL",
+              description: "Aperture gateway URL on your tailnet",
+              currentValue: baseUrl || "(not set)",
+              submenu: (_val, submenuDone) => {
+                let currentUrl = baseUrl;
+                const fields: SettingsDetailField[] = [
+                  {
+                    type: "text",
+                    id: "baseUrl",
+                    label: "Base URL",
+                    getValue: () => currentUrl,
+                    setValue: (value) => {
+                      currentUrl = value;
+                      const updated = structuredClone(draft) as ApertureConfig;
+                      updated.baseUrl = normalizeInputUrl(value);
+                      setDraft(updated);
+                    },
+                    validate: (value) =>
+                      value.trim() ? null : "URL cannot be empty",
+                    displayValue: (value) => value || "(not set)",
+                    emptyValueText: "(not set)",
+                  },
+                ];
+                return new SettingsDetailEditor({
+                  title: "Base URL",
+                  fields,
+                  theme: getSettingsListTheme(),
+                  onDone: (summary) =>
+                    submenuDone(summary ?? (currentUrl || "(not set)")),
+                  getDoneSummary: () => currentUrl || "(not set)",
+                });
+              },
+            },
+          ],
+        },
+        {
+          label: "Capabilities",
+          items: [
+            {
+              id: "proxy.enabled",
+              label: "Proxy existing providers",
+              description: "Route selected Pi providers through Aperture",
+              currentValue: boolLabel(proxyEnabled),
+              values: ["enabled", "disabled"],
+            },
+            {
+              id: "dedicated.enabled",
+              label: "Dedicated Aperture provider",
+              description: "Register a standalone aperture provider",
+              currentValue: boolLabel(dedicatedEnabled),
+              values: ["enabled", "disabled"],
+            },
+          ],
+        },
+        {
+          label: "Proxy",
+          items: [
+            {
+              id: "proxy.upstreamProviders",
+              label: "Upstream providers",
+              description: "Configured proxy providers and gateway checks",
+              currentValue:
+                upstreamProviders.length > 0
+                  ? `${upstreamProviders.length} provider(s)`
+                  : "none",
+              submenu: (_val, submenuDone) =>
+                new AsyncEditor(async () => {
+                  const client = new ApertureClient(baseUrl);
+                  const [providerInfos, gatewayProviders] = await Promise.all([
+                    client.providerConfigInfos(),
+                    client.providers(),
+                  ]);
+                  const providers = mapProxyProviders(
+                    getKnownModels(),
+                    providerInfos,
+                    gatewayProviders,
+                    upstreamProviders,
+                  );
+                  const enabled = new Set(
+                    upstreamProviders.map((provider) => provider.id),
+                  );
+                  {
+                    const updated = structuredClone(draft) as ApertureConfig;
+                    updated.proxy = {
+                      ...updated.proxy,
+                      upstreamProviders: providers.filter((provider) =>
+                        enabled.has(provider.id),
+                      ),
+                    };
+                    setDraft(updated);
+                  }
+                  const fields: SettingsDetailField[] = providers.flatMap(
+                    (p, i) => [
+                      {
+                        type: "boolean" as const,
+                        id: `provider.${p.id}.enabled`,
+                        label: p.name ?? p.id,
+                        getValue: () => enabled.has(p.id),
+                        setValue: (value: boolean) => {
+                          if (value) enabled.add(p.id);
+                          else enabled.delete(p.id);
+                          const updated = structuredClone(
+                            draft,
+                          ) as ApertureConfig;
+                          updated.proxy = {
+                            ...updated.proxy,
+                            upstreamProviders: providers.filter((provider) =>
+                              enabled.has(provider.id),
+                            ),
+                          };
+                          setDraft(updated);
+                        },
+                        trueLabel: "enabled",
+                        falseLabel: "disabled",
+                      },
+                      {
+                        type: "boolean" as const,
+                        id: `provider.${p.id}.shouldCheckGatewayModels`,
+                        label: `${p.name ?? p.id} — gateway model check`,
+                        getValue: () => p.shouldCheckGatewayModels as boolean,
+                        setValue: (value: boolean) => {
+                          const provider = providers[i];
+                          if (provider)
+                            provider.shouldCheckGatewayModels = value;
+                          const updated = structuredClone(
+                            draft,
+                          ) as ApertureConfig;
+                          updated.proxy = {
+                            ...updated.proxy,
+                            upstreamProviders: providers.filter((provider) =>
+                              enabled.has(provider.id),
+                            ),
+                          };
+                          setDraft(updated);
+                        },
+                        trueLabel: "on",
+                        falseLabel: "off",
+                      },
+                    ],
+                  );
+                  return new SettingsDetailEditor({
+                    title: () =>
+                      `Upstream Providers (${enabled.size}/${providers.length})`,
+                    fields,
+                    theme: getSettingsListTheme(),
+                    onDone: () =>
+                      submenuDone(
+                        providers.length > 0
+                          ? `${enabled.size}/${providers.length} enabled`
+                          : "none",
+                      ),
+                    getDoneSummary: () =>
+                      providers.length > 0
+                        ? `${enabled.size}/${providers.length} enabled`
+                        : "none",
+                    emptyStateText:
+                      "No local providers match the Aperture gateway provider base URLs.",
+                  });
+                }),
+            },
+          ],
+        },
+        {
+          label: "Dedicated",
+          items: [
+            {
+              id: "dedicated.providers",
+              label: "Aperture providers",
+              description:
+                "Gateway providers included in the aperture provider",
+              currentValue:
+                dedicatedProviders.length > 0
+                  ? `${dedicatedProviders.filter((p) => p.enabled).length}/${dedicatedProviders.length} enabled`
+                  : "all (no filter)",
+              submenu: (_val, submenuDone) =>
+                new AsyncEditor(async () => {
+                  const gatewayProviders = await new ApertureClient(
+                    baseUrl,
+                  ).providers();
+                  const providers: DedicatedProviderConfig[] =
+                    mapDedicatedProviders(gatewayProviders, dedicatedProviders);
+                  {
+                    const updated = structuredClone(draft) as ApertureConfig;
+                    updated.dedicated = {
+                      ...updated.dedicated,
+                      providers,
+                    };
+                    setDraft(updated);
+                  }
+                  const fields: SettingsDetailField[] = providers.map(
+                    (p: DedicatedProviderConfig, i: number) => ({
+                      type: "boolean" as const,
+                      id: `dedicated.provider.${p.id}.enabled`,
+                      label: p.name ?? p.id,
+                      getValue: () => p.enabled,
+                      setValue: (value: boolean) => {
+                        const provider = providers[i];
+                        if (provider) provider.enabled = value;
+                        const updated = structuredClone(
+                          draft,
+                        ) as ApertureConfig;
+                        updated.dedicated = {
+                          ...updated.dedicated,
+                          providers,
+                        };
+                        setDraft(updated);
+                      },
+                      trueLabel: "enabled",
+                      falseLabel: "disabled",
+                    }),
+                  );
+                  return new SettingsDetailEditor({
+                    title: () =>
+                      `Dedicated Providers (${providers.filter((p) => p.enabled).length}/${providers.length})`,
+                    fields,
+                    theme: getSettingsListTheme(),
+                    onDone: () =>
+                      submenuDone(
+                        providers.length > 0
+                          ? `${providers.filter((p) => p.enabled).length}/${providers.length} enabled`
+                          : "none",
+                      ),
+                    getDoneSummary: () =>
+                      providers.length > 0
+                        ? `${providers.filter((p) => p.enabled).length}/${providers.length} enabled`
+                        : "none",
+                    emptyStateText:
+                      "No providers found on the Aperture gateway.",
+                  });
+                }),
+            },
+          ],
+        },
+        {
+          label: "Setup",
+          items: [
+            {
+              id: "onboardingDone",
+              label: "Onboarding",
+              description: onboardingDone ? "Setup completed" : "Setup pending",
+              currentValue: onboardingDone ? "completed" : "pending",
+              values: ["completed", "pending"],
+            },
+            {
+              id: "onboardingEnabled",
+              label: "Onboarding extension",
+              description: "Controls first-run onboarding command",
+              currentValue: onboardingEnabled ? "enabled" : "disabled",
+              values: ["enabled", "disabled"],
+            },
+          ],
+        },
+      ];
+    },
+    onSettingChange: (id, newValue, config) => {
+      const updated = structuredClone(config);
+      if (id === "baseUrl") updated.baseUrl = normalizeInputUrl(newValue);
+      if (id === "proxy.enabled")
+        updated.proxy = { ...updated.proxy, enabled: newValue === "enabled" };
+      if (id === "dedicated.enabled")
+        updated.dedicated = {
+          ...updated.dedicated,
+          enabled: newValue === "enabled",
+        };
+      if (id === "onboardingDone") {
+        updated.onboardingDone = newValue === "completed";
+        updated.onboarding = {
+          ...updated.onboarding,
+          enabled: !updated.onboardingDone,
+        };
+      }
+      if (id === "onboardingEnabled")
+        updated.onboarding = {
+          ...updated.onboarding,
+          enabled: newValue === "enabled",
+        };
+      return updated;
+    },
+    onSave: (ctx) => onSync(ctx),
+  });
+}

package/extensions/aperture/shared/config/defaults.ts

@@ -0,0 +1,17 @@
+import type { ResolvedConfig } from "./types";
+
+export const DEFAULT_CONFIG: ResolvedConfig = {
+  baseUrl: "",
+  onboardingDone: false,
+  onboarding: {
+    enabled: true,
+  },
+  proxy: {
+    enabled: false,
+    upstreamProviders: [],
+  },
+  dedicated: {
+    enabled: true,
+    providers: [],
+  },
+};

package/extensions/aperture/shared/config/loader.ts

@@ -0,0 +1,21 @@
+import { ConfigLoader } from "@aliou/pi-utils-settings";
+import { DEFAULT_CONFIG } from "./defaults";
+import { migrations } from "./migration";
+import type { ApertureConfig, ResolvedConfig } from "./types";
+
+export const configLoader = new ConfigLoader<ApertureConfig, ResolvedConfig>(
+  "aperture",
+  DEFAULT_CONFIG,
+  {
+    scopes: ["global"],
+    migrations,
+  },
+);
+
+export type {
+  ApertureConfig,
+  ApertureMode,
+  DedicatedProviderConfig,
+  ProxiedProviderConfig,
+  ResolvedConfig,
+} from "./types";

package/extensions/aperture/shared/config/migration/001-legacy-to-v0-6.ts

@@ -0,0 +1,45 @@
+import type { ApertureConfig, Migration } from "../types";
+
+export const legacyToV06Migration: Migration<ApertureConfig> = {
+  name: "001-legacy-to-v0-6",
+  shouldRun: (config) =>
+    config.providers !== undefined ||
+    config.checkGatewayModels !== undefined ||
+    config.apertureProvider !== undefined ||
+    (config.onboardingDone === undefined && config.baseUrl !== undefined),
+  run: (config) => {
+    const migrated: ApertureConfig = { ...config };
+    const hadProviders =
+      migrated.providers !== undefined ||
+      migrated.checkGatewayModels !== undefined;
+
+    if (hadProviders) {
+      const providers = migrated.providers ?? [];
+      const checked = migrated.checkGatewayModels ?? [];
+      migrated.proxy = {
+        ...migrated.proxy,
+        enabled: true,
+        upstreamProviders: providers.map((id) => ({
+          id,
+          shouldCheckGatewayModels: checked.includes(id),
+        })),
+      };
+      delete migrated.providers;
+      delete migrated.checkGatewayModels;
+    }
+
+    if (migrated.apertureProvider !== undefined) {
+      migrated.dedicated = {
+        ...migrated.dedicated,
+        enabled: migrated.apertureProvider,
+      };
+      delete migrated.apertureProvider;
+    }
+
+    if (migrated.onboardingDone === undefined && migrated.baseUrl) {
+      migrated.onboardingDone = true;
+    }
+
+    return migrated;
+  },
+};

package/extensions/aperture/shared/config/migration/002-mode-to-capabilities.ts

@@ -0,0 +1,20 @@
+import type { ApertureConfig, Migration } from "../types";
+
+export const modeToCapabilitiesMigration: Migration<ApertureConfig> = {
+  name: "002-mode-to-capabilities",
+  shouldRun: (config) => config.mode !== undefined,
+  run: (config) => {
+    const migrated: ApertureConfig = { ...config };
+
+    if (migrated.mode === "proxy") {
+      migrated.proxy = { ...migrated.proxy, enabled: true };
+      migrated.dedicated = { ...migrated.dedicated, enabled: false };
+    } else if (migrated.mode === "dedicated") {
+      migrated.dedicated = { ...migrated.dedicated, enabled: true };
+      migrated.proxy = { ...migrated.proxy, enabled: false };
+    }
+
+    delete migrated.mode;
+    return migrated;
+  },
+};

package/extensions/aperture/shared/config/migration/003-normalize-capabilities.ts

@@ -0,0 +1,26 @@
+import type { ApertureConfig, Migration } from "../types";
+
+export const normalizeCapabilitiesMigration: Migration<ApertureConfig> = {
+  name: "003-normalize-capabilities",
+  shouldRun: (config) =>
+    config.proxy?.enabled === undefined ||
+    config.proxy?.upstreamProviders === undefined ||
+    config.dedicated?.enabled === undefined ||
+    config.dedicated?.providers === undefined ||
+    config.dedicated?.cachedModels !== undefined,
+  run: (config) => {
+    const migrated: ApertureConfig = { ...config };
+    migrated.proxy = {
+      ...migrated.proxy,
+      enabled: migrated.proxy?.enabled ?? false,
+      upstreamProviders: migrated.proxy?.upstreamProviders ?? [],
+    };
+    migrated.dedicated = {
+      ...migrated.dedicated,
+      enabled: migrated.dedicated?.enabled ?? true,
+      providers: migrated.dedicated?.providers ?? [],
+    };
+    delete migrated.dedicated.cachedModels;
+    return migrated;
+  },
+};

package/extensions/aperture/shared/config/migration/index.ts

@@ -0,0 +1,15 @@
+import { legacyToV06Migration } from "./001-legacy-to-v0-6";
+import { modeToCapabilitiesMigration } from "./002-mode-to-capabilities";
+import { normalizeCapabilitiesMigration } from "./003-normalize-capabilities";
+
+export const migrations = [
+  legacyToV06Migration,
+  modeToCapabilitiesMigration,
+  normalizeCapabilitiesMigration,
+];
+
+export {
+  legacyToV06Migration,
+  modeToCapabilitiesMigration,
+  normalizeCapabilitiesMigration,
+};

package/extensions/aperture/shared/config/types.ts

@@ -0,0 +1,57 @@
+export interface ProxiedProviderConfig {
+  id: string;
+  shouldCheckGatewayModels?: boolean;
+}
+
+export interface DedicatedProviderConfig {
+  id: string;
+  name?: string;
+  enabled: boolean;
+}
+
+export type ApertureMode = "proxy" | "dedicated";
+
+export interface ApertureConfig {
+  baseUrl?: string;
+  onboardingDone?: boolean;
+  onboarding?: {
+    enabled?: boolean;
+  };
+  proxy?: {
+    enabled?: boolean;
+    upstreamProviders?: ProxiedProviderConfig[];
+  };
+  dedicated?: {
+    enabled?: boolean;
+    providers?: DedicatedProviderConfig[];
+    cachedModels?: unknown[];
+  };
+
+  // Legacy-only migration inputs.
+  mode?: ApertureMode;
+  providers?: string[];
+  checkGatewayModels?: string[];
+  apertureProvider?: boolean;
+}
+
+export interface ResolvedConfig {
+  baseUrl: string;
+  onboardingDone: boolean;
+  onboarding: {
+    enabled: boolean;
+  };
+  proxy: {
+    enabled: boolean;
+    upstreamProviders: Required<ProxiedProviderConfig>[];
+  };
+  dedicated: {
+    enabled: boolean;
+    providers: DedicatedProviderConfig[];
+  };
+}
+
+export interface Migration<TConfig> {
+  name: string;
+  shouldRun: (config: TConfig) => boolean;
+  run: (config: TConfig, filePath: string) => TConfig;
+}

package/extensions/aperture/shared/sync-bus.ts

@@ -0,0 +1,12 @@
+type SyncCallback = () => void;
+
+const listeners = new Set<SyncCallback>();
+
+export function onConfigSync(cb: SyncCallback): () => void {
+  listeners.add(cb);
+  return () => listeners.delete(cb);
+}
+
+export function emitConfigSync(): void {
+  for (const listener of listeners) listener();
+}

package/{src/lib → extensions/aperture/shared}/types.ts

@@ -8,7 +8,7 @@ import type {
   Context,
   Model,
   SimpleStreamOptions,
-} from "@mariozechner/pi-ai";
+} from "@earendil-works/pi-ai";
 
 export type {
   Api,