@mseep/claudian 2.0.25

package/tests/unit/providers/pi/runtime/PiRpcTransport.test.ts

@@ -0,0 +1,116 @@
+import { PassThrough } from 'node:stream';
+
+import {
+  PiRpcResponseError,
+  PiRpcTransport,
+  PiRpcTransportClosedError,
+} from '@/providers/pi/runtime/PiRpcTransport';
+
+function createTransport() {
+  const input = new PassThrough();
+  const output = new PassThrough();
+  const writes: string[] = [];
+  output.on('data', chunk => writes.push(chunk.toString('utf8')));
+  const transport = new PiRpcTransport({ input, output }, 100);
+  transport.start();
+  return { input, output, transport, writes };
+}
+
+describe('PiRpcTransport', () => {
+  afterEach(() => {
+    jest.useRealTimers();
+  });
+
+  it('writes command requests with string ids', async () => {
+    const { input, transport, writes } = createTransport();
+    const promise = transport.request('get_state', { foo: 'bar' });
+
+    expect(JSON.parse(writes[0]) as unknown).toEqual({
+      foo: 'bar',
+      id: 'req_1',
+      type: 'get_state',
+    });
+
+    input.write('{"type":"response","id":"req_1","success":true,"result":{"ok":true}}\n');
+    await expect(promise).resolves.toEqual({ ok: true });
+  });
+
+  it('sends fire-and-forget records without pending request tracking', () => {
+    const { transport, writes } = createTransport();
+
+    transport.send({ id: 'ui-1', type: 'extension_ui_response', value: 'ok' });
+
+    expect(JSON.parse(writes[0]) as unknown).toEqual({
+      id: 'ui-1',
+      type: 'extension_ui_response',
+      value: 'ok',
+    });
+  });
+
+  it('resolves concurrent requests by id out of order', async () => {
+    const { input, transport } = createTransport();
+    const first = transport.request('first');
+    const second = transport.request('second');
+
+    input.write('{"type":"response","id":"req_2","success":true,"result":2}\n');
+    input.write('{"type":"response","id":"req_1","success":true,"result":1}\n');
+
+    await expect(second).resolves.toBe(2);
+    await expect(first).resolves.toBe(1);
+  });
+
+  it('unwraps Pi response data when result is absent', async () => {
+    const { input, transport } = createTransport();
+    const promise = transport.request('get_available_models');
+
+    input.write('{"type":"response","id":"req_1","success":true,"data":{"models":[{"id":"gpt-5"}]}}\n');
+
+    await expect(promise).resolves.toEqual({ models: [{ id: 'gpt-5' }] });
+  });
+
+  it('routes non-response events to listeners', () => {
+    const { input, transport } = createTransport();
+    const events: unknown[] = [];
+    transport.onEvent(event => events.push(event));
+
+    input.write('{"type":"message_update","delta":"hi"}\n');
+
+    expect(events).toEqual([{ type: 'message_update', delta: 'hi' }]);
+  });
+
+  it('ignores malformed JSON records without failing pending requests', async () => {
+    const { input, transport } = createTransport();
+    const promise = transport.request('prompt');
+
+    input.write('not-json\n');
+    input.write('{"type":"response","id":"req_1","success":true,"result":{"accepted":true}}\n');
+
+    await expect(promise).resolves.toEqual({ accepted: true });
+  });
+
+  it('rejects failed responses and pending requests on dispose', async () => {
+    const { input, transport } = createTransport();
+    const failed = transport.request('prompt');
+    input.write('{"type":"response","id":"req_1","success":false,"error":"boom"}\n');
+
+    await expect(failed).rejects.toBeInstanceOf(PiRpcResponseError);
+
+    const pending = transport.request('prompt');
+    transport.dispose();
+    await expect(pending).rejects.toBeInstanceOf(PiRpcTransportClosedError);
+  });
+
+  it('rejects timed-out requests and removes them from the pending set', async () => {
+    jest.useFakeTimers();
+    const { input, transport } = createTransport();
+    const timedOut = transport.request('prompt', {}, 100);
+
+    jest.advanceTimersByTime(100);
+    await expect(timedOut).rejects.toThrow('Request timeout: prompt');
+
+    input.write('{"type":"response","id":"req_1","success":true,"result":"late"}\n');
+    const next = transport.request('get_state', {}, 100);
+    input.write('{"type":"response","id":"req_2","success":true,"result":{"ok":true}}\n');
+    await expect(next).resolves.toEqual({ ok: true });
+  });
+});

