@pi-chamber/web 0.1.8

package/server/lib/pi/attachment-store.js

@@ -0,0 +1,98 @@
+import { randomUUID } from 'node:crypto';
+import { mkdir, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { basename, extname, join } from 'node:path';
+
+const MAX_ATTACHMENT_BYTES = 100 * 1024 * 1024;
+const MAX_ATTACHMENT_COUNT = 32;
+const ATTACHMENT_TTL_MS = 60 * 60 * 1_000;
+const REJECTED_MIME_PREFIXES = ['application/x-msdownload', 'application/x-dosexec'];
+
+export class PiAttachmentStoreError extends Error {
+  constructor(code) {
+    super('The Pi attachment could not be processed.');
+    this.code = code;
+  }
+}
+
+const invalid = () => new PiAttachmentStoreError('ATTACHMENT_FAILED');
+
+const sanitizeFilename = (value) => {
+  const filename = basename(typeof value === 'string' ? value : 'attachment')
+    // The explicit control range is intentional: client-supplied filenames
+    // must never produce an ambiguous temporary-file path.
+    // eslint-disable-next-line no-control-regex
+    .replace(/[\x00-\x1f\x7f]/g, '')
+    .replace(/[^a-zA-Z0-9._-]/g, '_')
+    .replace(/^\.+/, '')
+    .slice(0, 160);
+  return filename || 'attachment';
+};
+
+const decodeBase64 = (value) => {
+  if (typeof value !== 'string' || value.length === 0 || value.length > Math.ceil(MAX_ATTACHMENT_BYTES * 4 / 3) + 8) throw invalid();
+  if (!/^[A-Za-z0-9+/]*={0,2}$/.test(value) || value.length % 4 !== 0) throw invalid();
+  const bytes = Buffer.from(value, 'base64');
+  if (bytes.length === 0 || bytes.length > MAX_ATTACHMENT_BYTES) throw new PiAttachmentStoreError(bytes.length === 0 ? 'ATTACHMENT_FAILED' : 'ATTACHMENT_TOO_LARGE');
+  return bytes;
+};
+
+const normalizeMime = (value) => {
+  if (typeof value !== 'string' || value.length === 0 || value.length > 200) throw invalid();
+  const mime = value.toLowerCase();
+  if (REJECTED_MIME_PREFIXES.some((prefix) => mime.startsWith(prefix))) throw invalid();
+  return mime;
+};
+
+/**
+ * Process-lifetime upload map. The browser receives opaque ids only; resolved
+ * filesystem paths cross the private daemon IPC and are never returned from a
+ * public route or persisted in Pi JSONL.
+ */
+export const createPiAttachmentStore = ({
+  directory = join(tmpdir(), 'pichamber-pi-attachments'),
+  now = () => Date.now(),
+  ttlMs = ATTACHMENT_TTL_MS,
+} = {}) => {
+  const entries = new Map();
+
+  const cleanup = async () => {
+    const expired = [...entries.values()].filter((entry) => entry.expiresAt <= now());
+    await Promise.all(expired.map(async (entry) => {
+      entries.delete(entry.id);
+      await rm(entry.path, { force: true });
+    }));
+  };
+
+  const create = async ({ filename, mime, base64 }) => {
+    await cleanup();
+    if (entries.size >= MAX_ATTACHMENT_COUNT) throw new PiAttachmentStoreError('ATTACHMENT_LIMIT_REACHED');
+    const safeName = sanitizeFilename(filename);
+    const safeMime = normalizeMime(mime);
+    const bytes = decodeBase64(base64);
+    const extension = extname(safeName).slice(0, 20);
+    const id = randomUUID();
+    const path = join(directory, `pi-clipboard-${id}${extension}`);
+    await mkdir(directory, { recursive: true, mode: 0o700 });
+    await writeFile(path, bytes, { flag: 'wx', mode: 0o600 });
+    const entry = { id, name: safeName, mime: safeMime, size: bytes.length, path, expiresAt: now() + ttlMs };
+    entries.set(id, entry);
+    return { id: entry.id, name: entry.name, mime: entry.mime, size: entry.size };
+  };
+
+  const resolve = async (ids) => {
+    await cleanup();
+    if (!Array.isArray(ids) || ids.length > MAX_ATTACHMENT_COUNT || ids.some((id) => typeof id !== 'string' || id.length === 0)) throw invalid();
+    const selected = ids.map((id) => entries.get(id));
+    if (selected.some((entry) => !entry)) throw new PiAttachmentStoreError('ATTACHMENT_MISSING');
+    return selected.map(({ id, name, mime, size, path }) => ({ id, name, mime, size, path }));
+  };
+
+  const dispose = async () => {
+    const current = [...entries.values()];
+    entries.clear();
+    await Promise.all(current.map((entry) => rm(entry.path, { force: true })));
+  };
+
+  return { create, resolve, cleanup, dispose };
+};

package/server/lib/pi/attachment-store.test.js

@@ -0,0 +1,40 @@
+import { afterEach, describe, expect, it } from 'vitest';
+import { mkdtemp, readFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+import { createPiAttachmentStore, PiAttachmentStoreError } from './attachment-store.js';
+
+const base64 = (value) => Buffer.from(value).toString('base64');
+
+describe('Pi attachment store', () => {
+  let store;
+
+  afterEach(async () => {
+    await store?.dispose();
+    store = undefined;
+  });
+
+  it('writes bounded uploads using opaque ids and keeps paths private', async () => {
+    const directory = await mkdtemp(join(tmpdir(), 'pichamber-pi-attachments-'));
+    store = createPiAttachmentStore({ directory });
+    const attachment = await store.create({ filename: '../../notes?.txt', mime: 'text/plain', base64: base64('hello') });
+
+    expect(attachment).toEqual(expect.objectContaining({ name: 'notes_.txt', mime: 'text/plain', size: 5 }));
+    expect(attachment).not.toHaveProperty('path');
+    const [privateAttachment] = await store.resolve([attachment.id]);
+    await expect(readFile(privateAttachment.path, 'utf8')).resolves.toBe('hello');
+  });
+
+  it('rejects malformed, executable, missing, and expired uploads explicitly', async () => {
+    let now = 0;
+    store = createPiAttachmentStore({ directory: await mkdtemp(join(tmpdir(), 'pichamber-pi-attachments-')), now: () => now, ttlMs: 1 });
+    await expect(store.create({ filename: 'bad', mime: 'text/plain', base64: 'not base64!' })).rejects.toMatchObject({ code: 'ATTACHMENT_FAILED' });
+    await expect(store.create({ filename: 'bad.exe', mime: 'application/x-msdownload', base64: base64('x') })).rejects.toMatchObject({ code: 'ATTACHMENT_FAILED' });
+    await expect(store.resolve(['missing'])).rejects.toBeInstanceOf(PiAttachmentStoreError);
+
+    const attachment = await store.create({ filename: 'note.txt', mime: 'text/plain', base64: base64('x') });
+    now = 2;
+    await expect(store.resolve([attachment.id])).rejects.toMatchObject({ code: 'ATTACHMENT_MISSING' });
+  });
+});

package/server/lib/pi/custom-themes.js

@@ -0,0 +1,33 @@
+import { readdir, readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+
+import { resolvePiChamberDataPath } from '../pichamber-data-dir.js';
+
+const MAX_THEME_BYTES = 1024 * 1024;
+
+export const listPiCustomThemes = async ({
+  directory = resolvePiChamberDataPath('themes'),
+  fs = { readdir, readFile },
+} = {}) => {
+  let entries;
+  try {
+    entries = await fs.readdir(directory, { withFileTypes: true });
+  } catch (error) {
+    if (error?.code === 'ENOENT') return [];
+    throw error;
+  }
+
+  const themes = [];
+  for (const entry of entries) {
+    if (!entry?.isFile?.() || !entry.name.toLowerCase().endsWith('.json')) continue;
+    try {
+      const raw = await fs.readFile(join(directory, entry.name), 'utf8');
+      if (Buffer.byteLength(raw) > MAX_THEME_BYTES) continue;
+      const theme = JSON.parse(raw);
+      if (theme && typeof theme === 'object' && !Array.isArray(theme)) themes.push(theme);
+    } catch {
+      // One malformed theme must not hide unrelated valid themes.
+    }
+  }
+  return themes;
+};

package/server/lib/pi/custom-themes.test.js

@@ -0,0 +1,21 @@
+import { describe, expect, it } from 'vitest';
+import { mkdir, mkdtemp, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+import { listPiCustomThemes } from './custom-themes.js';
+
+describe('Pi custom themes', () => {
+  it('returns an empty authoritative list when the directory is missing', async () => {
+    const root = await mkdtemp(join(tmpdir(), 'pichamber-themes-'));
+    await expect(listPiCustomThemes({ directory: join(root, 'missing') })).resolves.toEqual([]);
+  });
+
+  it('keeps valid themes when another theme is malformed', async () => {
+    const root = await mkdtemp(join(tmpdir(), 'pichamber-themes-'));
+    await mkdir(root, { recursive: true });
+    await writeFile(join(root, 'valid.json'), JSON.stringify({ metadata: { id: 'valid' } }));
+    await writeFile(join(root, 'broken.json'), '{broken');
+    await expect(listPiCustomThemes({ directory: root })).resolves.toEqual([{ metadata: { id: 'valid' } }]);
+  });
+});

package/server/lib/pi/legacy-ui-model-defaults.js

@@ -0,0 +1,57 @@
+const parseProviderModelString = (value) => {
+  if (typeof value !== 'string') return undefined;
+  const trimmed = value.trim();
+  const separator = trimmed.indexOf('/');
+  if (separator <= 0 || separator >= trimmed.length - 1) return undefined;
+  const providerId = trimmed.slice(0, separator).trim();
+  const modelId = trimmed.slice(separator + 1).trim();
+  if (!providerId || !modelId) return undefined;
+  return { providerId, modelId };
+};
+
+/**
+ * Copy leftover UI/desktop model strings into sidecar fields that are still unset.
+ * Sessions settings now owns these fields; this is a one-time bridge.
+ */
+export const legacyUiModelDefaultsPatch = (uiSettings, current = {}) => {
+  if (!uiSettings || typeof uiSettings !== 'object') return {};
+  const patch = {};
+  if (!current.defaultModel) {
+    const model = parseProviderModelString(uiSettings.defaultModel);
+    if (model) patch.defaultModel = model;
+  }
+  if (!current.smallModel && uiSettings.smallModelUseDefault === false) {
+    const small = parseProviderModelString(uiSettings.smallModelOverride);
+    if (small) patch.smallModel = small;
+  }
+  if (!current.walkthroughModel) {
+    const walkthrough = parseProviderModelString(uiSettings.walkthroughModelOverride);
+    if (walkthrough) patch.walkthroughModel = walkthrough;
+  }
+  return patch;
+};
+
+const LEGACY_UI_MODEL_DEFAULT_CLEAR = {
+  defaultModel: '',
+  smallModelOverride: '',
+  walkthroughModelOverride: '',
+};
+
+export const adoptLegacyUiModelDefaults = async (settingsStore, uiSettingsStore) => {
+  const current = await settingsStore.read();
+  let uiSettings;
+  try {
+    uiSettings = await uiSettingsStore.read();
+  } catch {
+    return current;
+  }
+  const patch = legacyUiModelDefaultsPatch(uiSettings, current);
+  if (Object.keys(patch).length === 0) return current;
+  const next = await settingsStore.update(patch);
+  try {
+    await uiSettingsStore.write(LEGACY_UI_MODEL_DEFAULT_CLEAR);
+  } catch {
+    // Sidecar is already authoritative; leftover UI keys must not fail the read.
+  }
+  return next;
+};

package/server/lib/pi/legacy-ui-model-defaults.test.js

@@ -0,0 +1,65 @@
+import { describe, expect, it, vi } from 'vitest';
+
+import { adoptLegacyUiModelDefaults, legacyUiModelDefaultsPatch } from './legacy-ui-model-defaults.js';
+
+describe('legacy UI model defaults', () => {
+  it('adopts leftover UI strings only for unset sidecar fields', () => {
+    expect(legacyUiModelDefaultsPatch({
+      defaultModel: 'openai/gpt-5',
+      smallModelUseDefault: false,
+      smallModelOverride: 'openai/mini',
+      walkthroughModelOverride: 'anthropic/sonnet',
+    }, {
+      defaultModel: { providerId: 'google', modelId: 'gemini' },
+    })).toEqual({
+      smallModel: { providerId: 'openai', modelId: 'mini' },
+      walkthroughModel: { providerId: 'anthropic', modelId: 'sonnet' },
+    });
+  });
+
+  it('does not adopt a small-model override while the default-small checkbox is on', () => {
+    expect(legacyUiModelDefaultsPatch({
+      smallModelUseDefault: true,
+      smallModelOverride: 'openai/mini',
+    })).toEqual({});
+  });
+
+  it('writes adopted values into the sidecar and clears leftover UI keys', async () => {
+    const settingsStore = {
+      read: vi.fn(async () => ({ version: 1 })),
+      update: vi.fn(async (patch) => ({ version: 1, ...patch })),
+    };
+    const uiSettingsStore = {
+      read: vi.fn(async () => ({ defaultModel: 'openai/gpt-5', themeMode: 'dark' })),
+      write: vi.fn(async () => ({})),
+    };
+    await expect(adoptLegacyUiModelDefaults(settingsStore, uiSettingsStore)).resolves.toEqual({
+      version: 1,
+      defaultModel: { providerId: 'openai', modelId: 'gpt-5' },
+    });
+    expect(settingsStore.update).toHaveBeenCalledWith({ defaultModel: { providerId: 'openai', modelId: 'gpt-5' } });
+    expect(uiSettingsStore.write).toHaveBeenCalledWith({
+      defaultModel: '',
+      smallModelOverride: '',
+      walkthroughModelOverride: '',
+    });
+  });
+
+  it('leaves sidecar unchanged when UI settings are unreadable', async () => {
+    const settingsStore = {
+      read: vi.fn(async () => ({ version: 1, defaultThinking: 'high' })),
+      update: vi.fn(),
+    };
+    const uiSettingsStore = {
+      read: vi.fn(async () => {
+        throw new Error('UI_SETTINGS_INVALID');
+      }),
+      write: vi.fn(),
+    };
+    await expect(adoptLegacyUiModelDefaults(settingsStore, uiSettingsStore)).resolves.toEqual({
+      version: 1,
+      defaultThinking: 'high',
+    });
+    expect(settingsStore.update).not.toHaveBeenCalled();
+  });
+});

package/server/lib/pi/model-config-store.js

@@ -0,0 +1,173 @@
+import { mkdir, readFile, rename, writeFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+
+const PROVIDER_ID = /^[a-z0-9][a-z0-9-_]*$/;
+const API_KEY_REFERENCE = /^\{env:[A-Za-z_][A-Za-z0-9_]*\}$/;
+const API_TYPES = new Set(['openai-completions', 'openai-responses', 'anthropic-messages', 'google-generative-ai']);
+
+// Pi accepts JSON-with-comments for models.json. Strip comments without
+// touching quoted URL/header values before parsing the editable snapshot.
+const stripJsonComments = (source) => {
+  let output = '';
+  let quote = '';
+  let escaped = false;
+  for (let index = 0; index < source.length; index += 1) {
+    const current = source[index];
+    const next = source[index + 1];
+    if (quote) {
+      output += current;
+      if (escaped) escaped = false;
+      else if (current === '\\') escaped = true;
+      else if (current === quote) quote = '';
+      continue;
+    }
+    if (current === '"' || current === "'") {
+      quote = current;
+      output += current;
+      continue;
+    }
+    if (current === '/' && next === '/') {
+      while (index < source.length && source[index] !== '\n') index += 1;
+      output += '\n';
+      continue;
+    }
+    if (current === '/' && next === '*') {
+      index += 2;
+      while (index < source.length && !(source[index] === '*' && source[index + 1] === '/')) index += 1;
+      index += 1;
+      continue;
+    }
+    output += current;
+  }
+  return output;
+};
+
+const invalidModelConfig = () => {
+  const error = new Error('Pi models configuration is invalid.');
+  error.code = 'PI_MODEL_CONFIG_INVALID';
+  return error;
+};
+
+const cloneRecord = (value) => {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) throw invalidModelConfig();
+  return structuredClone(value);
+};
+
+const validateHeaderMap = (headers) => {
+  if (headers === undefined) return undefined;
+  if (!headers || typeof headers !== 'object' || Array.isArray(headers)
+    || Object.entries(headers).some(([key, value]) => !key || key.length > 256 || typeof value !== 'string' || value.length > 8_192)) throw invalidModelConfig();
+  return headers;
+};
+
+const publicProvider = (providerId, value) => {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) throw invalidModelConfig();
+  if (!Array.isArray(value.models)) return null;
+  const models = value.models.map((model) => {
+    if (!model || typeof model !== 'object' || typeof model.id !== 'string' || model.id.length === 0) throw invalidModelConfig();
+    return {
+      id: model.id,
+      providerId,
+      ...(typeof model.name === 'string' ? { label: model.name } : {}),
+      ...(Number.isSafeInteger(model.contextWindow) ? { contextWindow: model.contextWindow } : {}),
+      ...(model.reasoning === true ? { supportsThinking: true } : {}),
+    };
+  });
+  return {
+    providerId,
+    ...(typeof value.name === 'string' ? { label: value.name } : {}),
+    ...(typeof value.baseUrl === 'string' ? { baseUrl: value.baseUrl } : {}),
+    ...(typeof value.api === 'string' ? { api: value.api } : {}),
+    models,
+  };
+};
+
+const normalizeUpdate = (input) => {
+  if (!input || typeof input !== 'object' || typeof input.providerId !== 'string' || !PROVIDER_ID.test(input.providerId)
+    || typeof input.label !== 'string' || input.label.trim().length === 0 || input.label.length > 256
+    || typeof input.baseUrl !== 'string' || !/^https?:\/\//.test(input.baseUrl) || input.baseUrl.length > 8_192
+    || !API_TYPES.has(input.api ?? 'openai-completions') || !Array.isArray(input.models) || input.models.length === 0 || input.models.length > 256
+    || (input.apiKeyReference !== undefined && (typeof input.apiKeyReference !== 'string' || !API_KEY_REFERENCE.test(input.apiKeyReference)))) throw invalidModelConfig();
+  const modelIds = new Set();
+  const models = input.models.map((model) => {
+    if (!model || typeof model !== 'object' || typeof model.id !== 'string' || model.id.trim().length === 0 || model.id.length > 512
+      || (typeof model.label !== 'string' || model.label.trim().length === 0 || model.label.length > 512)
+      || (model.contextWindow !== undefined && (!Number.isSafeInteger(model.contextWindow) || model.contextWindow <= 0))
+      || (model.supportsThinking !== undefined && typeof model.supportsThinking !== 'boolean')) throw invalidModelConfig();
+    const id = model.id.trim();
+    if (modelIds.has(id)) throw invalidModelConfig();
+    modelIds.add(id);
+    return {
+      id,
+      name: model.label.trim(),
+      ...(Number.isSafeInteger(model.contextWindow) ? { contextWindow: model.contextWindow } : {}),
+      ...(model.supportsThinking === true ? { reasoning: true } : {}),
+    };
+  });
+  return {
+    providerId: input.providerId,
+    name: input.label.trim(),
+    baseUrl: input.baseUrl.trim(),
+    api: input.api ?? 'openai-completions',
+    models,
+    ...(input.headers !== undefined ? { headers: validateHeaderMap(input.headers) } : {}),
+    ...(input.apiKeyReference ? { apiKeyReference: input.apiKeyReference } : {}),
+  };
+};
+
+/**
+ * Owns atomic updates to Pi's credential-blind models.json. Credentials are
+ * deliberately excluded: literal keys use Pi's auth flow, and only validated
+ * `{env:NAME}` references may be persisted with a provider configuration.
+ */
+export const createPiModelConfigStore = ({ file }) => {
+  if (typeof file !== 'string' || file.length === 0) throw invalidModelConfig();
+  let writeChain = Promise.resolve();
+
+  const readConfig = async () => {
+    try {
+      const parsed = JSON.parse(stripJsonComments(await readFile(file, 'utf8')));
+      const config = cloneRecord(parsed);
+      if (!config.providers || typeof config.providers !== 'object' || Array.isArray(config.providers)) throw invalidModelConfig();
+      return config;
+    } catch (error) {
+      if (error?.code === 'ENOENT') return { providers: {} };
+      if (error?.code === 'PI_MODEL_CONFIG_INVALID') throw error;
+      throw invalidModelConfig();
+    }
+  };
+
+  const get = async (providerId) => {
+    if (typeof providerId !== 'string' || !PROVIDER_ID.test(providerId)) throw invalidModelConfig();
+    const config = await readConfig();
+    if (!Object.hasOwn(config.providers, providerId)) return null;
+    return publicProvider(providerId, config.providers[providerId]);
+  };
+
+  const update = async (input) => {
+    const nextProvider = normalizeUpdate(input);
+    const operation = writeChain.then(async () => {
+      const config = await readConfig();
+      const previous = config.providers[nextProvider.providerId];
+      const provider = {
+        ...(previous && typeof previous === 'object' && !Array.isArray(previous) ? previous : {}),
+        name: nextProvider.name,
+        baseUrl: nextProvider.baseUrl,
+        api: nextProvider.api,
+        models: nextProvider.models,
+        ...(nextProvider.headers !== undefined ? { headers: nextProvider.headers } : {}),
+        ...(nextProvider.apiKeyReference ? { apiKey: nextProvider.apiKeyReference } : {}),
+      };
+      config.providers[nextProvider.providerId] = provider;
+      await mkdir(dirname(file), { recursive: true, mode: 0o700 });
+      const temporary = join(dirname(file), `.${Date.now()}-${process.pid}-models.json.tmp`);
+      await writeFile(temporary, `${JSON.stringify(config, null, 2)}\n`, { mode: 0o600 });
+      await rename(temporary, file);
+      return publicProvider(nextProvider.providerId, provider);
+    });
+    writeChain = operation.catch(() => {});
+    return operation;
+  };
+
+  return { get, update };
+};

package/server/lib/pi/model-config-store.test.js

@@ -0,0 +1,42 @@
+import { describe, expect, it } from 'vitest';
+import { mkdtemp, readFile, stat, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+import { createPiModelConfigStore } from './model-config-store.js';
+
+describe('Pi models configuration store', () => {
+  it('atomically writes a credential-blind custom provider while preserving unrelated Pi configuration', async () => {
+    const root = await mkdtemp(join(tmpdir(), 'pichamber-pi-models-'));
+    const file = join(root, 'models.json');
+    await writeFile(file, `// Pi accepts comments in models.json\n{ "providers": { "builtin": { "baseUrl": "https://proxy.test", "api": "openai-completions" } } }`);
+    const store = createPiModelConfigStore({ file });
+
+    await expect(store.update({
+      providerId: 'custom-provider', label: 'Custom Provider', baseUrl: 'https://api.example.test/v1',
+      models: [{ id: 'model-1', providerId: 'custom-provider', label: 'Model 1', contextWindow: 128_000, supportsThinking: true }],
+      headers: { 'X-Client': 'PiChamber' }, apiKeyReference: '{env:CUSTOM_API_KEY}',
+    })).resolves.toEqual({
+      providerId: 'custom-provider', label: 'Custom Provider', baseUrl: 'https://api.example.test/v1', api: 'openai-completions',
+      models: [{ id: 'model-1', providerId: 'custom-provider', label: 'Model 1', contextWindow: 128_000, supportsThinking: true }],
+    });
+
+    const persisted = JSON.parse(await readFile(file, 'utf8'));
+    expect(persisted.providers.builtin).toEqual({ baseUrl: 'https://proxy.test', api: 'openai-completions' });
+    expect(persisted.providers['custom-provider']).toMatchObject({ apiKey: '{env:CUSTOM_API_KEY}', headers: { 'X-Client': 'PiChamber' } });
+    expect((await stat(file)).mode & 0o777).toBe(0o600);
+    expect(JSON.stringify(await store.get('custom-provider'))).not.toContain('CUSTOM_API_KEY');
+    expect(JSON.stringify(await store.get('custom-provider'))).not.toContain('X-Client');
+    await expect(store.get('amazon-bedrock')).resolves.toBeNull();
+    await expect(store.get('builtin')).resolves.toBeNull();
+  });
+
+  it('keeps malformed Pi models configuration explicit and rejects unsafe updates', async () => {
+    const root = await mkdtemp(join(tmpdir(), 'pichamber-pi-models-'));
+    const file = join(root, 'models.json');
+    await writeFile(file, '{ invalid');
+    const store = createPiModelConfigStore({ file });
+    await expect(store.get('custom')).rejects.toMatchObject({ code: 'PI_MODEL_CONFIG_INVALID' });
+    await expect(store.update({ providerId: '../unsafe', label: 'Unsafe', baseUrl: 'https://example.test', models: [] })).rejects.toMatchObject({ code: 'PI_MODEL_CONFIG_INVALID' });
+  });
+});