gloomberb 0.9.9 → 0.10.0

package/src/plugins/builtin/ai/pane-settings.ts

@@ -0,0 +1,319 @@
+import type {
+  PaneSettingActionContext,
+  PaneSettingField,
+  PaneSettingOption,
+  PaneSettingsDef,
+} from "../../../types/plugin";
+import { migrateLegacyAiProviderId } from "./providers";
+
+export const AI_DEFAULT_PROVIDER_SETTING_KEY = "defaultProviderId";
+export const AI_DEFAULT_MODEL_SETTING_KEY = "defaultModelId";
+export const AI_PANE_PROVIDER_SETTING_KEY = "providerId";
+export const AI_PANE_MODEL_SETTING_KEY = "modelId";
+export const AI_INHERIT_SETTING_VALUE = "";
+
+export interface AiSharedDefaults {
+  providerId: string;
+  modelId: string | null;
+}
+
+export interface ResolveAiPaneSelectionOptions {
+  settings: Record<string, unknown> | undefined;
+  savedProviderId: string | null | undefined;
+  savedModelId: string | null | undefined;
+  defaultProviderId: string;
+  defaultModelId: string | null | undefined;
+  providerKey?: string;
+  modelKey?: string;
+}
+
+export interface AiSettingsModel {
+  id: string;
+  label: string;
+  providerId: string;
+  description?: string;
+}
+
+export interface AiSettingsProvider {
+  id: string;
+  label: string;
+  description?: string;
+}
+
+export interface AiAccountSettingRow {
+  providerId: string;
+  providerLabel: string;
+  description: string;
+  actionLabel: string;
+  disabled?: boolean;
+  action: (context: PaneSettingActionContext) => void | Promise<void>;
+}
+
+export interface AiManageAccountsSettingRow {
+  description?: string;
+  actionLabel?: string;
+  action: (context: PaneSettingActionContext) => void | Promise<void>;
+}
+
+export interface AiPaneOverrideSettings {
+  providerId: string | null | undefined;
+  modelId: string | null | undefined;
+  providerKey?: string;
+  modelKey?: string;
+}
+
+export interface BuildAiPaneSettingsOptions {
+  title: string;
+  providers: AiSettingsProvider[];
+  models: AiSettingsModel[];
+  defaultProviderId: string | null | undefined;
+  defaultModelId: string | null | undefined;
+  paneOverride?: AiPaneOverrideSettings;
+  accountRows?: AiAccountSettingRow[];
+  manageAccounts?: AiManageAccountsSettingRow;
+  additional?: PaneSettingsDef;
+}
+
+function normalizeId(value: string | null | undefined): string {
+  return value?.trim() ?? "";
+}
+
+function normalizeProviderId(value: string | null | undefined): string {
+  const providerId = normalizeId(value);
+  return providerId ? migrateLegacyAiProviderId(providerId) : "";
+}
+
+function settingValue(
+  settings: Record<string, unknown> | undefined,
+  key: string,
+): { configured: boolean; value: string } {
+  if (!settings || !Object.prototype.hasOwnProperty.call(settings, key)) {
+    return { configured: false, value: "" };
+  }
+  const value = settings[key];
+  return {
+    configured: true,
+    value: typeof value === "string" ? value.trim() : "",
+  };
+}
+
+export function resolveAiSharedDefaults(
+  pluginConfig: Record<string, unknown> | undefined,
+  fallbackProviderId: string,
+): AiSharedDefaults {
+  const providerId = typeof pluginConfig?.[AI_DEFAULT_PROVIDER_SETTING_KEY] === "string"
+    ? normalizeProviderId(pluginConfig[AI_DEFAULT_PROVIDER_SETTING_KEY] as string)
+    : "";
+  const modelId = typeof pluginConfig?.[AI_DEFAULT_MODEL_SETTING_KEY] === "string"
+    ? normalizeId(pluginConfig[AI_DEFAULT_MODEL_SETTING_KEY] as string)
+    : "";
+  return {
+    providerId: providerId || normalizeProviderId(fallbackProviderId),
+    modelId: modelId || null,
+  };
+}
+
+/**
+ * Resolves a pane's effective runner without rewriting the saved thread or tab.
+ * Missing settings preserve legacy saved selections. An explicitly blank value
+ * means "use the shared default", which lets old panes opt in intentionally.
+ */
+export function resolveAiPaneSelection({
+  settings,
+  savedProviderId,
+  savedModelId,
+  defaultProviderId,
+  defaultModelId,
+  providerKey = AI_PANE_PROVIDER_SETTING_KEY,
+  modelKey = AI_PANE_MODEL_SETTING_KEY,
+}: ResolveAiPaneSelectionOptions): AiSharedDefaults {
+  const providerSetting = settingValue(settings, providerKey);
+  const modelSetting = settingValue(settings, modelKey);
+  const configuredProvider = normalizeProviderId(providerSetting.value);
+  const savedProvider = normalizeProviderId(savedProviderId);
+  const sharedProvider = normalizeProviderId(defaultProviderId);
+  const providerId = providerSetting.configured
+    ? configuredProvider || sharedProvider
+    : savedProvider || sharedProvider;
+
+  let modelId: string | null;
+  if (modelSetting.configured) {
+    modelId = modelSetting.value
+      || (providerId === sharedProvider ? normalizeId(defaultModelId) : "")
+      || null;
+  } else if (providerSetting.configured && configuredProvider !== savedProvider) {
+    modelId = (providerId === sharedProvider ? normalizeId(defaultModelId) : "") || null;
+  } else {
+    modelId = normalizeId(savedModelId) || null;
+  }
+
+  return { providerId, modelId };
+}
+
+function appendCurrentOption(
+  options: PaneSettingOption[],
+  currentValue: string,
+  label: string,
+): PaneSettingOption[] {
+  if (!currentValue || options.some((option) => option.value === currentValue)) return options;
+  return [
+    ...options,
+    {
+      value: currentValue,
+      label,
+      description: "Currently selected, but not present in the latest provider catalog.",
+    },
+  ];
+}
+
+function uniqueOptions(options: PaneSettingOption[]): PaneSettingOption[] {
+  const seen = new Set<string>();
+  return options.filter((option) => {
+    if (seen.has(option.value)) return false;
+    seen.add(option.value);
+    return true;
+  });
+}
+
+function providerOptions(
+  providers: AiSettingsProvider[],
+  currentValue: string,
+): PaneSettingOption[] {
+  const options = uniqueOptions(providers
+    .map((provider) => ({
+      value: normalizeId(provider.id),
+      label: provider.label,
+      description: provider.description,
+    }))
+    .filter((provider) => provider.value));
+  return appendCurrentOption(options, currentValue, `${currentValue} (current)`);
+}
+
+function modelOptions(
+  models: AiSettingsModel[],
+  providerId: string,
+  currentValue: string,
+  automaticLabel: string,
+): PaneSettingOption[] {
+  const options = uniqueOptions([
+    {
+      value: AI_INHERIT_SETTING_VALUE,
+      label: automaticLabel,
+    },
+    ...models
+      .filter((model) => normalizeId(model.providerId) === providerId)
+      .map((model) => ({
+        value: normalizeId(model.id),
+        label: model.label,
+        description: model.description,
+      }))
+      .filter((model) => model.value),
+  ]);
+  return appendCurrentOption(options, currentValue, `${currentValue} (current)`);
+}
+
+function getProviderLabel(providers: AiSettingsProvider[], providerId: string): string {
+  return providers.find((provider) => normalizeId(provider.id) === providerId)?.label ?? providerId;
+}
+
+export function buildAiPaneSettingsDef(options: BuildAiPaneSettingsOptions): PaneSettingsDef {
+  const defaultProviderId = normalizeProviderId(options.defaultProviderId)
+    || normalizeProviderId(options.providers[0]?.id);
+  const defaultModelId = normalizeId(options.defaultModelId);
+  const paneProviderId = normalizeProviderId(options.paneOverride?.providerId);
+  const paneModelId = normalizeId(options.paneOverride?.modelId);
+  const effectiveProviderId = paneProviderId || defaultProviderId;
+  const providerLabel = getProviderLabel(options.providers, defaultProviderId) || "configured provider";
+  const paneProviderKey = options.paneOverride?.providerKey ?? AI_PANE_PROVIDER_SETTING_KEY;
+  const paneModelKey = options.paneOverride?.modelKey ?? AI_PANE_MODEL_SETTING_KEY;
+
+  const fields: PaneSettingField[] = [
+    {
+      key: AI_DEFAULT_PROVIDER_SETTING_KEY,
+      label: "Default provider",
+      description: "Used by new AI panes and conversations.",
+      type: "select",
+      storage: "plugin",
+      clearOnChange: [AI_DEFAULT_MODEL_SETTING_KEY],
+      options: providerOptions(options.providers, defaultProviderId),
+    },
+    {
+      key: AI_DEFAULT_MODEL_SETTING_KEY,
+      label: "Default model",
+      description: "Used when a pane does not have its own model override.",
+      type: "select",
+      storage: "plugin",
+      options: modelOptions(options.models, defaultProviderId, defaultModelId, "Auto (recommended)"),
+    },
+  ];
+
+  if (options.paneOverride) {
+    fields.push(
+      {
+        key: paneProviderKey,
+        label: "Provider for this pane",
+        description: "Overrides the shared default for this pane only.",
+        type: "select",
+        clearOnChange: [paneModelKey],
+        options: [
+          {
+            value: AI_INHERIT_SETTING_VALUE,
+            label: `Use default · ${providerLabel}`,
+          },
+          ...providerOptions(options.providers, paneProviderId),
+        ],
+      },
+      {
+        key: paneModelKey,
+        label: "Model for this pane",
+        description: "Overrides the shared default for this pane only.",
+        type: "select",
+        options: modelOptions(options.models, effectiveProviderId, paneModelId, "Use default"),
+      },
+    );
+  }
+
+  for (const account of options.accountRows ?? []) {
+    fields.push({
+      key: `account:${account.providerId}`,
+      label: `${account.providerLabel} account`,
+      description: account.description,
+      type: "action",
+      actionId: `ai:account:${account.providerId}`,
+      actionLabel: account.actionLabel,
+      disabled: account.disabled,
+      action: account.action,
+    });
+  }
+
+  if (options.manageAccounts) {
+    fields.push({
+      key: "manageAiAccounts",
+      label: "AI accounts",
+      description: options.manageAccounts.description ?? "Connect, reconnect, or disconnect AI providers.",
+      type: "action",
+      actionId: "ai:manage-accounts",
+      actionLabel: options.manageAccounts.actionLabel ?? "Manage",
+      action: options.manageAccounts.action,
+    });
+  }
+
+  return {
+    title: options.title,
+    values: {
+      [AI_DEFAULT_PROVIDER_SETTING_KEY]: defaultProviderId,
+      [AI_DEFAULT_MODEL_SETTING_KEY]: defaultModelId,
+      ...(options.paneOverride
+        ? {
+          [paneProviderKey]: paneProviderId,
+          [paneModelKey]: paneModelId,
+        }
+        : {}),
+      ...(options.additional?.values ?? {}),
+    },
+    fields: [
+      ...fields,
+      ...(options.additional?.fields ?? []),
+    ],
+  };
+}

