@geminilight/mindos 0.6.74 → 0.6.75

package/_standalone/lib/obsidian-compat/component.ts

@@ -0,0 +1,84 @@
+/**
+ * Obsidian Plugin Compatibility - Component Base
+ * Lifecycle and resource cleanup
+ */
+
+import { Events, EventRef } from './events';
+
+/**
+ * Base component class for plugin lifecycle and event/timer cleanup.
+ * Plugins extend this; ensures unload() properly cleans up child resources.
+ */
+export class Component extends Events {
+  private children: Set<Component> = new Set();
+  private unloadCallbacks: Set<() => void> = new Set();
+
+  async load(): Promise<void> {
+    await this.onload();
+  }
+
+  async unload(): Promise<void> {
+    // Clean up all children first
+    for (const child of Array.from(this.children)) {
+      await child.unload();
+    }
+    this.children.clear();
+
+    // Call all registered unload callbacks
+    for (const callback of Array.from(this.unloadCallbacks)) {
+      try {
+        callback();
+      } catch (err) {
+        console.error('[obsidian-compat] Component unload callback error:', err);
+      }
+    }
+    this.unloadCallbacks.clear();
+
+    // Call user-defined onunload
+    await this.onunload();
+  }
+
+  /** Override in subclass */
+  onload(): Promise<void> | void {}
+
+  /** Override in subclass */
+  onunload(): Promise<void> | void {}
+
+  addChild(child: Component): void {
+    this.children.add(child);
+  }
+
+  removeChild(child: Component): void {
+    this.children.delete(child);
+  }
+
+  /**
+   * Register a callback to be invoked when this component unloads.
+   */
+  register(callback: () => void): void {
+    this.unloadCallbacks.add(callback);
+  }
+
+  /**
+   * Register an event reference. Automatically calls ref.off() on unload.
+   */
+  registerEvent(ref: EventRef): void {
+    this.register(() => ref.off());
+  }
+
+  /**
+   * Register a DOM event listener. Automatically removes on unload.
+   */
+  registerDomEvent(el: EventTarget, type: string, callback: EventListener): void {
+    el.addEventListener(type, callback);
+    this.register(() => el.removeEventListener(type, callback));
+  }
+
+  /**
+   * Register an interval timer. Automatically clears on unload.
+   */
+  registerInterval(id: number): number {
+    this.register(() => clearInterval(id));
+    return id;
+  }
+}

package/_standalone/lib/obsidian-compat/errors.ts

@@ -0,0 +1,27 @@
+/**
+ * Obsidian Plugin Compatibility - Errors
+ */
+
+export class CompatError extends Error {
+  constructor(
+    message: string,
+    public code: string,
+    public context?: Record<string, unknown>,
+  ) {
+    super(message);
+    this.name = 'CompatError';
+  }
+}
+
+export const CompatErrorCodes = {
+  PLUGIN_NOT_FOUND: 'PLUGIN_NOT_FOUND',
+  MANIFEST_INVALID: 'MANIFEST_INVALID',
+  MANIFEST_READ_FAILED: 'MANIFEST_READ_FAILED',
+  MODULE_LOAD_FAILED: 'MODULE_LOAD_FAILED',
+  MODULE_NOT_SUPPORTED: 'MODULE_NOT_SUPPORTED',
+  PLUGIN_RUNTIME_ERROR: 'PLUGIN_RUNTIME_ERROR',
+  DATA_FILE_READ_FAILED: 'DATA_FILE_READ_FAILED',
+  DATA_FILE_WRITE_FAILED: 'DATA_FILE_WRITE_FAILED',
+  PLUGIN_ALREADY_LOADED: 'PLUGIN_ALREADY_LOADED',
+  PLUGIN_NOT_LOADED: 'PLUGIN_NOT_LOADED',
+};

package/_standalone/lib/obsidian-compat/events.ts

