@geminilight/mindos 0.6.76 → 0.6.78

package/_standalone/__tests__/ask/ask-content-agent-capsule-visibility.test.tsx

@@ -0,0 +1,195 @@
+// @vitest-environment jsdom
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import React, { act } from 'react';
+import { createRoot } from 'react-dom/client';
+import AskContent from '@/components/ask/AskContent';
+
+const mockInstalledAgents: Array<{ id: string; name: string; binaryPath: string }> = [];
+
+vi.mock('@/lib/stores/locale-store', () => ({
+  useLocale: () => ({
+    t: {
+      ask: {
+        title: 'MindOS',
+        placeholder: 'Ask a question...',
+        send: 'send',
+        newlineHint: 'new line',
+        panelComposerResize: 'Resize input',
+        panelComposerResetHint: 'Double click reset',
+        panelComposerKeyboard: 'Arrow keys',
+        attachFile: 'attach file',
+        attachFileLabel: 'Document',
+        attachImageLabel: 'Image',
+        stopTitle: 'Stop',
+        cancelReconnect: 'Cancel reconnect',
+        connecting: 'connecting',
+        thinking: 'thinking',
+        generating: 'generating',
+        reconnecting: (attempt: number, max: number) => `retry ${attempt}/${max}`,
+        stopped: 'stopped',
+        errorNoResponse: 'no response',
+        emptyPrompt: 'empty',
+        suggestions: [],
+        copyMessage: 'Copy',
+      },
+      search: { close: 'close' },
+      hints: {
+        typeMessage: 'Type a message',
+        mentionInProgress: 'Mention or command in progress',
+        sessionHistory: 'Session history',
+        newSession: 'New session',
+        attachFile: 'Attach local file',
+        maximizePanel: 'Maximize panel',
+        restorePanel: 'Restore panel',
+        dockToSide: 'Dock to side panel',
+        openAsPopup: 'Open as popup',
+        closePanel: 'Close',
+      },
+      fileImport: { unsupported: 'Unsupported file type' },
+      panels: { agents: { acpDefaultAgent: 'MindOS' } },
+    },
+  }),
+}));
+
+vi.mock('@/hooks/useAskSession', () => ({
+  useAskSession: () => ({
+    messages: [],
+    sessions: [],
+    activeSession: null,
+    activeSessionId: 's1',
+    initSessions: vi.fn(),
+    persistSession: vi.fn(),
+    clearPersistTimer: vi.fn(),
+    setMessages: vi.fn(),
+    setSessionDefaultAcpAgent: vi.fn(),
+    resetSession: vi.fn(),
+    loadSession: vi.fn(),
+    deleteSession: vi.fn(),
+    renameSession: vi.fn(),
+    togglePinSession: vi.fn(),
+    clearAllSessions: vi.fn(),
+  }),
+}));
+
+vi.mock('@/hooks/useFileUpload', () => ({
+  useFileUpload: () => ({
+    localAttachments: [],
+    uploadError: '',
+    uploadInputRef: { current: null },
+    clearAttachments: vi.fn(),
+    removeAttachment: vi.fn(),
+    pickFiles: vi.fn(),
+    injectFiles: vi.fn(),
+  }),
+}));
+
+vi.mock('@/hooks/useImageUpload', () => ({
+  useImageUpload: () => ({
+    images: [],
+    imageError: '',
+    clearImages: vi.fn(),
+    removeImage: vi.fn(),
+    handlePaste: vi.fn(),
+    handleDrop: vi.fn(),
+    handleFileSelect: vi.fn(),
+    addImages: vi.fn(),
+  }),
+}));
+
+vi.mock('@/hooks/useMention', () => ({
+  useMention: () => ({
+    mentionQuery: null,
+    mentionResults: [],
+    mentionIndex: 0,
+    resetMention: vi.fn(),
+    updateMentionFromInput: vi.fn(),
+    navigateMention: vi.fn(),
+  }),
+}));
+
+vi.mock('@/hooks/useSlashCommand', () => ({
+  useSlashCommand: () => ({
+    slashQuery: null,
+    slashResults: [],
+    slashIndex: 0,
+    resetSlash: vi.fn(),
+    updateSlashFromInput: vi.fn(),
+    navigateSlash: vi.fn(),
+  }),
+}));
+
+vi.mock('@/hooks/useAcpDetection', () => ({
+  useAcpDetection: () => ({
+    installedAgents: mockInstalledAgents,
+    notInstalledAgents: [],
+    loading: false,
+    error: null,
+    refresh: vi.fn(),
+  }),
+}));
+
+vi.mock('@/hooks/useAskChat', () => ({
+  useAskChat: () => ({
+    isLoading: false,
+    isLoadingRef: { current: false },
+    loadingPhase: 'connecting',
+    reconnectAttempt: 0,
+    reconnectMaxRef: { current: 3 },
+    abortRef: { current: null },
+    firstMessageFired: { current: false },
+    submit: (e: Event) => e.preventDefault(),
+    stop: vi.fn(),
+  }),
+}));
+
+vi.mock('@/components/ask/MessageList', () => ({ default: () => <div /> }));
+vi.mock('@/components/ask/MentionPopover', () => ({ default: () => null }));
+vi.mock('@/components/ask/SlashCommandPopover', () => ({ default: () => null }));
+vi.mock('@/components/ask/SessionHistory', () => ({ default: () => null }));
+vi.mock('@/components/ask/SessionHistoryPanel', () => ({ default: () => null }));
+vi.mock('@/components/ask/AskHeader', () => ({ default: () => <div /> }));
+vi.mock('@/components/ask/FileChip', () => ({ default: () => null }));
+vi.mock('@/components/ask/ModeCapsule', () => ({
+  default: () => <div data-testid="mode-capsule">mode</div>,
+  getPersistedMode: () => 'agent',
+}));
+vi.mock('@/components/ask/ProviderModelCapsule', () => ({
+  default: () => <div data-testid="provider-capsule">provider</div>,
+  getPersistedProviderModel: () => ({ provider: null, model: null }),
+}));
+vi.mock('@/components/ask/AgentSelectorCapsule', () => ({
+  default: ({ selectedAgent }: { selectedAgent: { id: string; name: string } | null }) => (
+    <div data-testid="agent-selector">{selectedAgent?.name ?? 'MindOS'}</div>
+  ),
+}));
+vi.mock('@/lib/utils', () => ({ cn: (...parts: Array<string | false | null | undefined>) => parts.filter(Boolean).join(' ') }));
+
+describe('AskContent agent selector capsule visibility', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockInstalledAgents.length = 0;
+    (globalThis as any).IS_REACT_ACT_ENVIRONMENT = true;
+  });
+
+  it('keeps the agent selector capsule visible in panel mode even with no detected ACP agents', async () => {
+    const host = document.createElement('div');
+    document.body.appendChild(host);
+    const root = createRoot(host);
+
+    await act(async () => {
+      root.render(<AskContent visible variant="panel" />);
+    });
+
+    await act(async () => {
+      await Promise.resolve();
+    });
+
+    expect(host.querySelector('[data-testid="mode-capsule"]')).toBeTruthy();
+    expect(host.querySelector('[data-testid="provider-capsule"]')).toBeTruthy();
+    expect(host.querySelector('[data-testid="agent-selector"]')?.textContent).toBe('MindOS');
+
+    await act(async () => {
+      root.unmount();
+    });
+  });
+});