package/src/plugins/builtin/ai/pi/credential-store.test.ts

@@ -0,0 +1,80 @@
+import { afterEach, describe, expect, test } from "bun:test";
+import { mkdir, mkdtemp, readFile, rm, stat, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import { PiFileCredentialStore, resolvePiCredentialPath } from "./credential-store";
+
+const tempDirs: string[] = [];
+
+async function tempDataDir(): Promise<string> {
+  const path = await mkdtemp(join(tmpdir(), "gloomberb-pi-credentials-"));
+  tempDirs.push(path);
+  return path;
+}
+
+afterEach(async () => {
+  await Promise.all(tempDirs.splice(0).map((path) => rm(path, { recursive: true, force: true })));
+});
+
+describe("PiFileCredentialStore", () => {
+  test("persists credentials outside AppConfig and never returns mutable storage references", async () => {
+    const dataDir = await tempDataDir();
+    const store = new PiFileCredentialStore(dataDir);
+    await store.modify("anthropic", async () => ({
+      type: "oauth",
+      access: "access-one",
+      refresh: "refresh-one",
+      expires: 123,
+      accountId: "account-one",
+    }));
+
+    const first = await store.read("anthropic");
+    expect(first?.type).toBe("oauth");
+    if (first?.type === "oauth") first.access = "mutated-only-in-memory";
+
+    const reloaded = await new PiFileCredentialStore(dataDir).read("anthropic");
+    expect(reloaded).toMatchObject({
+      type: "oauth",
+      access: "access-one",
+      refresh: "refresh-one",
+      expires: 123,
+      accountId: "account-one",
+    });
+    expect(resolvePiCredentialPath(dataDir)).toBe(join(dataDir, "ai", "credentials.json"));
+
+    if (process.platform !== "win32") {
+      expect((await stat(resolvePiCredentialPath(dataDir))).mode & 0o777).toBe(0o600);
+      expect((await stat(dirname(resolvePiCredentialPath(dataDir)))).mode & 0o777).toBe(0o700);
+    }
+  });
+
+  test("serializes updates made through separate store instances", async () => {
+    const dataDir = await tempDataDir();
+    const first = new PiFileCredentialStore(dataDir);
+    const second = new PiFileCredentialStore(dataDir);
+
+    await Promise.all([
+      first.modify("anthropic", async () => ({ type: "api_key", key: "anthropic-key" })),
+      second.modify("openai", async () => ({ type: "api_key", key: "openai-key" })),
+    ]);
+
+    expect(await first.list()).toEqual([
+      { providerId: "anthropic", type: "api_key" },
+      { providerId: "openai", type: "api_key" },
+    ]);
+  });
+
+  test("fails closed instead of overwriting a malformed credential file", async () => {
+    const dataDir = await tempDataDir();
+    const path = resolvePiCredentialPath(dataDir);
+    await mkdir(dirname(path), { recursive: true });
+    await writeFile(path, JSON.stringify({ version: 1, credentials: { anthropic: { type: "oauth" } } }), "utf8");
+
+    const store = new PiFileCredentialStore(dataDir);
+    await expect(store.read("anthropic")).rejects.toThrow("stored AI credential");
+    await expect(store.modify("openai", async () => ({ type: "api_key", key: "key" }))).rejects.toThrow(
+      "stored AI credential",
+    );
+    expect(await readFile(path, "utf8")).toContain('"type":"oauth"');
+  });
+});

package/src/plugins/builtin/ai/pi/credential-store.ts

@@ -0,0 +1,138 @@
+import type {
+  ApiKeyCredential,
+  Credential,
+  CredentialInfo,
+  CredentialStore,
+  OAuthCredential,
+} from "@earendil-works/pi-ai";
+import { join } from "node:path";
+import { LockedJsonFile } from "./file-store";
+
+const CREDENTIAL_FILE_VERSION = 1;
+const PROVIDER_ID_PATTERN = /^[a-z0-9][a-z0-9._-]{0,127}$/i;
+
+interface CredentialFile {
+  version: typeof CREDENTIAL_FILE_VERSION;
+  credentials: Record<string, Credential>;
+}
+
+function assertProviderId(providerId: string): void {
+  if (!PROVIDER_ID_PATTERN.test(providerId)) {
+    throw new Error(`Invalid AI provider id: ${providerId}`);
+  }
+}
+
+function isStringRecord(value: unknown): value is Record<string, string> {
+  return !!value
+    && typeof value === "object"
+    && !Array.isArray(value)
+    && Object.values(value).every((entry) => typeof entry === "string");
+}
+
+function isApiKeyCredential(value: unknown): value is ApiKeyCredential {
+  if (!value || typeof value !== "object" || (value as { type?: unknown }).type !== "api_key") return false;
+  const credential = value as { key?: unknown; env?: unknown };
+  return (credential.key === undefined || typeof credential.key === "string")
+    && (credential.env === undefined || isStringRecord(credential.env));
+}
+
+function isOAuthCredential(value: unknown): value is OAuthCredential {
+  if (!value || typeof value !== "object" || (value as { type?: unknown }).type !== "oauth") return false;
+  const credential = value as { access?: unknown; refresh?: unknown; expires?: unknown };
+  return typeof credential.access === "string"
+    && typeof credential.refresh === "string"
+    && typeof credential.expires === "number"
+    && Number.isFinite(credential.expires);
+}
+
+function isCredential(value: unknown): value is Credential {
+  return isApiKeyCredential(value) || isOAuthCredential(value);
+}
+
+function cloneCredential<T extends Credential | undefined>(credential: T): T {
+  return credential === undefined ? credential : structuredClone(credential);
+}
+
+function validateCredentialFile(value: unknown): CredentialFile {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error("The AI credential file is not an object.");
+  }
+  const candidate = value as { version?: unknown; credentials?: unknown };
+  if (candidate.version !== CREDENTIAL_FILE_VERSION) {
+    throw new Error(`Unsupported AI credential file version: ${String(candidate.version)}`);
+  }
+  if (!candidate.credentials || typeof candidate.credentials !== "object" || Array.isArray(candidate.credentials)) {
+    throw new Error("The AI credential file does not contain a credentials object.");
+  }
+
+  const credentials: Record<string, Credential> = Object.create(null) as Record<string, Credential>;
+  for (const [providerId, credential] of Object.entries(candidate.credentials)) {
+    assertProviderId(providerId);
+    if (!isCredential(credential)) {
+      throw new Error(`The stored AI credential for ${providerId} is invalid.`);
+    }
+    credentials[providerId] = cloneCredential(credential);
+  }
+  return { version: CREDENTIAL_FILE_VERSION, credentials };
+}
+
+function createCredentialFile(): CredentialFile {
+  return {
+    version: CREDENTIAL_FILE_VERSION,
+    credentials: Object.create(null) as Record<string, Credential>,
+  };
+}
+
+export function resolvePiCredentialPath(dataDir: string): string {
+  return join(dataDir, "ai", "credentials.json");
+}
+
+/** Persistent backend credential store for Pi. Secrets never enter AppConfig. */
+export class PiFileCredentialStore implements CredentialStore {
+  readonly path: string;
+  private readonly file: LockedJsonFile<CredentialFile>;
+
+  constructor(dataDir: string) {
+    this.path = resolvePiCredentialPath(dataDir);
+    this.file = new LockedJsonFile(this.path, {
+      create: createCredentialFile,
+      validate: validateCredentialFile,
+    });
+  }
+
+  async read(providerId: string): Promise<Credential | undefined> {
+    assertProviderId(providerId);
+    const file = await this.file.read();
+    return cloneCredential(file.credentials[providerId]);
+  }
+
+  async list(): Promise<readonly CredentialInfo[]> {
+    const file = await this.file.read();
+    return Object.entries(file.credentials)
+      .map(([providerId, credential]) => ({ providerId, type: credential.type }))
+      .sort((left, right) => left.providerId.localeCompare(right.providerId));
+  }
+
+  async modify(
+    providerId: string,
+    update: (current: Credential | undefined) => Promise<Credential | undefined>,
+  ): Promise<Credential | undefined> {
+    assertProviderId(providerId);
+    return this.file.update(async (file) => {
+      const current = cloneCredential(file.credentials[providerId]);
+      const next = await update(current);
+      if (next !== undefined) {
+        if (!isCredential(next)) throw new Error(`Refusing to store an invalid AI credential for ${providerId}.`);
+        file.credentials[providerId] = cloneCredential(next);
+      }
+      return cloneCredential(file.credentials[providerId]);
+    });
+  }
+
+  async delete(providerId: string): Promise<void> {
+    assertProviderId(providerId);
+    await this.file.update((file) => {
+      delete file.credentials[providerId];
+    });
+  }
+}