@@ -0,0 +1,50 @@
+/**
+ * Obsidian Plugin Compatibility - Events Base
+ * Minimal event emitter used by Vault, MetadataCache, Workspace
+ */
+
+export type EventCallback = (...args: any[]) => any;
+export type EventRef = { off: () => void };
+
+export class Events {
+  private listeners: Map<string, Set<EventCallback>> = new Map();
+
+  on(name: string, callback: EventCallback): EventRef {
+    if (!this.listeners.has(name)) {
+      this.listeners.set(name, new Set());
+    }
+    this.listeners.get(name)!.add(callback);
+
+    return {
+      off: () => this.off(name, callback),
+    };
+  }
+
+  off(name: string, callback: EventCallback): void {
+    const set = this.listeners.get(name);
+    if (set) {
+      set.delete(callback);
+      if (set.size === 0) {
+        this.listeners.delete(name);
+      }
+    }
+  }
+
+  offref(ref: EventRef): void {
+    // ref.off() is already bound, just call it
+    ref.off();
+  }
+
+  trigger(name: string, ...args: any[]): void {
+    const set = this.listeners.get(name);
+    if (set) {
+      for (const callback of Array.from(set)) {
+        try {
+          callback(...args);
+        } catch (err) {
+          console.error(`[obsidian-compat] Event '${name}' callback error:`, err);
+        }
+      }
+    }
+  }
+}

package/_standalone/lib/obsidian-compat/index.ts

@@ -0,0 +1,18 @@
+/**
+ * Obsidian Plugin Compatibility - Public API
+ * Main entry point for using the compat layer
+ */
+
+export { Plugin } from './shims/plugin';
+export { Vault } from './shims/vault';
+export { Notice, Modal } from './shims/ui';
+export { PluginSettingTab, Setting } from './shims/settings';
+export { AppShim } from './shims/app';
+export { PluginLoader } from './loader';
+export { PluginManager } from './plugin-manager';
+export { CommandRegistry } from './command-registry';
+export { Component } from './component';
+export { Events } from './events';
+export { validateManifest, ManifestError } from './manifest';
+export { CompatError, CompatErrorCodes } from './errors';
+export type { PluginManifest, TFile, TFolder, TAbstractFile, Command } from './types';

package/_standalone/lib/obsidian-compat/loader.ts