package/_standalone/__tests__/ask/ask-content-input-during-run.test.tsx

@@ -198,7 +198,7 @@ describe('AskContent input behavior while running', () => {
     const submitButton = host.querySelector('button[type="submit"]') as HTMLButtonElement;
     expect(submitButton.disabled).toBe(true);
     expect(submitButton.title).toBe('Wait for uploaded files to finish processing before sending.');
-    expect(host.textContent).toContain('Wait for uploaded files to finish processing before sending.');
+    expect(host.textContent).not.toContain('Wait for uploaded files to finish processing before sending.');
 
     const form = host.querySelector('form') as HTMLFormElement;
     await act(async () => {

package/_standalone/__tests__/fixtures/obsidian-community-fixtures.ts

@@ -0,0 +1,92 @@
+export interface ObsidianCommunityFixture {
+  pluginId: string;
+  displayName: string;
+  source: string;
+  code: string;
+  styles?: string;
+  expectedCompatibilityLevel: 'compatible' | 'partial' | 'blocked';
+}
+
+export const OBSIDIAN_COMMUNITY_FIXTURES: ObsidianCommunityFixture[] = [
+  {
+    pluginId: 'style-settings-like',
+    displayName: 'Style Settings-like',
+    source: 'https://github.com/obsidian-community/obsidian-style-settings',
+    expectedCompatibilityLevel: 'compatible',
+    styles: '.theme-accent { color: var(--amber); }',
+    code: `
+      const { Plugin, PluginSettingTab, Setting } = require('obsidian');
+      class StyleSettingsTab extends PluginSettingTab {
+        display() {
+          new Setting(this)
+            .setName('Theme accent')
+            .addDropdown((dropdown) => dropdown.addOption('amber', 'Amber').setValue('amber'));
+        }
+      }
+      module.exports = class StyleSettingsLike extends Plugin {
+        onload() {
+          this.addSettingTab(new StyleSettingsTab(this.app));
+        }
+      };
+    `,
+  },
+  {
+    pluginId: 'quickadd-like',
+    displayName: 'QuickAdd-like',
+    source: 'https://publish.obsidian.md/quickadd/ManualInstallation',
+    expectedCompatibilityLevel: 'compatible',
+    code: `
+      const { Plugin, Modal, Notice } = require('obsidian');
+      class CaptureModal extends Modal {}
+      module.exports = class QuickAddLike extends Plugin {
+        async onload() {
+          await this.saveData({ macros: [] });
+          this.addCommand({
+            id: 'capture',
+            name: 'Capture',
+            callback: () => new Notice('captured')
+          });
+        }
+      };
+    `,
+  },
+  {
+    pluginId: 'tag-wrangler-like',
+    displayName: 'Tag Wrangler-like',
+    source: 'https://publish.obsidian.md/hub/02+-+Community+Expansions/02.05+All+Community+Expansions/Plugins/tag-wrangler',
+    expectedCompatibilityLevel: 'compatible',
+    code: `
+      const { Plugin, Notice } = require('obsidian');
+      module.exports = class TagWranglerLike extends Plugin {
+        onload() {
+          this.addCommand({
+            id: 'rename-tag',
+            name: 'Rename Tag',
+            callback: () => {
+              this.app.metadataCache.getCache('notes/example.md');
+              new Notice('renamed');
+            }
+          });
+        }
+      };
+    `,
+  },
+  {
+    pluginId: 'homepage-like',
+    displayName: 'Homepage-like',
+    source: 'https://www.obsidianstats.com/plugins/homepage',
+    expectedCompatibilityLevel: 'compatible',
+    code: `
+      const { Plugin } = require('obsidian');
+      module.exports = class HomepageLike extends Plugin {
+        onload() {
+          this.addCommand({
+            id: 'open-homepage',
+            name: 'Open Homepage',
+            callback: () => this.app.workspace.openLinkText('Home', '')
+          });
+        }
+      };
+    `,
+  },
+];

package/_standalone/__tests__/obsidian-compat/community-smoke.test.ts

@@ -0,0 +1,62 @@
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { analyzePluginCompatibility, getCompatibilityLevel } from '@/lib/obsidian-compat/compatibility-report';
+import { PluginManager } from '@/lib/obsidian-compat/plugin-manager';
+import { OBSIDIAN_COMMUNITY_FIXTURES } from '../fixtures/obsidian-community-fixtures';
+
+let mindRoot: string;
+
+function writePlugin(pluginId: string, mainJs: string, styles?: string) {
+  const pluginDir = path.join(mindRoot, '.plugins', pluginId);
+  fs.mkdirSync(pluginDir, { recursive: true });
+  fs.writeFileSync(
+    path.join(pluginDir, 'manifest.json'),
+    JSON.stringify({ id: pluginId, name: pluginId, version: '1.0.0' }, null, 2),
+    'utf-8',
+  );
+  fs.writeFileSync(path.join(pluginDir, 'main.js'), mainJs, 'utf-8');
+  if (styles) {
+    fs.writeFileSync(path.join(pluginDir, 'styles.css'), styles, 'utf-8');
+  }
+}
+
+describe('community plugin smoke suite', () => {
+  beforeEach(() => {
+    mindRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'mindos-obsidian-community-'));
+  });
+
+  afterEach(() => {
+    fs.rmSync(mindRoot, { recursive: true, force: true });
+  });
+
+  for (const fixture of OBSIDIAN_COMMUNITY_FIXTURES) {
+    it(`classifies ${fixture.displayName} from ${fixture.source}`, async () => {
+      writePlugin(fixture.pluginId, fixture.code, fixture.styles);
+
+      const report = analyzePluginCompatibility(fixture.code);
+      expect(getCompatibilityLevel(report)).toBe(fixture.expectedCompatibilityLevel);
+
+      const manager = new PluginManager(mindRoot);
+      const plugins = await manager.discover();
+      const plugin = plugins.find((item) => item.id === fixture.pluginId);
+      expect(plugin).toMatchObject({ id: fixture.pluginId, compatibilityLevel: fixture.expectedCompatibilityLevel });
+    });
+  }
+
+  it('loads the QuickAdd-like fixture successfully', async () => {
+    const fixture = OBSIDIAN_COMMUNITY_FIXTURES.find((item) => item.pluginId === 'quickadd-like');
+    if (!fixture) throw new Error('Missing quickadd-like fixture');
+
+    writePlugin(fixture.pluginId, fixture.code, fixture.styles);
+
+    const manager = new PluginManager(mindRoot);
+    await manager.discover();
+    await manager.enable(fixture.pluginId);
+    const result = await manager.loadEnabledPlugins();
+
+    expect(result.loaded).toEqual([fixture.pluginId]);
+    expect(manager.list()[0]).toMatchObject({ compatibilityLevel: 'compatible', loaded: true });
+  });
+});

package/_standalone/__tests__/obsidian-compat/obsidian-import.test.ts

@@ -0,0 +1,126 @@
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import {
+  importObsidianPlugin,
+  scanObsidianVaultPlugins,
+} from '@/lib/obsidian-compat/obsidian-import';
+
+let vaultRoot: string;
+let mindRoot: string;
+
+const writeVaultPlugin = (
+  pluginId: string,
+  mainJs: string,
+  options?: { styles?: string; data?: object; manifest?: Record<string, unknown> },
+) => {
+  const pluginDir = path.join(vaultRoot, '.obsidian', 'plugins', pluginId);
+  fs.mkdirSync(pluginDir, { recursive: true });
+  fs.writeFileSync(
+    path.join(pluginDir, 'manifest.json'),
+    JSON.stringify(options?.manifest ?? { id: pluginId, name: pluginId, version: '1.0.0' }, null, 2),
+    'utf-8',
+  );
+  fs.writeFileSync(path.join(pluginDir, 'main.js'), mainJs, 'utf-8');
+  if (options?.styles) {
+    fs.writeFileSync(path.join(pluginDir, 'styles.css'), options.styles, 'utf-8');
+  }
+  if (options?.data) {
+    fs.writeFileSync(path.join(pluginDir, 'data.json'), JSON.stringify(options.data, null, 2), 'utf-8');
+  }
+};
+
+describe('obsidian import scanner', () => {
+  beforeEach(() => {
+    vaultRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'mindos-obsidian-vault-source-'));
+    mindRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'mindos-obsidian-vault-target-'));
+  });
+
+  afterEach(() => {
+    fs.rmSync(vaultRoot, { recursive: true, force: true });
+    fs.rmSync(mindRoot, { recursive: true, force: true });
+  });
+
+  it('scans .obsidian/plugins and returns compatibility summaries', async () => {
+    writeVaultPlugin(
+      'quickadd-like',
+      `
+        const { Plugin, Modal, Notice } = require('obsidian');
+        module.exports = class QuickAddLike extends Plugin {
+          onload() {
+            this.addCommand({ id: 'capture', name: 'Capture', callback: () => new Notice('ok') });
+          }
+        };
+      `,
+      { styles: '.test { color: red; }', data: { enabled: true } },
+    );
+
+    writeVaultPlugin(
+      'desktop-only-like',
+      `
+        const { Plugin } = require('obsidian');
+        const electron = require('electron');
+        module.exports = class DesktopOnly extends Plugin {};
+      `,
+    );
+
+    const reports = await scanObsidianVaultPlugins(vaultRoot);
+
+    expect(reports).toHaveLength(2);
+
+    const quickadd = reports.find((item) => item.id === 'quickadd-like');
+    expect(quickadd).toMatchObject({
+      compatibilityLevel: 'compatible',
+      hasStyles: true,
+      hasData: true,
+    });
+
+    const desktopOnly = reports.find((item) => item.id === 'desktop-only-like');
+    expect(desktopOnly).toMatchObject({ compatibilityLevel: 'blocked' });
+    expect(desktopOnly?.compatibility.nodeModules).toContain('electron');
+  });
+
+  it('skips invalid manifests instead of crashing the whole scan', async () => {
+    writeVaultPlugin('good-plugin', `const { Plugin } = require('obsidian'); module.exports = class Good extends Plugin {};`);
+    writeVaultPlugin(
+      'bad-plugin',
+      `const { Plugin } = require('obsidian'); module.exports = class Bad extends Plugin {};`,
+      { manifest: { id: 'bad plugin', name: 'bad', version: '1.0.0' } },
+    );
+
+    const reports = await scanObsidianVaultPlugins(vaultRoot);
+
+    expect(reports.map((item) => item.id)).toEqual(['good-plugin']);
+  });
+
+  it('imports an Obsidian plugin into MindOS .plugins and preserves data and styles', async () => {
+    writeVaultPlugin(
+      'import-me',
+      `const { Plugin } = require('obsidian'); module.exports = class ImportMe extends Plugin {};`,
+      { styles: '.plugin-style {}', data: { count: 2 } },
+    );
+
+    const imported = await importObsidianPlugin({
+      vaultRoot,
+      pluginId: 'import-me',
+      targetMindRoot: mindRoot,
+    });
+
+    expect(imported.targetDir).toBe(path.join(mindRoot, '.plugins', 'import-me'));
+    expect(fs.existsSync(path.join(imported.targetDir, 'manifest.json'))).toBe(true);
+    expect(fs.existsSync(path.join(imported.targetDir, 'main.js'))).toBe(true);
+    expect(fs.existsSync(path.join(imported.targetDir, 'styles.css'))).toBe(true);
+    expect(JSON.parse(fs.readFileSync(path.join(imported.targetDir, 'data.json'), 'utf-8'))).toEqual({ count: 2 });
+  });
+
+  it('rejects importing plugins that escape the source plugins directory', async () => {
+    await expect(
+      importObsidianPlugin({
+        vaultRoot,
+        pluginId: '../escape',
+        targetMindRoot: mindRoot,
+      }),
+    ).rejects.toThrow(/escapes/i);
+  });
+});

