@geminilight/mindos 0.6.73 → 0.6.74

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

@@ -1,84 +0,0 @@
-/**
- * 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

@@ -1,27 +0,0 @@
-/**
- * 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

@@ -1,50 +0,0 @@
-/**
- * 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

@@ -1,18 +0,0 @@
-/**
- * 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

@@ -1,225 +0,0 @@
-/**
- * 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

@@ -1,90 +0,0 @@
-/**
- * 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

@@ -1,149 +0,0 @@
-/**
- * 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');
-  }
-}