@@ -0,0 +1,225 @@
+/**
+ * Obsidian Plugin Compatibility - Plugin Loader
+ * Scans .plugins/ directory, validates manifests, loads and executes plugins
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { validateManifest, ManifestError } from './manifest';
+import { CompatError, CompatErrorCodes } from './errors';
+import { Plugin } from './shims/plugin';
+import { createObsidianModule } from './shims/obsidian';
+import { AppShim } from './shims/app';
+import { PluginManifest } from './types';
+
+export interface LoadedPlugin {
+  manifest: PluginManifest;
+  instance: Plugin;
+  pluginDir: string;
+}
+
+/**
+ * Plugin loader: scans .plugins/ directory and loads valid plugins
+ */
+export class PluginLoader {
+  private plugins: Map<string, LoadedPlugin> = new Map();
+  private app: AppShim;
+
+  constructor(private mindRoot: string) {
+    this.app = new AppShim(mindRoot);
+  }
+
+  private resolvePluginDir(pluginId: string): string {
+    const pluginsDir = path.resolve(path.join(this.mindRoot, '.plugins'));
+    const pluginDir = path.resolve(path.join(pluginsDir, pluginId));
+
+    if (pluginDir !== pluginsDir && !pluginDir.startsWith(pluginsDir + path.sep)) {
+      throw new CompatError(`Plugin path escapes .plugins directory: ${pluginId}`, CompatErrorCodes.PLUGIN_NOT_FOUND, { pluginId });
+    }
+
+    return pluginDir;
+  }
+
+  /**
+   * Scan .plugins/ directory and discover all plugins.
+   */
+  discoverPlugins(): PluginManifest[] {
+    const pluginsDir = path.join(this.mindRoot, '.plugins');
+
+    if (!fs.existsSync(pluginsDir)) {
+      return [];
+    }
+
+    const discovered: PluginManifest[] = [];
+
+    try {
+      const entries = fs.readdirSync(pluginsDir);
+      for (const entry of entries) {
+        const pluginDir = path.join(pluginsDir, entry);
+        const manifestPath = path.join(pluginDir, 'manifest.json');
+
+        if (!fs.statSync(pluginDir).isDirectory()) {
+          continue;
+        }
+
+        if (!fs.existsSync(manifestPath)) {
+          console.warn(`[obsidian-compat] Plugin "${entry}" has no manifest.json, skipping`);
+          continue;
+        }
+
+        try {
+          const manifestRaw = fs.readFileSync(manifestPath, 'utf-8');
+          const manifestObj = JSON.parse(manifestRaw);
+          const manifest = validateManifest(manifestObj);
+          discovered.push(manifest);
+        } catch (err) {
+          if (err instanceof ManifestError) {
+            console.error(`[obsidian-compat] Invalid manifest in plugin "${entry}": ${err.message}`);
+          } else {
+            console.error(`[obsidian-compat] Failed to read manifest in plugin "${entry}": ${err instanceof Error ? err.message : String(err)}`);
+          }
+        }
+      }
+    } catch (err) {
+      console.error(`[obsidian-compat] Failed to scan plugins directory: ${err instanceof Error ? err.message : String(err)}`);
+    }
+
+    return discovered;
+  }
+
+  /**
+   * Load a plugin by ID.
+   */
+  async loadPlugin(pluginId: string): Promise<LoadedPlugin> {
+    if (this.plugins.has(pluginId)) {
+      throw new CompatError(`Plugin already loaded: ${pluginId}`, CompatErrorCodes.PLUGIN_ALREADY_LOADED);
+    }
+
+    const pluginDir = this.resolvePluginDir(pluginId);
+    const manifestPath = path.join(pluginDir, 'manifest.json');
+    const mainPath = path.join(pluginDir, 'main.js');
+
+    // Validate manifest exists and is valid
+    if (!fs.existsSync(manifestPath)) {
+      throw new CompatError(`Plugin manifest not found: ${pluginId}`, CompatErrorCodes.MANIFEST_READ_FAILED, { pluginId });
+    }
+
+    let manifest: PluginManifest;
+    try {
+      const raw = fs.readFileSync(manifestPath, 'utf-8');
+      manifest = validateManifest(JSON.parse(raw));
+    } catch (err) {
+      throw new CompatError(
+        `Invalid plugin manifest: ${err instanceof ManifestError ? err.message : String(err)}`,
+        CompatErrorCodes.MANIFEST_INVALID,
+        { pluginId },
+      );
+    }
+
+    // Check if main.js exists
+    if (!fs.existsSync(mainPath)) {
+      throw new CompatError(`Plugin main.js not found: ${pluginId}`, CompatErrorCodes.MODULE_LOAD_FAILED, { pluginId });
+    }
+
+    // Load and execute main.js with obsidian shim
+    let instance: Plugin;
+    try {
+      const code = fs.readFileSync(mainPath, 'utf-8');
+      instance = this.executePluginModule(code, manifest, pluginDir);
+    } catch (err) {
+      throw new CompatError(
+        `Failed to load plugin: ${err instanceof Error ? err.message : String(err)}`,
+        CompatErrorCodes.MODULE_LOAD_FAILED,
+        { pluginId },
+      );
+    }
+
+    const loaded: LoadedPlugin = { manifest, instance, pluginDir };
+    this.plugins.set(pluginId, loaded);
+
+    // Call onload
+    try {
+      await instance.load();
+    } catch (err) {
+      this.plugins.delete(pluginId);
+      throw new CompatError(
+        `Plugin onload failed: ${err instanceof Error ? err.message : String(err)}`,
+        CompatErrorCodes.PLUGIN_RUNTIME_ERROR,
+        { pluginId },
+      );
+    }
+
+    return loaded;
+  }
+
+  /**
+   * Unload a plugin by ID.
+   */
+  async unloadPlugin(pluginId: string): Promise<void> {
+    const loaded = this.plugins.get(pluginId);
+    if (!loaded) {
+      throw new CompatError(`Plugin not loaded: ${pluginId}`, CompatErrorCodes.PLUGIN_NOT_LOADED, { pluginId });
+    }
+
+    try {
+      await loaded.instance.unload();
+    } catch (err) {
+      console.error(`[obsidian-compat] Error during plugin unload: ${err instanceof Error ? err.message : String(err)}`);
+    }
+
+    this.app.unregisterAllCommands(pluginId);
+    this.plugins.delete(pluginId);
+  }
+
+  /**
+   * Execute plugin code in a sandbox with obsidian shim.
+   */
+  private executePluginModule(code: string, manifest: PluginManifest, pluginDir: string): Plugin {
+    const module = { exports: {} as any };
+    const exports = module.exports;
+
+    const obsidianModule = createObsidianModule();
+
+    const require = (id: string) => {
+      if (id === 'obsidian') {
+        return obsidianModule;
+      }
+      throw new CompatError(`Unsupported module: ${id}`, CompatErrorCodes.MODULE_NOT_SUPPORTED, { moduleId: id });
+    };
+
+    try {
+      const wrappedCode = `${code}\n//# sourceURL=obsidian-plugin:${manifest.id}/main.js`;
+      const fn = new Function('module', 'exports', 'require', 'console', wrappedCode);
+      fn(module, exports, require, console);
+    } catch (err) {
+      throw new Error(`Plugin code execution failed for "${manifest.id}": ${err instanceof Error ? err.message : String(err)}`);
+    }
+
+    // Instantiate plugin
+    const PluginClass = module.exports.default || module.exports;
+    if (typeof PluginClass !== 'function') {
+      throw new Error('Plugin must export a default Plugin class');
+    }
+
+    const instance = new PluginClass(this.app, manifest, pluginDir) as Plugin;
+    if (!(instance instanceof Plugin)) {
+      throw new Error('Plugin instance is not instanceof Plugin');
+    }
+
+    return instance;
+  }
+
+  /**
+   * Get all loaded plugins.
+   */
+  getLoadedPlugins(): LoadedPlugin[] {
+    return Array.from(this.plugins.values());
+  }
+
+  /**
+   * Get the app shim (for testing/integration).
+   */
+  getApp(): AppShim {
+    return this.app;
+  }
+}