package/_standalone/__tests__/obsidian-compat/plugin-manager.test.ts

@@ -117,4 +117,32 @@ describe('PluginManager', () => {
     const plugin = manager.list().find((item) => item.id === 'toggle-plugin');
     expect(plugin).toMatchObject({ enabled: false, loaded: false });
   });
+
+  it('scans an external Obsidian vault and imports a selected plugin into the manager root', async () => {
+    const sourceVault = fs.mkdtempSync(path.join(os.tmpdir(), 'mindos-obsidian-import-source-'));
+    try {
+      const sourcePluginDir = path.join(sourceVault, '.obsidian', 'plugins', 'ported-plugin');
+      fs.mkdirSync(sourcePluginDir, { recursive: true });
+      fs.writeFileSync(
+        path.join(sourcePluginDir, 'manifest.json'),
+        JSON.stringify({ id: 'ported-plugin', name: 'ported-plugin', version: '1.0.0' }, null, 2),
+        'utf-8',
+      );
+      fs.writeFileSync(
+        path.join(sourcePluginDir, 'main.js'),
+        `const { Plugin } = require('obsidian'); module.exports = class PortedPlugin extends Plugin {};`,
+        'utf-8',
+      );
+
+      const manager = new PluginManager(mindRoot);
+      const scanned = await manager.scanObsidianVault(sourceVault);
+      expect(scanned[0]).toMatchObject({ id: 'ported-plugin', compatibilityLevel: 'compatible' });
+
+      await manager.importFromObsidianVault(sourceVault, 'ported-plugin');
+      const plugins = await manager.discover();
+      expect(plugins.find((item) => item.id === 'ported-plugin')).toBeTruthy();
+    } finally {
+      fs.rmSync(sourceVault, { recursive: true, force: true });
+    }
+  });
 });