package/src/plugins/builtin/ai/pi/file-store.ts

@@ -0,0 +1,138 @@
+import { chmod, mkdir, open, readFile, rename, rm, stat } from "node:fs/promises";
+import { dirname } from "node:path";
+import { randomUUID } from "node:crypto";
+
+const DIRECTORY_MODE = 0o700;
+const FILE_MODE = 0o600;
+
+export interface LockedJsonFileOptions<T> {
+  create: () => T;
+  validate: (value: unknown) => T;
+  lockTimeoutMs?: number;
+  staleLockMs?: number;
+}
+
+function errorCode(error: unknown): string | null {
+  return error && typeof error === "object" && "code" in error
+    ? String((error as { code?: unknown }).code)
+    : null;
+}
+
+function wait(delayMs: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, delayMs));
+}
+
+/**
+ * Small backend-only JSON store with atomic replacement and a cross-process
+ * lock. The lock is important because the TUI and desktop backend may share
+ * one Gloomberb data directory and Pi refreshes rotating OAuth tokens inside
+ * CredentialStore.modify().
+ */
+export class LockedJsonFile<T> {
+  readonly path: string;
+
+  private readonly options: Required<Pick<LockedJsonFileOptions<T>, "lockTimeoutMs" | "staleLockMs">>
+    & Omit<LockedJsonFileOptions<T>, "lockTimeoutMs" | "staleLockMs">;
+  private writeQueue: Promise<void> = Promise.resolve();
+
+  constructor(path: string, options: LockedJsonFileOptions<T>) {
+    this.path = path;
+    this.options = {
+      ...options,
+      lockTimeoutMs: options.lockTimeoutMs ?? 45_000,
+      staleLockMs: options.staleLockMs ?? 10 * 60_000,
+    };
+  }
+
+  async read(): Promise<T> {
+    let raw: string;
+    try {
+      raw = await readFile(this.path, "utf8");
+    } catch (error) {
+      if (errorCode(error) === "ENOENT") return this.options.create();
+      throw error;
+    }
+
+    let parsed: unknown;
+    try {
+      parsed = JSON.parse(raw);
+    } catch (error) {
+      throw new Error(`Could not parse ${this.path}`, { cause: error });
+    }
+    return this.options.validate(parsed);
+  }
+
+  update<R>(mutate: (current: T) => R | Promise<R>): Promise<R> {
+    const queued = this.writeQueue.catch(() => {}).then(async () => {
+      const release = await this.acquireLock();
+      try {
+        const current = await this.read();
+        const result = await mutate(current);
+        await this.write(current);
+        return result;
+      } finally {
+        await release();
+      }
+    });
+    this.writeQueue = queued.then(() => {}, () => {});
+    return queued;
+  }
+
+  private async write(value: T): Promise<void> {
+    await mkdir(dirname(this.path), { recursive: true, mode: DIRECTORY_MODE });
+    await chmod(dirname(this.path), DIRECTORY_MODE).catch(() => {});
+
+    const temporaryPath = `${this.path}.${process.pid}.${randomUUID()}.tmp`;
+    const handle = await open(temporaryPath, "wx", FILE_MODE);
+    try {
+      await handle.writeFile(`${JSON.stringify(value, null, 2)}\n`, "utf8");
+      await handle.sync();
+    } finally {
+      await handle.close();
+    }
+
+    try {
+      await rename(temporaryPath, this.path);
+      await chmod(this.path, FILE_MODE).catch(() => {});
+    } catch (error) {
+      await rm(temporaryPath, { force: true }).catch(() => {});
+      throw error;
+    }
+  }
+
+  private async acquireLock(): Promise<() => Promise<void>> {
+    const lockPath = `${this.path}.lock`;
+    const token = `${process.pid}:${randomUUID()}`;
+    const deadline = Date.now() + this.options.lockTimeoutMs;
+    await mkdir(dirname(this.path), { recursive: true, mode: DIRECTORY_MODE });
+    await chmod(dirname(this.path), DIRECTORY_MODE).catch(() => {});
+
+    while (true) {
+      try {
+        const handle = await open(lockPath, "wx", FILE_MODE);
+        try {
+          await handle.writeFile(token, "utf8");
+          await handle.sync();
+        } finally {
+          await handle.close();
+        }
+        return async () => {
+          const owner = await readFile(lockPath, "utf8").catch(() => null);
+          if (owner === token) await rm(lockPath, { force: true }).catch(() => {});
+        };
+      } catch (error) {
+        if (errorCode(error) !== "EEXIST") throw error;
+      }
+
+      const lockStat = await stat(lockPath).catch(() => null);
+      if (lockStat && Date.now() - lockStat.mtimeMs >= this.options.staleLockMs) {
+        await rm(lockPath, { force: true }).catch(() => {});
+        continue;
+      }
+      if (Date.now() >= deadline) {
+        throw new Error(`Timed out waiting for the AI store lock at ${lockPath}`);
+      }
+      await wait(25);
+    }
+  }
+}