package/_standalone/lib/obsidian-compat/manifest.ts

@@ -0,0 +1,90 @@
+/**
+ * Obsidian Plugin Compatibility - Manifest Validation
+ */
+
+import { PluginManifest } from './types';
+
+export class ManifestError extends Error {
+  constructor(message: string, public field?: string) {
+    super(message);
+    this.name = 'ManifestError';
+  }
+}
+
+/**
+ * Validates a plugin manifest against required and optional fields.
+ * @throws ManifestError if validation fails
+ */
+export function validateManifest(manifest: unknown): PluginManifest {
+  if (!manifest || typeof manifest !== 'object') {
+    throw new ManifestError('Manifest must be an object');
+  }
+
+  const m = manifest as Record<string, unknown>;
+
+  // Required fields
+  if (!m.id || typeof m.id !== 'string') {
+    throw new ManifestError('Missing or invalid "id" field', 'id');
+  }
+  if (!isValidId(m.id)) {
+    throw new ManifestError(`Invalid plugin id: "${m.id}". Must be alphanumeric with hyphens/underscores.`, 'id');
+  }
+
+  if (!m.name || typeof m.name !== 'string') {
+    throw new ManifestError('Missing or invalid "name" field', 'name');
+  }
+
+  if (!m.version || typeof m.version !== 'string') {
+    throw new ManifestError('Missing or invalid "version" field', 'version');
+  }
+  if (!isValidSemver(m.version)) {
+    throw new ManifestError(`Invalid semver: "${m.version}"`, 'version');
+  }
+
+  // Optional fields
+  const result: PluginManifest = {
+    id: m.id,
+    name: m.name,
+    version: m.version,
+  };
+
+  if (m.minMindOsVersion && typeof m.minMindOsVersion === 'string') {
+    result.minMindOsVersion = m.minMindOsVersion;
+  }
+
+  if (m.description && typeof m.description === 'string') {
+    result.description = m.description;
+  }
+
+  if (m.author && typeof m.author === 'string') {
+    result.author = m.author;
+  }
+
+  if (m.authorUrl && typeof m.authorUrl === 'string') {
+    result.authorUrl = m.authorUrl;
+  }
+
+  if (m.fundingUrl && typeof m.fundingUrl === 'string') {
+    result.fundingUrl = m.fundingUrl;
+  }
+
+  if (m.isDesktopOnly === true) {
+    result.isDesktopOnly = true;
+  }
+
+  return result;
+}
+
+/**
+ * Checks if plugin ID is valid (alphanumeric, hyphens, underscores).
+ */
+function isValidId(id: string): boolean {
+  return /^[a-zA-Z0-9_-]+$/.test(id) && id.length > 0 && id.length <= 64;
+}
+
+/**
+ * Checks if version string is valid semver (major.minor.patch).
+ */
+function isValidSemver(version: string): boolean {
+  return /^\d+\.\d+\.\d+$/.test(version);
+}

package/_standalone/lib/obsidian-compat/plugin-manager.ts

