@geminilight/mindos 0.6.76 → 0.6.77

package/app/__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/app/__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/app/__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/app/__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/app/__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/app/app/api/obsidian/compat-report/route.ts

@@ -0,0 +1,33 @@
+export const dynamic = 'force-dynamic';
+
+import { NextRequest, NextResponse } from 'next/server';
+import { handleRouteErrorSimple } from '@/lib/errors';
+import { scanObsidianVaultPlugins } from '@/lib/obsidian-compat/obsidian-import';
+import { expandSetupPathHome } from '@/app/api/setup/path-utils';
+
+export async function GET(req: NextRequest) {
+  try {
+    const vaultRootParam = req.nextUrl.searchParams.get('vaultRoot');
+    if (!vaultRootParam) {
+      return NextResponse.json({ ok: false, error: 'Missing vaultRoot' }, { status: 400 });
+    }
+
+    const vaultRoot = expandSetupPathHome(vaultRootParam.trim());
+    const plugins = await scanObsidianVaultPlugins(vaultRoot);
+    const summary = {
+      total: plugins.length,
+      compatible: plugins.filter((plugin) => plugin.compatibilityLevel === 'compatible').length,
+      partial: plugins.filter((plugin) => plugin.compatibilityLevel === 'partial').length,
+      blocked: plugins.filter((plugin) => plugin.compatibilityLevel === 'blocked').length,
+    };
+
+    return NextResponse.json({
+      ok: true,
+      vaultRoot,
+      summary,
+      plugins,
+    });
+  } catch (err) {
+    return handleRouteErrorSimple(err);
+  }
+}

package/app/app/api/obsidian/import/route.ts

@@ -0,0 +1,37 @@
+export const dynamic = 'force-dynamic';
+
+import { NextRequest, NextResponse } from 'next/server';
+import { handleRouteErrorSimple } from '@/lib/errors';
+import { importObsidianPlugin, scanObsidianVaultPlugins } from '@/lib/obsidian-compat/obsidian-import';
+import { expandSetupPathHome } from '@/app/api/setup/path-utils';
+
+export async function POST(req: NextRequest) {
+  try {
+    const body = await req.json() as { vaultRoot?: string; pluginId?: string; targetMindRoot?: string };
+    if (!body.vaultRoot || !body.pluginId) {
+      return NextResponse.json({ ok: false, error: 'Missing vaultRoot or pluginId' }, { status: 400 });
+    }
+
+    const vaultRoot = expandSetupPathHome(body.vaultRoot.trim());
+    const targetMindRoot = expandSetupPathHome((body.targetMindRoot ?? process.cwd()).trim());
+    const plugins = await scanObsidianVaultPlugins(vaultRoot);
+    const plugin = plugins.find((item) => item.id === body.pluginId);
+    if (!plugin) {
+      return NextResponse.json({ ok: false, error: 'Plugin not found in Obsidian vault' }, { status: 404 });
+    }
+
+    const imported = await importObsidianPlugin({
+      vaultRoot,
+      pluginId: body.pluginId,
+      targetMindRoot,
+    });
+
+    return NextResponse.json({
+      ok: true,
+      plugin,
+      imported,
+    });
+  } catch (err) {
+    return handleRouteErrorSimple(err);
+  }
+}

package/app/app/api/setup/check-path/route.ts

@@ -1,7 +1,7 @@
 export const dynamic = 'force-dynamic';
 import { NextRequest, NextResponse } from 'next/server';
 import { existsSync, readdirSync } from 'node:fs';
-import { expandSetupPathHome } from '../path-utils';
+import { expandSetupPathHome, validateMindRootPath } from '../path-utils';
 import { handleRouteErrorSimple } from '@/lib/errors';
 
 export async function POST(req: NextRequest) {
@@ -11,6 +11,20 @@ export async function POST(req: NextRequest) {
       return NextResponse.json({ error: 'Invalid path' }, { status: 400 });
     }
     const abs = expandSetupPathHome(path.trim());
+    
+    // Validate path is not inside dangerous directories
+    const validation = validateMindRootPath(abs);
+    if (!validation.safe) {
+      return NextResponse.json({
+        exists: false,
+        empty: true,
+        count: 0,
+        unsafe: true,
+        reason: validation.reason,
+        reasonZh: validation.reasonZh,
+      });
+    }
+    
     const exists = existsSync(abs);
     let empty = true;
     let count = 0;
@@ -24,7 +38,7 @@ export async function POST(req: NextRequest) {
         empty = false;
       }
     }
-    return NextResponse.json({ exists, empty, count });
+    return NextResponse.json({ exists, empty, count, unsafe: false });
   } catch (err) {
     return handleRouteErrorSimple(err);
   }