@moxxy/core 0.6.3 → 0.21.0

package/src/preferences.test.ts

@@ -1,156 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import { promises as fs } from 'node:fs';
-import * as os from 'node:os';
-import * as path from 'node:path';
-import { loadPreferences, preferencesPath, savePreferences } from './preferences.js';
-
-// preferencesPath() resolves ~/.moxxy/preferences.json via os.homedir(), which
-// derives from HOME (POSIX) / USERPROFILE (Windows). Point both at a tmpdir per
-// test so the suite never touches the developer's real preferences file.
-let tmpHome: string;
-let savedHome: string | undefined;
-let savedUserProfile: string | undefined;
-let savedMoxxyHome: string | undefined;
-
-beforeEach(async () => {
-  tmpHome = await fs.mkdtemp(path.join(os.tmpdir(), 'mox-prefs-'));
-  savedHome = process.env.HOME;
-  savedUserProfile = process.env.USERPROFILE;
-  savedMoxxyHome = process.env.MOXXY_HOME;
-  process.env.HOME = tmpHome;
-  process.env.USERPROFILE = tmpHome;
-  // The default-home tests below assert the `~/.moxxy` fallback, so MOXXY_HOME
-  // must be unset for them (it would otherwise win).
-  delete process.env.MOXXY_HOME;
-  await fs.mkdir(path.join(tmpHome, '.moxxy'), { recursive: true });
-});
-
-afterEach(async () => {
-  if (savedHome === undefined) delete process.env.HOME;
-  else process.env.HOME = savedHome;
-  if (savedUserProfile === undefined) delete process.env.USERPROFILE;
-  else process.env.USERPROFILE = savedUserProfile;
-  if (savedMoxxyHome === undefined) delete process.env.MOXXY_HOME;
-  else process.env.MOXXY_HOME = savedMoxxyHome;
-  await fs.rm(tmpHome, { recursive: true, force: true });
-});
-
-const readRaw = async (): Promise<unknown> =>
-  JSON.parse(await fs.readFile(preferencesPath(), 'utf8'));
-
-describe('preferences store', () => {
-  it('resolves the path under the (overridden) home dir', () => {
-    expect(preferencesPath()).toBe(path.join(tmpHome, '.moxxy', 'preferences.json'));
-  });
-
-  it('honors $MOXXY_HOME so preferences follow the relocated data dir', async () => {
-    const altHome = await fs.mkdtemp(path.join(os.tmpdir(), 'mox-prefs-alt-'));
-    const prevMoxxyHome = process.env.MOXXY_HOME;
-    process.env.MOXXY_HOME = altHome;
-    try {
-      // Path now lives directly under MOXXY_HOME, NOT under ~/.moxxy.
-      expect(preferencesPath()).toBe(path.join(altHome, 'preferences.json'));
-      await savePreferences({ model: 'relocated' });
-      // Written to the relocated dir, not the homedir fallback.
-      const raw = await fs.readFile(path.join(altHome, 'preferences.json'), 'utf8');
-      expect(JSON.parse(raw).model).toBe('relocated');
-      // The homedir fallback location must remain empty.
-      await expect(
-        fs.readFile(path.join(tmpHome, '.moxxy', 'preferences.json'), 'utf8'),
-      ).rejects.toMatchObject({ code: 'ENOENT' });
-    } finally {
-      if (prevMoxxyHome === undefined) delete process.env.MOXXY_HOME;
-      else process.env.MOXXY_HOME = prevMoxxyHome;
-      await fs.rm(altHome, { recursive: true, force: true });
-    }
-  });
-
-  it('returns an empty object when the file is missing', async () => {
-    expect(await loadPreferences()).toEqual({});
-  });
-
-  it('returns an empty object when the file is corrupt', async () => {
-    await fs.writeFile(preferencesPath(), '{ not json', 'utf8');
-    expect(await loadPreferences()).toEqual({});
-  });
-
-  it('round-trips a patch through disk', async () => {
-    await savePreferences({ model: 'gpt-5.4-mini', providerName: 'openai' });
-    const loaded = await loadPreferences();
-    expect(loaded.model).toBe('gpt-5.4-mini');
-    expect(loaded.providerName).toBe('openai');
-  });
-
-  it('merges a second patch without clobbering unrelated fields', async () => {
-    await savePreferences({ providerName: 'openai' });
-    await savePreferences({ model: 'gpt-5.4-mini' });
-    const loaded = await loadPreferences();
-    expect(loaded.providerName).toBe('openai');
-    expect(loaded.model).toBe('gpt-5.4-mini');
-  });
-
-  it('migrates legacy mode names on load', async () => {
-    // "tool-use" is the legacy id that migrateModeName maps to "default".
-    await fs.writeFile(
-      preferencesPath(),
-      JSON.stringify({ mode: 'tool-use' }) + '\n',
-      'utf8',
-    );
-    const loaded = await loadPreferences();
-    expect(loaded.mode).toBe('default');
-  });
-
-  it('writes a trailing newline atomically (no partial file)', async () => {
-    await savePreferences({ model: 'm1' });
-    const raw = await fs.readFile(preferencesPath(), 'utf8');
-    expect(raw.endsWith('\n')).toBe(true);
-    expect(JSON.parse(raw)).toEqual({ model: 'm1' });
-  });
-
-  it('serializes overlapping saves so no update is lost (invariant #5)', async () => {
-    // Two patches firing concurrently each read-merge-write the same file.
-    // Without the mutex the later writer clobbers the earlier writer's field.
-    await Promise.all([
-      savePreferences({ model: 'a' }),
-      savePreferences({ mode: 'goal' }),
-    ]);
-    const loaded = await loadPreferences();
-    expect(loaded.model).toBe('a');
-    expect(loaded.mode).toBe('goal');
-  });
-
-  it('swallows a write failure: logs to stderr but never throws (best-effort contract)', async () => {
-    // savePreferences is documented best-effort — a persist failure must NOT
-    // bubble out and break the slash-command / shutdown that triggered it. Force
-    // an unwritable target by pointing MOXXY_HOME *under a regular file*, so the
-    // atomic writer's `mkdir(dirname)` fails with ENOTDIR.
-    const blocker = path.join(tmpHome, 'not-a-dir');
-    await fs.writeFile(blocker, 'x', 'utf8');
-    const prevMoxxyHome = process.env.MOXXY_HOME;
-    process.env.MOXXY_HOME = path.join(blocker, 'nested'); // dirname is a file → mkdir fails
-    const stderr = vi.spyOn(process.stderr, 'write').mockReturnValue(true);
-    try {
-      // Must resolve, not reject — the pick still took effect in-session.
-      await expect(savePreferences({ model: 'm' })).resolves.toBeUndefined();
-      // The failure is surfaced (not silently swallowed) on stderr.
-      expect(stderr).toHaveBeenCalled();
-    } finally {
-      stderr.mockRestore();
-      if (prevMoxxyHome === undefined) delete process.env.MOXXY_HOME;
-      else process.env.MOXXY_HOME = prevMoxxyHome;
-    }
-  });
-
-  it('keeps ALL distinct keys present under many overlapping writers', async () => {
-    const patches: Array<Partial<Record<`k${number}`, string>>> = [];
-    for (let i = 0; i < 25; i++) patches.push({ [`k${i}`]: `v${i}` });
-    // Fire all saves at once; each merges a distinct key.
-    await Promise.all(
-      patches.map((p) => savePreferences(p as Record<string, string>)),
-    );
-    const loaded = (await readRaw()) as Record<string, string>;
-    for (let i = 0; i < 25; i++) {
-      expect(loaded[`k${i}`]).toBe(`v${i}`);
-    }
-  });
-});

