@owdproject/core 3.4.0 → 4.0.0-alpha.4

package/dist/managers/index.d.ts

@@ -0,0 +1,118 @@
+import { W as WindowManager, a as WindowInstance } from '../shared/core.BOvFdEVQ.js';
+import { CoreIPCBus } from '../events/index.js';
+import { Hookable } from 'hookable';
+import { DesktopWorkareaRect, DesktopRuntimeHooks, ApplicationConfig, ApplicationPermission, WindowState } from '../types/index.js';
+
+interface WorkspaceState {
+    readonly workspaces: readonly string[];
+    readonly active: string;
+    readonly workarea: DesktopWorkareaRect;
+}
+declare class WorkspaceManager {
+    private state;
+    private subscribers;
+    private hooks;
+    private ipc;
+    constructor(options?: {
+        workspaces?: string[];
+        active?: string;
+        workarea?: DesktopWorkareaRect;
+        hooks?: Hookable<DesktopRuntimeHooks>;
+        ipc?: CoreIPCBus;
+    });
+    private updateState;
+    getSnapshot(): WorkspaceState;
+    subscribe(callback: (state: WorkspaceState) => void): () => void;
+    private notify;
+    get activeWorkspace(): string;
+    get workspaces(): string[];
+    get workarea(): DesktopWorkareaRect;
+    setWorkspace(workspaceId: string): Promise<boolean>;
+    setWorkarea(workarea: DesktopWorkareaRect): void;
+    addWorkspace(id: string): void;
+    removeWorkspace(id: string): boolean;
+}
+
+interface ApplicationProcessSnapshot {
+    readonly id: string;
+    readonly title: string;
+    readonly icon?: string;
+    readonly category?: string;
+    readonly stateValue: string;
+    readonly pid: number | null;
+    readonly startedAt: number | null;
+    readonly isRunning: boolean;
+    readonly isSuspended: boolean;
+    readonly windowIds: readonly string[];
+}
+declare class ApplicationInstance {
+    readonly id: string;
+    readonly config: ApplicationConfig;
+    private actor;
+    private _pid;
+    private _startedAt;
+    private _windowIds;
+    private snapshot;
+    private subscribers;
+    private windowManager;
+    private workspaceManager?;
+    private hooks;
+    private ipc;
+    private allocatePid;
+    constructor(options: {
+        config: ApplicationConfig;
+        windowManager: WindowManager;
+        workspaceManager?: WorkspaceManager;
+        hooks?: Hookable<DesktopRuntimeHooks>;
+        ipc?: CoreIPCBus;
+        allocatePid: () => number;
+    });
+    private computeSnapshot;
+    private refreshSnapshot;
+    private notify;
+    getSnapshot(): ApplicationProcessSnapshot;
+    subscribe(callback: (snapshot: ApplicationProcessSnapshot) => void): () => void;
+    get pid(): number | null;
+    get startedAt(): number | null;
+    get stateValue(): string;
+    get isRunning(): boolean;
+    get isSuspended(): boolean;
+    hasPermission(permission: ApplicationPermission): boolean;
+    private ensureProcessStarted;
+    private reuseSingletonWindow;
+    launch(entryKey?: string, argument?: string): Promise<boolean>;
+    openWindow(model: string, meta?: Record<string, any>, initialState?: Partial<WindowState>): Promise<WindowInstance | undefined>;
+    closeWindow(windowId: string): Promise<boolean>;
+    closeAllWindows(): void;
+    suspend(): Promise<boolean>;
+    resume(): Promise<boolean>;
+    terminate(signal?: 'SIGTERM' | 'SIGKILL'): Promise<boolean>;
+}
+declare class ApplicationManager {
+    private apps;
+    private snapshotCache;
+    private pidCounter;
+    private subscribers;
+    private windowManager;
+    private workspaceManager?;
+    private hooks;
+    private ipc;
+    constructor(options: {
+        windowManager: WindowManager;
+        workspaceManager?: WorkspaceManager;
+        hooks?: Hookable<DesktopRuntimeHooks>;
+        ipc?: CoreIPCBus;
+    });
+    getSnapshot(): ApplicationInstance[];
+    subscribe(callback: (apps: ApplicationInstance[]) => void): () => void;
+    private notify;
+    register(config: ApplicationConfig): ApplicationInstance;
+    get(id: string): ApplicationInstance | undefined;
+    getByPid(pid: number): ApplicationInstance | undefined;
+    get runningApps(): ApplicationInstance[];
+    launch(id: string, entryKey?: string, argument?: string): Promise<boolean>;
+    terminate(idOrPid: string | number, signal?: 'SIGTERM' | 'SIGKILL'): Promise<boolean>;
+}
+
+export { ApplicationInstance, ApplicationManager, WindowInstance, WindowManager, WorkspaceManager };
+export type { ApplicationProcessSnapshot, WorkspaceState };