package/tests/unit/providers/pi/runtime/PiSubprocess.test.ts

@@ -0,0 +1,151 @@
+import { EventEmitter } from 'node:events';
+import { Readable, Writable } from 'node:stream';
+
+jest.mock('node:child_process', () => ({
+  spawn: jest.fn(),
+}));
+
+import { spawn } from 'node:child_process';
+
+import { PiSubprocess } from '@/providers/pi/runtime/PiSubprocess';
+
+const mockSpawn = spawn as jest.MockedFunction<typeof spawn>;
+
+function createMockProcess(): any {
+  const proc = new EventEmitter() as any;
+  proc.stdin = new Writable({ write: (_chunk, _encoding, callback) => callback() });
+  proc.stdout = new Readable({ read() {} });
+  proc.stderr = new Readable({ read() {} });
+  proc.exitCode = null;
+  proc.killed = false;
+  proc.pid = 12345;
+  proc.kill = jest.fn((signal?: string) => {
+    proc.killed = signal === 'SIGKILL';
+    return true;
+  });
+  return proc;
+}
+
+describe('PiSubprocess', () => {
+  const originalPlatform = process.platform;
+  let proc: any;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    proc = createMockProcess();
+    mockSpawn.mockReturnValue(proc);
+  });
+
+  afterEach(() => {
+    Object.defineProperty(process, 'platform', { value: originalPlatform });
+    jest.useRealTimers();
+  });
+
+  it('spawns Pi RPC with the launch spec args, cwd, stdio, and enhanced PATH', () => {
+    const subprocess = new PiSubprocess({
+      args: ['--mode', 'rpc'],
+      command: '/opt/pi/bin/pi',
+      cwd: '/vault',
+      env: { PATH: '/usr/bin' },
+    });
+
+    subprocess.start();
+
+    expect(mockSpawn).toHaveBeenCalledWith('/opt/pi/bin/pi', ['--mode', 'rpc'], expect.objectContaining({
+      cwd: '/vault',
+      stdio: 'pipe',
+      windowsHide: true,
+      env: expect.objectContaining({
+        PATH: expect.stringContaining('/usr/bin'),
+      }),
+    }));
+  });
+
+  it('wraps Windows .cmd shims through cmd.exe', () => {
+    Object.defineProperty(process, 'platform', { value: 'win32' });
+    const subprocess = new PiSubprocess({
+      args: ['--mode', 'rpc', '--system-prompt', 'Use R&D policy'],
+      command: 'C:\\Users\\R&D\\AppData\\Roaming\\npm\\pi.cmd',
+      cwd: 'C:\\Vault',
+      env: { PATH: 'C:\\Windows\\System32' },
+    });
+
+    subprocess.start();
+
+    expect(mockSpawn).toHaveBeenCalledWith(
+      process.env.ComSpec || process.env.comspec || 'cmd.exe',
+      ['/d', '/s', '/c', '""C:\\Users\\R&D\\AppData\\Roaming\\npm\\pi.cmd" --mode rpc --system-prompt "Use R&D policy""'],
+      expect.objectContaining({
+        cwd: 'C:\\Vault',
+        windowsHide: true,
+        windowsVerbatimArguments: true,
+      }),
+    );
+  });
+
+  it('kills the process tree when shutting down Windows .cmd shims', async () => {
+    Object.defineProperty(process, 'platform', { value: 'win32' });
+    const subprocess = new PiSubprocess({
+      args: ['--mode', 'rpc'],
+      command: 'C:\\Users\\R&D\\AppData\\Roaming\\npm\\pi.cmd',
+      cwd: 'C:\\Vault',
+      env: { PATH: 'C:\\Windows\\System32' },
+    });
+    subprocess.start();
+
+    const shutdown = subprocess.shutdown();
+
+    expect(mockSpawn).toHaveBeenCalledWith(
+      'taskkill.exe',
+      ['/pid', '12345', '/t', '/f'],
+      expect.objectContaining({
+        stdio: 'ignore',
+        windowsHide: true,
+      }),
+    );
+    expect(proc.kill).not.toHaveBeenCalled();
+
+    proc.exitCode = 0;
+    proc.emit('exit', 0, null);
+    await shutdown;
+  });
+
+  it('keeps a bounded stderr snapshot for runtime errors', () => {
+    const subprocess = new PiSubprocess({
+      args: ['--mode', 'rpc'],
+      command: 'pi',
+      cwd: '/vault',
+      env: {},
+    });
+    subprocess.start();
+
+    proc.stderr.emit('data', 'a'.repeat(9_000));
+
+    expect(subprocess.getStderrSnapshot()).toHaveLength(8_000);
+  });
+
+  it('notifies close listeners and escalates shutdown after timeout', async () => {
+    jest.useFakeTimers();
+    const subprocess = new PiSubprocess({
+      args: ['--mode', 'rpc'],
+      command: 'pi',
+      cwd: '/vault',
+      env: {},
+    });
+    const onClose = jest.fn();
+    subprocess.onClose(onClose);
+    subprocess.start();
+
+    const shutdown = subprocess.shutdown();
+    expect(proc.kill).toHaveBeenCalledWith('SIGTERM');
+
+    jest.advanceTimersByTime(3_000);
+    expect(proc.kill).toHaveBeenCalledWith('SIGKILL');
+
+    proc.exitCode = 1;
+    proc.emit('exit', 1, 'SIGKILL');
+    await shutdown;
+
+    expect(onClose).toHaveBeenCalledWith(expect.any(Error));
+  });
+});