package/src/preferences.ts

@@ -1,85 +0,0 @@
-import { promises as fs } from 'node:fs';
-import { createMutex, migrateModeName } from '@moxxy/sdk';
-import { moxxyPath, writeFileAtomic } from '@moxxy/sdk/server';
-
-/**
- * User-level runtime preferences persisted at ~/.moxxy/preferences.json.
- * Distinct from `~/.moxxy/config.yaml` (user-edited, source of truth for
- * provider/plugin wiring) — this file is mutated by the TUI as the user
- * picks a model / loop strategy via slash commands, so it survives across
- * CLI invocations. A missing file or unreadable contents is a no-op:
- * preferences are best-effort, never load-blocking.
- */
-export interface MoxxyPreferences {
-  /** Active provider name (e.g. "openai", "anthropic"). */
-  readonly providerName?: string;
-  /** Active model id under that provider (e.g. "gpt-5.4-mini"). */
-  readonly model?: string;
-  /** Active loop strategy name (e.g. "default", "research", "goal"). */
-  readonly mode?: string;
-  /**
-   * Providers the user disabled (desktop Settings → Providers toggle).
-   * Seeded into the ProviderRegistry at boot; a listed provider stays
-   * registered but can't be activated until re-enabled.
-   */
-  readonly disabledProviders?: ReadonlyArray<string>;
-}
-
-export function preferencesPath(): string {
-  // Route through `moxxyPath` so a `$MOXXY_HOME` override relocates preferences
-  // alongside the rest of the data dir (config.yaml, vault, providers.json, …).
-  // Identical to `~/.moxxy/preferences.json` when MOXXY_HOME is unset.
-  return moxxyPath('preferences.json');
-}
-
-/**
- * Read preferences from disk. Returns an empty object when the file
- * doesn't exist or fails to parse — preferences are an optional layer,
- * never a hard dependency of session bootstrap.
- */
-export async function loadPreferences(): Promise<MoxxyPreferences> {
-  try {
-    const raw = await fs.readFile(preferencesPath(), 'utf8');
-    const parsed = JSON.parse(raw) as unknown;
-    if (parsed && typeof parsed === 'object') {
-      const prefs = parsed as MoxxyPreferences;
-      return prefs.mode ? { ...prefs, mode: migrateModeName(prefs.mode) } : prefs;
-    }
-    return {};
-  } catch {
-    return {};
-  }
-}
-
-// Serializes the read-modify-write in `savePreferences` so two concurrent
-// saves (e.g. a /model pick and a provider-disable toggle firing close
-// together) can't both read the same snapshot and have the second write
-// clobber the first's field. This is the single write path for the file —
-// other packages (CLI, runner, channels) route their fire-and-forget saves
-// through it, and any load-modify-save must go through it too.
-const writeMutex = createMutex();
-
-/**
- * Merge-and-write preferences. Reads the current file (if any), merges
- * the patch on top so we don't blow away unrelated fields, and writes
- * the result back atomically. The whole read-merge-write runs inside a
- * module-level mutex so overlapping saves serialize (invariant #5) and
- * never lose an update. Best-effort: a write failure logs to stderr but
- * does not throw — the user's pick still takes effect in this session,
- * just won't persist across invocations.
- */
-export async function savePreferences(patch: Partial<MoxxyPreferences>): Promise<void> {
-  return writeMutex.run(async () => {
-    const current = await loadPreferences();
-    const next: MoxxyPreferences = { ...current, ...patch };
-    const target = preferencesPath();
-    try {
-      await writeFileAtomic(target, JSON.stringify(next, null, 2) + '\n');
-    } catch (err) {
-      process.stderr.write(
-        `moxxy: failed to persist preferences to ${target}: ` +
-          `${err instanceof Error ? err.message : String(err)}\n`,
-      );
-    }
-  });
-}