package/dist/managers/index.mjs

@@ -0,0 +1,6 @@
+export { A as ApplicationInstance, a as ApplicationManager, W as WindowInstance, b as WindowManager, c as WorkspaceManager } from '../shared/core.d_A3q1kZ.mjs';
+import 'xstate';
+import '../shared/core.B3mp7ztE.mjs';
+import '../shared/core.CsDFgGnX.mjs';
+import '../shared/core.Pd_Ogt4g.mjs';
+import 'hookable';

package/dist/session/index.d.mts

@@ -0,0 +1,57 @@
+import { WindowManager } from '../index.mjs';
+import 'hookable';
+import '../types/index.mjs';
+
+/**
+ * @owdproject/core - Desktop Session Serializer & Hydration Engine
+ * Allows full state capture, persistence (LocalStorage / Database), and instant restore
+ * across sessions, devices, and frameworks.
+ */
+
+interface DesktopSerializedWindow {
+    id: string;
+    model: string;
+    workspace: string;
+    title?: string;
+    position?: {
+        x?: number;
+        y?: number;
+        z?: number;
+    };
+    size?: {
+        width?: any;
+        height?: any;
+    };
+    maximized?: boolean;
+    layout?: any;
+    spatial?: any;
+    focused?: boolean;
+    meta?: Record<string, any>;
+}
+interface DesktopSerializedSession {
+    version: number;
+    timestamp: number;
+    activeWorkspace?: string;
+    windows: DesktopSerializedWindow[];
+}
+declare class DesktopSessionManager {
+    static readonly CURRENT_VERSION = 1;
+    /**
+     * Serializes current WindowManager state into a JSON-compatible object.
+     */
+    static serialize(windowManager: WindowManager, options?: {
+        activeWorkspace?: string;
+    }): DesktopSerializedSession;
+    /**
+     * Restores windows from a serialized session into a WindowManager instance.
+     */
+    static restore(windowManager: WindowManager, session: DesktopSerializedSession, options?: {
+        componentResolver?: (model: string) => any;
+    }): {
+        restoredCount: number;
+        errors: string[];
+    };
+}
+
+export { DesktopSessionManager };
+export type { DesktopSerializedSession, DesktopSerializedWindow };

package/dist/session/index.d.ts

@@ -0,0 +1,57 @@
+import { WindowManager } from '../index.js';
+import 'hookable';
+import '../types/index.js';
+
+/**
+ * @owdproject/core - Desktop Session Serializer & Hydration Engine
+ * Allows full state capture, persistence (LocalStorage / Database), and instant restore
+ * across sessions, devices, and frameworks.
+ */
+
+interface DesktopSerializedWindow {
+    id: string;
+    model: string;
+    workspace: string;
+    title?: string;
+    position?: {
+        x?: number;
+        y?: number;
+        z?: number;
+    };
+    size?: {
+        width?: any;
+        height?: any;
+    };
+    maximized?: boolean;
+    layout?: any;
+    spatial?: any;
+    focused?: boolean;
+    meta?: Record<string, any>;
+}
+interface DesktopSerializedSession {
+    version: number;
+    timestamp: number;
+    activeWorkspace?: string;
+    windows: DesktopSerializedWindow[];
+}
+declare class DesktopSessionManager {
+    static readonly CURRENT_VERSION = 1;
+    /**
+     * Serializes current WindowManager state into a JSON-compatible object.
+     */
+    static serialize(windowManager: WindowManager, options?: {
+        activeWorkspace?: string;
+    }): DesktopSerializedSession;
+    /**
+     * Restores windows from a serialized session into a WindowManager instance.
+     */
+    static restore(windowManager: WindowManager, session: DesktopSerializedSession, options?: {
+        componentResolver?: (model: string) => any;
+    }): {
+        restoredCount: number;
+        errors: string[];
+    };
+}
+
+export { DesktopSessionManager };
+export type { DesktopSerializedSession, DesktopSerializedWindow };

package/dist/session/index.mjs