package/tests/unit/providers/pi/runtime/buildPiPrompt.test.ts

@@ -0,0 +1,84 @@
+import {
+  buildPiPromptImages,
+  buildPiPromptText,
+} from '@/providers/pi/runtime/buildPiPrompt';
+
+describe('buildPiPrompt', () => {
+  it('appends provider-neutral note and selection context without embedding images', () => {
+    const prompt = buildPiPromptText({
+      browserSelection: {
+        selectedText: 'Browser text',
+        source: 'browser',
+        title: 'Docs',
+        url: 'https://example.com',
+      },
+      canvasSelection: {
+        canvasPath: 'Board.canvas',
+        nodeIds: ['node-a', 'node-b'],
+      },
+      currentNotePath: 'Notes/today.md',
+      editorSelection: {
+        lineCount: 2,
+        mode: 'selection',
+        notePath: 'Notes/today.md',
+        selectedText: 'Selected text',
+        startLine: 4,
+      },
+      images: [{
+        data: 'base64-image',
+        id: 'image-1',
+        mediaType: 'image/png',
+        name: 'image.png',
+        size: 12,
+        source: 'paste',
+      }],
+      text: 'Summarize this',
+    });
+
+    expect(prompt).toContain('Summarize this');
+    expect(prompt).toContain('<current_note>\nNotes/today.md\n</current_note>');
+    expect(prompt).toContain('<editor_selection path="Notes/today.md" lines="4-5">\nSelected text\n</editor_selection>');
+    expect(prompt).toContain('<browser_selection source="browser" title="Docs" url="https://example.com">\nBrowser text\n</browser_selection>');
+    expect(prompt).toContain('<canvas_selection path="Board.canvas">\nnode-a, node-b\n</canvas_selection>');
+    expect(prompt).not.toContain('base64-image');
+  });
+
+  it('uses history context only when conversation history is supplied', () => {
+    const withoutHistory = buildPiPromptText({ text: 'Continue' });
+    const withHistory = buildPiPromptText({ text: 'Continue' }, [
+      {
+        content: 'Earlier request',
+        id: 'm1',
+        role: 'user',
+        timestamp: 1,
+      },
+    ]);
+
+    expect(withoutHistory).toBe('Continue');
+    expect(withHistory).toContain('Earlier request');
+    expect(withHistory).toContain('Continue');
+  });
+
+  it('maps image attachments separately for Pi RPC payloads', () => {
+    expect(buildPiPromptImages([
+      {
+        data: 'image-a',
+        id: 'image-a',
+        mediaType: 'image/png',
+        name: 'a.png',
+        size: 12,
+        source: 'paste',
+      },
+      {
+        data: '',
+        id: 'image-b',
+        mediaType: 'image/jpeg',
+        name: 'b.jpg',
+        size: 12,
+        source: 'paste',
+      },
+    ])).toEqual([
+      { data: 'image-a', mimeType: 'image/png', type: 'image' },
+    ]);
+  });
+});