package/_standalone/__tests__/scripts/extract-pdf-runtime.test.ts

@@ -0,0 +1,139 @@
+import { describe, it, expect } from 'vitest';
+import { execFileSync } from 'child_process';
+import path from 'path';
+import fs from 'fs';
+import os from 'os';
+
+/**
+ * Runtime integration test for extract-pdf.cjs.
+ *
+ * Unlike the API tests which run POST /api/extract-pdf via vitest imports,
+ * this test spawns the actual child process (as happens in production) to
+ * verify that pdfjs-dist can be resolved when running extract-pdf.cjs outside
+ * the Next.js bundler context.
+ *
+ * This catches the real failure mode: "Cannot find module 'pdfjs-dist/legacy/build/pdf.mjs'"
+ * which only occurs when pdfjs-dist is missing from the runtime's node_modules.
+ */
+
+// Minimal valid PDF with extractable text
+const MINIMAL_PDF = Buffer.from(`%PDF-1.4
+1 0 obj
+<< /Type /Catalog /Pages 2 0 R >>
+endobj
+
+2 0 obj
+<< /Type /Pages /Kids [3 0 R] /Count 1 >>
+endobj
+
+3 0 obj
+<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792]
+   /Contents 4 0 R /Resources << /Font << /F1 5 0 R >> >> >>
+endobj
+
+4 0 obj
+<< /Length 44 >>
+stream
+BT /F1 12 Tf 100 700 Td (Hello World) Tj ET
+endstream
+endobj
+
+5 0 obj
+<< /Type /Font /Subtype /Type1 /BaseFont /Helvetica >>
+endobj
+
+xref
+0 6
+0000000000 65535 f 
+0000000009 00000 n 
+0000000058 00000 n 
+0000000115 00000 n 
+0000000266 00000 n 
+0000000360 00000 n 
+
+trailer
+<< /Size 6 /Root 1 0 R >>
+startxref
+441
+%%EOF`);
+
+describe('extract-pdf.cjs runtime integration', () => {
+  const scriptPath = path.resolve(__dirname, '../../scripts/extract-pdf.cjs');
+
+  it('script file exists', () => {
+    expect(fs.existsSync(scriptPath)).toBe(true);
+  });
+
+  it('successfully loads pdfjs-dist and extracts text', () => {
+    // Write test PDF to temp file
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pdf-test-'));
+    const pdfPath = path.join(tmpDir, 'test.pdf');
+    fs.writeFileSync(pdfPath, MINIMAL_PDF);
+
+    try {
+      // Spawn the script exactly as the API route does
+      const result = execFileSync('node', [scriptPath, pdfPath], {
+        encoding: 'utf-8',
+        timeout: 10_000,
+        maxBuffer: 10 * 1024 * 1024,
+      });
+
+      // Parse JSON output
+      const parsed = JSON.parse(result.trim()) as {
+        text: string;
+        pages: number;
+        error?: string;
+      };
+
+      // Must not have an error
+      expect(parsed.error).toBeUndefined();
+
+      // Must extract the expected text
+      expect(parsed.text).toContain('Hello');
+      expect(parsed.pages).toBe(1);
+    } finally {
+      // Cleanup
+      fs.rmSync(tmpDir, { recursive: true, force: true });
+    }
+  });
+
+  it('returns error JSON for invalid PDF (not crash)', () => {
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pdf-test-'));
+    const pdfPath = path.join(tmpDir, 'invalid.pdf');
+    fs.writeFileSync(pdfPath, 'not a valid PDF');
+
+    try {
+      const result = execFileSync('node', [scriptPath, pdfPath], {
+        encoding: 'utf-8',
+        timeout: 10_000,
+        maxBuffer: 10 * 1024 * 1024,
+      });
+
+      const parsed = JSON.parse(result.trim()) as {
+        text: string;
+        pages: number;
+        error?: string;
+      };
+
+      // Should have an error field, not throw
+      expect(parsed.error).toBeDefined();
+    } finally {
+      fs.rmSync(tmpDir, { recursive: true, force: true });
+    }
+  });
+
+  it('returns error JSON for missing file', () => {
+    const result = execFileSync('node', [scriptPath, '/nonexistent/path.pdf'], {
+      encoding: 'utf-8',
+      timeout: 10_000,
+    });
+
+    const parsed = JSON.parse(result.trim()) as {
+      text: string;
+      pages: number;
+      error?: string;
+    };
+
+    expect(parsed.error).toContain('not found');
+  });
+});

package/_standalone/components/ask/AgentSelectorCapsule.tsx

@@ -27,7 +27,11 @@ export default function AgentSelectorCapsule({
   loading = false,
 }: AgentSelectorCapsuleProps) {
   const { t } = useLocale();
-  const p = t.panels.agents;
+  const p = t.panels?.agents ?? {
+    acpDefaultAgent: 'MindOS',
+    acpSelectAgent: 'Select Agent',
+    acpChangeAgent: 'Change agent',
+  };
   const [open, setOpen] = useState(false);
   const [pos, setPos] = useState<DropdownPos | null>(null);
   const triggerRef = useRef<HTMLButtonElement>(null);
@@ -117,9 +121,6 @@ export default function AgentSelectorCapsule({
   const isDefault = !selectedAgent;
   const displayName = selectedAgent?.name ?? p.acpDefaultAgent;
 
-  // Only show if there are installed agents to choose from
-  if (!loading && installedAgents.length === 0 && !selectedAgent) return null;
-
   const dropdown = open && pos ? (
     <div
       ref={dropdownRef}