@@ -0,0 +1,65 @@
+class DesktopSessionManager {
+  static CURRENT_VERSION = 1;
+  /**
+   * Serializes current WindowManager state into a JSON-compatible object.
+   */
+  static serialize(windowManager, options) {
+    const windows = windowManager.getSnapshot();
+    const serializedWindows = windows.filter((win) => win.state.active).map((win) => {
+      return {
+        id: win.id,
+        model: win.model ?? "window",
+        workspace: win.state.workspace,
+        title: win.config.title,
+        position: win.state.position,
+        size: win.state.size,
+        maximized: win.state.maximized,
+        layout: win.state.layout,
+        spatial: win.state.spatial,
+        focused: win.state.focused
+      };
+    });
+    return {
+      version: DesktopSessionManager.CURRENT_VERSION,
+      timestamp: Date.now(),
+      activeWorkspace: options?.activeWorkspace,
+      windows: serializedWindows
+    };
+  }
+  /**
+   * Restores windows from a serialized session into a WindowManager instance.
+   */
+  static restore(windowManager, session, options) {
+    const errors = [];
+    let restoredCount = 0;
+    if (!session || typeof session !== "object" || !Array.isArray(session.windows)) {
+      return { restoredCount: 0, errors: ["Invalid session format"] };
+    }
+    for (const item of session.windows) {
+      try {
+        const component = options?.componentResolver?.(item.model);
+        windowManager.createWindow({
+          id: item.id,
+          model: item.model,
+          config: {
+            title: item.title,
+            component
+          },
+          initialState: {
+            workspace: item.workspace,
+            position: item.position,
+            size: item.size ?? { width: 640, height: 480 },
+            maximized: item.maximized,
+            spatial: item.spatial
+          }
+        });
+        restoredCount++;
+      } catch (err) {
+        errors.push(`Failed to restore window ${item.id}: ${err?.message || String(err)}`);
+      }
+    }
+    return { restoredCount, errors };
+  }
+}
+
+export { DesktopSessionManager };

package/dist/shared/core.B1XxB289.mjs