package/tests/unit/providers/pi/runtime/buildPiUsageInfo.test.ts

@@ -0,0 +1,69 @@
+import { buildPiUsageInfo } from '@/providers/pi/runtime/buildPiUsageInfo';
+
+describe('buildPiUsageInfo', () => {
+  it('normalizes fractional provider percentages to whole context-meter percentages', () => {
+    const usage = buildPiUsageInfo({
+      contextUsage: {
+        contextTokens: 24_691,
+        contextWindow: 200_000,
+        inputTokens: 1200,
+        percentage: 0.123456789,
+      },
+    }, 'pi:openai/gpt-5');
+
+    expect(usage?.percentage).toBe(12);
+  });
+
+  it('preserves provider percentages that are already whole percent values', () => {
+    const usage = buildPiUsageInfo({
+      context_usage: {
+        context_tokens: 50_000,
+        context_window: 200_000,
+        input_tokens: 1200,
+        percentage: 25,
+      },
+    }, null);
+
+    expect(usage?.percentage).toBe(25);
+  });
+
+  it('rounds provider percentage decimals when they are already percent values', () => {
+    const usage = buildPiUsageInfo({
+      contextUsage: {
+        contextTokens: 24_691,
+        contextWindow: 200_000,
+        inputTokens: 1200,
+        percentage: 12.3456789,
+      },
+    }, null);
+
+    expect(usage?.percentage).toBe(12);
+  });
+
+  it('rounds derived percentages to match the shared context meter contract', () => {
+    const usage = buildPiUsageInfo({
+      contextUsage: {
+        contextTokens: 11_830,
+        contextWindow: 200_000,
+        inputTokens: 38,
+      },
+    }, null);
+
+    expect(usage?.percentage).toBe(6);
+  });
+
+  it('uses a fallback context window without marking it provider-authoritative', () => {
+    const usage = buildPiUsageInfo({
+      contextUsage: {
+        contextTokens: 50_000,
+        inputTokens: 1200,
+      },
+    }, 'pi:anthropic/claude-sonnet-4', 1_000_000);
+
+    expect(usage).toMatchObject({
+      contextWindow: 1_000_000,
+      contextWindowIsAuthoritative: false,
+      percentage: 5,
+    });
+  });
+});

package/tests/unit/providers/pi/settings.test.ts