@@ -0,0 +1,149 @@
+/**
+ * Obsidian Plugin Compatibility - Plugin Manager
+ * Persists enabled state and orchestrates bulk plugin loading.
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { PluginLoader } from './loader';
+import type { PluginManifest } from './types';
+
+interface PluginManagerState {
+  enabled: Record<string, boolean>;
+}
+
+export interface ManagedPlugin {
+  id: string;
+  name: string;
+  version: string;
+  enabled: boolean;
+  loaded: boolean;
+  lastError?: string;
+}
+
+export interface LoadEnabledResult {
+  loaded: string[];
+  failed: string[];
+}
+
+const EMPTY_STATE: PluginManagerState = { enabled: {} };
+
+export class PluginManager {
+  private readonly loader: PluginLoader;
+  private readonly stateFilePath: string;
+  private plugins = new Map<string, ManagedPlugin>();
+
+  constructor(private mindRoot: string) {
+    this.loader = new PluginLoader(mindRoot);
+    this.stateFilePath = path.join(mindRoot, '.plugins', '.plugin-manager.json');
+  }
+
+  async discover(): Promise<ManagedPlugin[]> {
+    const persisted = this.readState();
+    const manifests = this.loader.discoverPlugins();
+
+    this.plugins.clear();
+    for (const manifest of manifests) {
+      this.plugins.set(manifest.id, this.toManagedPlugin(manifest, persisted));
+    }
+
+    return this.list();
+  }
+
+  list(): ManagedPlugin[] {
+    return Array.from(this.plugins.values()).sort((a, b) => a.id.localeCompare(b.id));
+  }
+
+  async enable(pluginId: string): Promise<void> {
+    const plugin = this.requirePlugin(pluginId);
+    plugin.enabled = true;
+    plugin.lastError = undefined;
+    this.writeState();
+  }
+
+  async disable(pluginId: string): Promise<void> {
+    const plugin = this.requirePlugin(pluginId);
+    if (plugin.loaded) {
+      await this.loader.unloadPlugin(pluginId);
+    }
+    plugin.enabled = false;
+    plugin.loaded = false;
+    plugin.lastError = undefined;
+    this.writeState();
+  }
+
+  async loadEnabledPlugins(): Promise<LoadEnabledResult> {
+    const result: LoadEnabledResult = { loaded: [], failed: [] };
+
+    for (const plugin of this.list()) {
+      if (!plugin.enabled) {
+        continue;
+      }
+
+      try {
+        await this.loader.loadPlugin(plugin.id);
+        plugin.loaded = true;
+        plugin.lastError = undefined;
+        result.loaded.push(plugin.id);
+      } catch (error) {
+        plugin.loaded = false;
+        plugin.lastError = error instanceof Error ? error.message : String(error);
+        result.failed.push(plugin.id);
+      }
+    }
+
+    this.writeState();
+    return result;
+  }
+
+  getLoader(): PluginLoader {
+    return this.loader;
+  }
+
+  private toManagedPlugin(manifest: PluginManifest, state: PluginManagerState): ManagedPlugin {
+    const loaded = this.loader.getLoadedPlugins().some((plugin) => plugin.manifest.id === manifest.id);
+    return {
+      id: manifest.id,
+      name: manifest.name,
+      version: manifest.version,
+      enabled: state.enabled[manifest.id] === true,
+      loaded,
+    };
+  }
+
+  private requirePlugin(pluginId: string): ManagedPlugin {
+    const plugin = this.plugins.get(pluginId);
+    if (!plugin) {
+      throw new Error(`Unknown plugin: ${pluginId}`);
+    }
+    return plugin;
+  }
+
+  private readState(): PluginManagerState {
+    if (!fs.existsSync(this.stateFilePath)) {
+      return { ...EMPTY_STATE, enabled: {} };
+    }
+
+    try {
+      const raw = fs.readFileSync(this.stateFilePath, 'utf-8');
+      const parsed = JSON.parse(raw) as Partial<PluginManagerState>;
+      return {
+        enabled: parsed.enabled ?? {},
+      };
+    } catch {
+      return { ...EMPTY_STATE, enabled: {} };
+    }
+  }
+
+  private writeState(): void {
+    const enabled: Record<string, boolean> = {};
+    for (const plugin of this.plugins.values()) {
+      if (plugin.enabled) {
+        enabled[plugin.id] = true;
+      }
+    }
+
+    fs.mkdirSync(path.dirname(this.stateFilePath), { recursive: true });
+    fs.writeFileSync(this.stateFilePath, JSON.stringify({ enabled }, null, 2), 'utf-8');
+  }
+}