@@ -0,0 +1,239 @@
+import { g as globalDesktopHooks, a as globalIPCBus } from './core.Pd_Ogt4g.mjs';
+
+function shellEscape(str) {
+  if (str === "") {
+    return "''";
+  }
+  return `${str.replace(/'/g, `'\\''`)}`;
+}
+function padEnd(str, len) {
+  return str.length >= len ? str : str + " ".repeat(len - str.length);
+}
+function formatDuration(ms) {
+  const totalSec = Math.max(0, Math.floor(ms / 1e3));
+  const m = Math.floor(totalSec / 60);
+  const s = totalSec % 60;
+  return `${String(m).padStart(2, "0")}m ${String(s).padStart(2, "0")}s`;
+}
+function parseCommandLine(input) {
+  const trimmed = input.trim();
+  if (!trimmed) {
+    return { name: "", args: [] };
+  }
+  const [name = "", ...args] = trimmed.split(/\s+/);
+  return { name, args };
+}
+
+class DesktopKeybindings {
+  windowManager;
+  workareaProvider;
+  customHandlers = /* @__PURE__ */ new Map();
+  isListening = false;
+  listenerRef;
+  constructor(windowManager, options) {
+    this.windowManager = windowManager;
+    this.workareaProvider = options?.workareaProvider;
+  }
+  register(shortcut, handler) {
+    this.customHandlers.set(shortcut.toLowerCase(), handler);
+    return this;
+  }
+  listen() {
+    if (typeof window === "undefined" || this.isListening) {
+      return () => this.stop();
+    }
+    this.isListening = true;
+    this.listenerRef = (e) => this.handleKeyDown(e);
+    window.addEventListener("keydown", this.listenerRef);
+    return () => this.stop();
+  }
+  stop() {
+    if (typeof window !== "undefined" && this.listenerRef) {
+      window.removeEventListener("keydown", this.listenerRef);
+    }
+    this.isListening = false;
+  }
+  handleKeyDown(e) {
+    const activeEl = document.activeElement;
+    if (activeEl && (activeEl.tagName === "INPUT" || activeEl.tagName === "TEXTAREA" || activeEl.isContentEditable)) {
+      return;
+    }
+    const isMetaOrCtrl = e.metaKey || e.ctrlKey;
+    const isAlt = e.altKey;
+    const isShift = e.shiftKey;
+    const key = e.key.toLowerCase();
+    if (isAlt && key === "tab") {
+      e.preventDefault();
+      this.cycleWindowFocus(isShift ? "backward" : "forward");
+      return;
+    }
+    if (isMetaOrCtrl) {
+      const focused = this.windowManager.focusedWindow;
+      const workarea = this.workareaProvider?.() ?? {
+        x: 0,
+        y: 0,
+        width: typeof window !== "undefined" ? window.innerWidth : 1920,
+        height: typeof window !== "undefined" ? window.innerHeight : 1080
+      };
+      if (key === "arrowleft" && focused) {
+        e.preventDefault();
+        this.windowManager.snapWindow(focused.id, "left-half", workarea);
+        return;
+      }
+      if (key === "arrowright" && focused) {
+        e.preventDefault();
+        this.windowManager.snapWindow(focused.id, "right-half", workarea);
+        return;
+      }
+      if (key === "arrowup" && focused) {
+        e.preventDefault();
+        if (!focused.state.maximized) {
+          focused.maximize();
+        }
+        return;
+      }
+      if (key === "arrowdown" && focused) {
+        e.preventDefault();
+        if (focused.state.maximized) {
+          focused.unmaximize();
+        } else {
+          focused.minimize();
+        }
+        return;
+      }
+      if (key === "w" && focused && !e.shiftKey) {
+        e.preventDefault();
+        this.windowManager.closeWindow(focused.id);
+        return;
+      }
+    }
+  }
+  cycleWindowFocus(direction) {
+    const activeWindows = Array.from(this.windowManager.getSnapshot()).filter((w) => w.active);
+    if (activeWindows.length <= 1) return;
+    const focusedId = this.windowManager.focusedWindow?.id;
+    const currentIndex = activeWindows.findIndex((w) => w.id === focusedId);
+    let nextIndex = 0;
+    if (direction === "forward") {
+      nextIndex = (currentIndex + 1) % activeWindows.length;
+    } else {
+      nextIndex = (currentIndex - 1 + activeWindows.length) % activeWindows.length;
+    }
+    const nextWin = activeWindows[nextIndex];
+    if (nextWin) {
+      this.windowManager.focusWindow(nextWin.id);
+    }
+  }
+}
+
+class DesktopCommands {
+  commands = /* @__PURE__ */ new Map();
+  snapshotCache = Object.freeze([]);
+  subscribers = /* @__PURE__ */ new Set();
+  hooks;
+  ipc;
+  constructor(options) {
+    this.hooks = options?.hooks ?? globalDesktopHooks;
+    this.ipc = options?.ipc ?? globalIPCBus;
+  }
+  getSnapshot() {
+    return this.snapshotCache;
+  }
+  subscribe(callback) {
+    this.subscribers.add(callback);
+    callback(this.getSnapshot());
+    return () => {
+      this.subscribers.delete(callback);
+    };
+  }
+  notify() {
+    this.snapshotCache = Object.freeze(
+      Array.from(this.commands.values()).map(({ handler: _h, ...meta }) => Object.freeze({ ...meta }))
+    );
+    const snapshot = this.getSnapshot();
+    for (const sub of this.subscribers) {
+      try {
+        sub(snapshot);
+      } catch {
+      }
+    }
+  }
+  register(command, handler) {
+    this.commands.set(command.name, {
+      ...command,
+      handler
+    });
+    this.notify();
+    return () => {
+      this.unregister(command.name);
+    };
+  }
+  unregister(name) {
+    const deleted = this.commands.delete(name);
+    if (deleted) {
+      this.notify();
+    }
+    return deleted;
+  }
+  has(name) {
+    return this.commands.has(name);
+  }
+  getCommands() {
+    return this.getSnapshot();
+  }
+  async exec(input) {
+    const { name, args } = parseCommandLine(input);
+    if (!name) return void 0;
+    const execCtx = {
+      input,
+      commandName: name,
+      args,
+      cancel: false,
+      overrideOutput: void 0
+    };
+    await this.hooks.callHook("command:before-exec", execCtx);
+    if (execCtx.cancel) {
+      return execCtx.overrideOutput ?? {
+        message: `Command "${name}" execution cancelled by policy.`,
+        isError: true
+      };
+    }
+    const registered = this.commands.get(name);
+    if (!registered) {
+      const notFoundOutput = {
+        message: `${name}: command not found`,
+        isError: true
+      };
+      await this.hooks.callHook("command:after-exec", {
+        input,
+        commandName: name,
+        output: notFoundOutput
+      });
+      return notFoundOutput;
+    }
+    try {
+      const result = await registered.handler(args, input);
+      const output = typeof result === "string" ? { message: result, isError: false } : result;
+      this.ipc.emit("command:executed", { command: name, args }, { source: "commands" });
+      await this.hooks.callHook("command:after-exec", {
+        input,
+        commandName: name,
+        output
+      });
+      return output;
+    } catch (err) {
+      const errorOutput = {
+        message: err?.message || String(err),
+        isError: true
+      };
+      await this.hooks.callHook("command:after-exec", {
+        input,
+        commandName: name,
+        output: errorOutput
+      });
+      return errorOutput;
+    }
+  }
+}
+
+export { DesktopCommands as D, DesktopKeybindings as a, parseCommandLine as b, formatDuration as f, padEnd as p, shellEscape as s };