@@ -0,0 +1,253 @@
+const mockGetHostnameKey = jest.fn(() => 'host-a');
+const mockGetLegacyHostnameKey = jest.fn(() => 'legacy-host');
+
+jest.mock('../../../../src/utils/env', () => ({
+  ...jest.requireActual('../../../../src/utils/env'),
+  getHostnameKey: () => mockGetHostnameKey(),
+  getLegacyHostnameKey: () => mockGetLegacyHostnameKey(),
+}));
+
+import { piSettingsReconciler } from '@/providers/pi/env/PiSettingsReconciler';
+import {
+  DEFAULT_PI_PROVIDER_SETTINGS,
+  getPiProviderSettings,
+  normalizePiModelAliases,
+  normalizePiPreferredThinkingByModel,
+  normalizePiVisibleModels,
+  updatePiProviderSettings,
+} from '@/providers/pi/settings';
+
+describe('Pi settings normalization', () => {
+  const discoveredModels = [
+    {
+      encodedId: 'pi:anthropic/claude-sonnet-4',
+      id: 'claude-sonnet-4',
+      input: ['text' as const],
+      label: 'Claude Sonnet 4',
+      provider: 'anthropic',
+      reasoning: true,
+      thinkingLevels: ['off' as const, 'medium' as const, 'high' as const],
+    },
+    {
+      encodedId: 'pi:openai/gpt-5',
+      id: 'gpt-5',
+      input: ['text' as const, 'image' as const],
+      label: 'GPT-5',
+      provider: 'openai',
+      reasoning: true,
+      thinkingLevels: ['off' as const, 'low' as const, 'medium' as const],
+    },
+  ];
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    mockGetHostnameKey.mockReturnValue('host-a');
+    mockGetLegacyHostnameKey.mockReturnValue('legacy-host');
+  });
+
+  it('defaults Pi to disabled all-tools mode', () => {
+    expect(DEFAULT_PI_PROVIDER_SETTINGS).toMatchObject({
+      enabled: false,
+      toolMode: 'all',
+      visibleModels: [],
+    });
+  });
+
+  it('migrates current legacy hostname-scoped CLI paths', () => {
+    mockGetHostnameKey.mockReturnValue('device:current');
+    mockGetLegacyHostnameKey.mockReturnValue('host-a');
+
+    expect(getPiProviderSettings({
+      providerConfigs: {
+        pi: {
+          cliPathsByHost: {
+            'host-a': '/host-a/pi',
+            'host-b': '/host-b/pi',
+          },
+        },
+      },
+    }).cliPathsByHost).toEqual({
+      'device:current': '/host-a/pi',
+      'host-b': '/host-b/pi',
+    });
+  });
+
+  it('normalizes visible models to valid encoded ids', () => {
+    expect(normalizePiVisibleModels([
+      'pi:anthropic/claude-sonnet-4',
+      'pi:anthropic/claude-sonnet-4',
+      'pi:missing/model',
+      'openai/gpt-5',
+    ], discoveredModels)).toEqual(['pi:anthropic/claude-sonnet-4']);
+  });
+
+  it('normalizes aliases and preferred thinking', () => {
+    expect(normalizePiModelAliases({
+      'pi:anthropic/claude-sonnet-4': '  Sonnet  ',
+      'pi:missing/model': 'Missing',
+    }, discoveredModels)).toEqual({
+      'pi:anthropic/claude-sonnet-4': 'Sonnet',
+    });
+    expect(normalizePiPreferredThinkingByModel({
+      'pi:anthropic/claude-sonnet-4': 'high',
+      'pi:openai/gpt-5': 'xhigh',
+    }, discoveredModels)).toEqual({
+      'pi:anthropic/claude-sonnet-4': 'high',
+    });
+  });
+
+  it('keeps selected model metadata even when the selected model is no longer discovered', () => {
+    const settings: Record<string, unknown> = {
+      model: 'pi:old-provider/old-model',
+      providerConfigs: {
+        pi: {
+          discoveredModels,
+          modelAliases: {
+            'pi:old-provider/old-model': 'Legacy model',
+            'pi:missing/model': 'Missing',
+          },
+          preferredThinkingByModel: {
+            'pi:old-provider/old-model': 'high',
+            'pi:missing/model': 'low',
+          },
+          visibleModels: ['pi:anthropic/claude-sonnet-4'],
+        },
+      },
+      savedProviderModel: {},
+      titleGenerationModel: '',
+    };
+
+    expect(getPiProviderSettings(settings).modelAliases).toEqual({
+      'pi:old-provider/old-model': 'Legacy model',
+    });
+    expect(getPiProviderSettings(settings).preferredThinkingByModel).toEqual({
+      'pi:old-provider/old-model': 'high',
+    });
+  });
+
+  it('preserves selected model metadata during model variant reconciliation when discovery is stale', () => {
+    const settings: Record<string, unknown> = {
+      model: 'pi:old-provider/old-model',
+      providerConfigs: {
+        pi: {
+          discoveredModels,
+          modelAliases: {
+            'pi:old-provider/old-model': 'Legacy model',
+          },
+          preferredThinkingByModel: {
+            'pi:old-provider/old-model': 'high',
+          },
+          visibleModels: ['pi:anthropic/claude-sonnet-4'],
+        },
+      },
+      savedProviderModel: {},
+      titleGenerationModel: '',
+    };
+
+    expect(piSettingsReconciler.normalizeModelVariantSettings(settings)).toBe(false);
+    expect(getPiProviderSettings(settings).modelAliases).toEqual({
+      'pi:old-provider/old-model': 'Legacy model',
+    });
+    expect(getPiProviderSettings(settings).preferredThinkingByModel).toEqual({
+      'pi:old-provider/old-model': 'high',
+    });
+  });
+
+  it('retargets active and saved Pi selections when visible models change', () => {
+    const settings: Record<string, unknown> = {
+      effortLevel: 'high',
+      model: 'pi:openai/gpt-5',
+      providerConfigs: {
+        pi: {
+          discoveredModels,
+          preferredThinkingByModel: {
+            'pi:anthropic/claude-sonnet-4': 'high',
+          },
+          visibleModels: ['pi:openai/gpt-5', 'pi:anthropic/claude-sonnet-4'],
+        },
+      },
+      savedProviderEffort: {
+        pi: 'medium',
+      },
+      savedProviderModel: {
+        pi: 'pi:openai/gpt-5',
+      },
+      titleGenerationModel: 'pi:openai/gpt-5',
+    };
+
+    updatePiProviderSettings(settings, {
+      visibleModels: ['pi:anthropic/claude-sonnet-4'],
+    });
+
+    expect(settings.model).toBe('pi:anthropic/claude-sonnet-4');
+    expect(settings.effortLevel).toBe('high');
+    expect((settings.savedProviderModel as Record<string, string>).pi).toBe('pi:anthropic/claude-sonnet-4');
+    expect((settings.savedProviderEffort as Record<string, string>).pi).toBe('high');
+    expect(settings.titleGenerationModel).toBe('pi:anthropic/claude-sonnet-4');
+  });
+
+  it('clears the Pi title model when all visible models are removed', () => {
+    const settings: Record<string, unknown> = {
+      providerConfigs: {
+        pi: {
+          discoveredModels,
+          visibleModels: ['pi:openai/gpt-5'],
+        },
+      },
+      titleGenerationModel: 'pi:openai/gpt-5',
+    };
+
+    updatePiProviderSettings(settings, { visibleModels: [] });
+
+    expect(settings.titleGenerationModel).toBe('');
+  });
+
+  it('clears stale discovery metadata on environment change without dropping visible model choices', () => {
+    const settings: Record<string, unknown> = {
+      providerConfigs: {
+        pi: {
+          discoveredModels,
+          visibleModels: ['pi:anthropic/claude-sonnet-4'],
+        },
+      },
+    };
+
+    expect(piSettingsReconciler.handleEnvironmentChange?.(settings)).toBe(true);
+
+    expect(getPiProviderSettings(settings).discoveredModels).toEqual([]);
+    expect(getPiProviderSettings(settings).visibleModels).toEqual(['pi:anthropic/claude-sonnet-4']);
+  });
+
+  it('normalizes blank Pi effort to a value supported by the selected model', () => {
+    const nonReasoningSettings: Record<string, unknown> = {
+      effortLevel: '',
+      model: 'pi:openai/gpt-5',
+      providerConfigs: {
+        pi: {
+          discoveredModels: [{
+            encodedId: 'pi:openai/gpt-5',
+            id: 'gpt-5',
+            input: ['text'],
+            label: 'GPT-5',
+            provider: 'openai',
+            reasoning: false,
+            thinkingLevels: ['off'],
+          }],
+          visibleModels: ['pi:openai/gpt-5'],
+        },
+      },
+    };
+
+    expect(piSettingsReconciler.normalizeModelVariantSettings(nonReasoningSettings)).toBe(true);
+    expect(nonReasoningSettings.effortLevel).toBe('off');
+
+    const fallbackSettings: Record<string, unknown> = {
+      effortLevel: '',
+      model: 'pi',
+      providerConfigs: { pi: {} },
+    };
+
+    expect(piSettingsReconciler.normalizeModelVariantSettings(fallbackSettings)).toBe(true);
+    expect(fallbackSettings.effortLevel).toBe('off');
+  });
+});