@owdproject/nuxt 0.0.0-stage → 4.0.0-alpha.4

package/dist/runtime/composables/useDesktop.d.ts

@@ -0,0 +1,210 @@
+export declare function registerDesktopExtension(name: string, extension: any): void;
+export declare function useDesktop(): {
+    config: import("vue").ComputedRef<unknown>;
+    applications: {
+        define: (id: string, config: ApplicationConfig) => Promise<any>;
+        defineApp: (id: string, config: ApplicationConfig) => Promise<any>;
+        exec: (id: string, rawCommand: string) => Promise<CommandOutput>;
+        running: import("vue").ComputedRef<IApplicationController[]>;
+        processes: import("vue").ComputedRef<{
+            id: string;
+            title: string;
+            icon?: string;
+            category?: string;
+            pid: number | null;
+            state: string;
+            isRunning: boolean;
+            isSuspended: boolean;
+            windowCount: number;
+            startedAt: number | null;
+            controller: IApplicationController;
+        }[]>;
+        isRunning: (id: string | undefined) => boolean;
+        findByPid: (pid: number) => IApplicationController | undefined;
+        resolveApp: (idOrPid: string | number) => IApplicationController | undefined;
+        launch: (id: string, entryKey?: string, argument?: string) => Promise<any>;
+        suspend: (idOrPid: string | number) => boolean;
+        resume: (idOrPid: string | number) => boolean;
+        kill: (idOrPid: string | number, signal?: "SIGTERM" | "SIGKILL" | "SIGSTOP" | "SIGCONT") => boolean;
+        close: (id: string) => void;
+        list: import("vue").ComputedRef<any[]>;
+        categories: import("vue").ComputedRef<Record<string, IApplicationController[]>>;
+        apps: import("vue").Reactive<Map<string, IApplicationController>>;
+        get: (id: string) => any;
+        isAppDefined: (id: string) => boolean;
+        getSortedEntries: (sortBy?: import("./application/useDesktopApplicationRegistry.js").SortBy, visibility?: import("./application/useDesktopApplicationRegistry.js").Visibility) => import("vue").ComputedRef<any[]>;
+    };
+    services: Readonly<{
+        register: (id: string, service: any) => void;
+        unregister: (id: string) => void;
+        get: (id: string) => any;
+        has: (id: string) => boolean;
+    }>;
+    hooks: import("./useDesktopHooks.js").DesktopHooksAPI;
+    ipc: {
+        events: import("vue").Ref<{
+            id: string;
+            timestamp: number;
+            channel: string;
+            source: string;
+            severity: "info" | "warn" | "error";
+            payload?: any;
+        }[], import("./useDesktopIPC.js").DesktopKernelEvent[] | {
+            id: string;
+            timestamp: number;
+            channel: string;
+            source: string;
+            severity: "info" | "warn" | "error";
+            payload?: any;
+        }[]>;
+        activeChannels: import("vue").ComputedRef<string[]>;
+        emit: (channel: string, payload?: any, options?: {
+            source?: string;
+            severity?: "info" | "warn" | "error";
+        }) => import("./useDesktopIPC.js").DesktopKernelEvent;
+        on: (channel: string, handler: (event: import("./useDesktopIPC.js").DesktopKernelEvent) => void) => () => void;
+        off: (channel: string, handler: (event: import("./useDesktopIPC.js").DesktopKernelEvent) => void) => void;
+        clearEvents: () => void;
+    };
+    windows: {
+        list: import("vue").ComputedRef<IWindowController[]>;
+        index: import("vue").ComputedRef<Map<string, IWindowController>>;
+        activeWorkspaceWindows: import("vue").ComputedRef<IWindowController[]>;
+        focused: import("vue").ComputedRef<any>;
+        topMaximizedWindow: import("vue").ComputedRef<any>;
+        get: (windowId: string) => IWindowController | undefined;
+        tileWindows: (mode?: "horizontal" | "vertical" | "grid", workspaceId?: string) => number;
+        minimizeAll: (workspaceId?: string) => void;
+        restoreAll: (workspaceId?: string) => void;
+        close: (windowId: string) => void;
+        closeAll: (appId?: string) => void;
+    };
+    workspace: import("pinia").Store<"desktop/workspace", Pick<{
+        list: import("vue").Ref<string[], string[]>;
+        active: import("vue").Ref<string, string>;
+        overview: import("vue").Ref<boolean, boolean>;
+        workarea: import("vue").Ref<{
+            x: number;
+            y: number;
+            width: number;
+            height: number;
+        }, import("@owdproject/core").DesktopWorkareaRect | {
+            x: number;
+            y: number;
+            width: number;
+            height: number;
+        }>;
+        workspaceActiveIndex: import("vue").ComputedRef<number>;
+        setWorkspace: (workspaceId: string) => boolean;
+        setOverview: (value: boolean) => void;
+        toggleOverview: () => void;
+        setWorkarea: (rect: import("@owdproject/core").DesktopWorkareaRect) => void;
+        addWorkspace: (id?: string) => string;
+        removeWorkspace: (workspaceId: string) => boolean;
+        resolveWorkspaceFallback: (removedId: string) => string | null;
+    }, "list" | "active" | "overview" | "workarea">, Pick<{
+        list: import("vue").Ref<string[], string[]>;
+        active: import("vue").Ref<string, string>;
+        overview: import("vue").Ref<boolean, boolean>;
+        workarea: import("vue").Ref<{
+            x: number;
+            y: number;
+            width: number;
+            height: number;
+        }, import("@owdproject/core").DesktopWorkareaRect | {
+            x: number;
+            y: number;
+            width: number;
+            height: number;
+        }>;
+        workspaceActiveIndex: import("vue").ComputedRef<number>;
+        setWorkspace: (workspaceId: string) => boolean;
+        setOverview: (value: boolean) => void;
+        toggleOverview: () => void;
+        setWorkarea: (rect: import("@owdproject/core").DesktopWorkareaRect) => void;
+        addWorkspace: (id?: string) => string;
+        removeWorkspace: (workspaceId: string) => boolean;
+        resolveWorkspaceFallback: (removedId: string) => string | null;
+    }, "workspaceActiveIndex">, Pick<{
+        list: import("vue").Ref<string[], string[]>;
+        active: import("vue").Ref<string, string>;
+        overview: import("vue").Ref<boolean, boolean>;
+        workarea: import("vue").Ref<{
+            x: number;
+            y: number;
+            width: number;
+            height: number;
+        }, import("@owdproject/core").DesktopWorkareaRect | {
+            x: number;
+            y: number;
+            width: number;
+            height: number;
+        }>;
+        workspaceActiveIndex: import("vue").ComputedRef<number>;
+        setWorkspace: (workspaceId: string) => boolean;
+        setOverview: (value: boolean) => void;
+        toggleOverview: () => void;
+        setWorkarea: (rect: import("@owdproject/core").DesktopWorkareaRect) => void;
+        addWorkspace: (id?: string) => string;
+        removeWorkspace: (workspaceId: string) => boolean;
+        resolveWorkspaceFallback: (removedId: string) => string | null;
+    }, "setWorkspace" | "setOverview" | "toggleOverview" | "setWorkarea" | "addWorkspace" | "removeWorkspace" | "resolveWorkspaceFallback">>;
+    defaultApps: {
+        defaultApps: import("vue").ComputedRef<Record<string, {
+            applicationId: string;
+            entry: string;
+        }>>;
+        getDefaultApp: (feature: string) => {
+            applicationId: string;
+            entry: string;
+        };
+        setDefaultApp: (feature: string, application: IApplicationController, entry: string) => void;
+    };
+    identity: {
+        userId: import("vue").ComputedRef<string>;
+        displayName: import("vue").ComputedRef<string>;
+        avatarUrl: import("vue").ComputedRef<string | null>;
+        userHome: import("vue").ComputedRef<string>;
+        isGuest: import("vue").ComputedRef<boolean>;
+        setDesktopIdentity: (partial: Partial<import("./useDesktopIdentity.js").ShellIdentity>) => void;
+        clear: () => void;
+    };
+    session: {
+        shuttingDown: import("vue").Ref<boolean, boolean>;
+        initiateShutdownToStart: () => void;
+    };
+    commands: {
+        register: (command: DesktopCommand) => void;
+        list: () => string[];
+        get: (name: string) => DesktopCommand | undefined;
+        all: () => DesktopCommand[];
+        exec: (input: string) => Promise<CommandOutput | void>;
+        addCommand: (command: DesktopCommand) => void;
+        listCommands: () => string[];
+        getCommand: (name: string) => DesktopCommand | undefined;
+        getAllCommands: () => DesktopCommand[];
+        execCommand: (input: string) => Promise<CommandOutput | void>;
+    };
+    volume: {
+        master: import("vue").ComputedRef<number>;
+        setMaster: (value: number) => void;
+    };
+    notifications: {
+        list: any;
+        add: (payload: {
+            title: string;
+            body?: string;
+            icon?: string;
+            appId?: string;
+        }) => DesktopNotificationItem;
+        remove: (id: string) => void;
+        clear: () => void;
+        markAsRead: (id: string) => void;
+        markAllAsRead: () => void;
+    };
+    tray: {
+        items: import("vue").ComputedRef<any>;
+        registerIcon: (item: DesktopTrayItem) => void;
+        unregisterIcon: (id: string) => void;
+    };
+};

package/dist/runtime/composables/useDesktop.js

@@ -0,0 +1,52 @@
+import { reactive } from "vue";
+import { useDesktopWorkspaceStore } from "../stores/storeDesktopWorkspace.js";
+import { useDesktopConfig } from "./useDesktopConfig.js";
+import { useDesktopIdentity } from "./useDesktopIdentity.js";
+import { useDesktopSession } from "./useDesktopSession.js";
+import { useDesktopCommands } from "./useDesktopCommands.js";
+import { useDesktopDefaultApps } from "./useDesktopDefaultApps.js";
+import { useDesktopApplication } from "./useDesktopApplication.js";
+import { useDesktopWindow } from "./window/useDesktopWindow.js";
+import { useDesktopVolume } from "./useDesktopVolume.js";
+import { useDesktopNotification } from "./useDesktopNotification.js";
+import { useDesktopTray } from "./useDesktopTray.js";
+import { useDesktopIPC } from "./useDesktopIPC.js";
+import { useDesktopHooks } from "./useDesktopHooks.js";
+const services = reactive(/* @__PURE__ */ new Map());
+const extensions = reactive({});
+export function registerDesktopExtension(name, extension) {
+  extensions[name] = extension;
+}
+const servicesRegistry = Object.freeze({
+  register: (id, service) => {
+    services.set(id, service);
+  },
+  unregister: (id) => {
+    services.delete(id);
+  },
+  get: (id) => {
+    return services.get(id);
+  },
+  has: (id) => {
+    return services.has(id);
+  }
+});
+export function useDesktop() {
+  return {
+    config: useDesktopConfig(),
+    applications: useDesktopApplication(),
+    services: servicesRegistry,
+    hooks: useDesktopHooks(),
+    ipc: useDesktopIPC(),
+    windows: useDesktopWindow(),
+    workspace: useDesktopWorkspaceStore(),
+    defaultApps: useDesktopDefaultApps(),
+    identity: useDesktopIdentity(),
+    session: useDesktopSession(),
+    commands: useDesktopCommands(),
+    volume: useDesktopVolume(),
+    notifications: useDesktopNotification(),
+    tray: useDesktopTray(),
+    ...extensions
+  };
+}

package/dist/runtime/composables/useDesktopApplication.d.ts

@@ -0,0 +1,34 @@
+export declare function useDesktopApplication(): {
+    define: (id: string, config: ApplicationConfig) => Promise<any>;
+    defineApp: (id: string, config: ApplicationConfig) => Promise<any>;
+    exec: (id: string, rawCommand: string) => Promise<CommandOutput>;
+    running: import("vue").ComputedRef<IApplicationController[]>;
+    processes: import("vue").ComputedRef<{
+        id: string;
+        title: string;
+        icon?: string;
+        category?: string;
+        pid: number | null;
+        state: string;
+        isRunning: boolean;
+        isSuspended: boolean;
+        windowCount: number;
+        startedAt: number | null;
+        controller: IApplicationController;
+    }[]>;
+    isRunning: (id: string | undefined) => boolean;
+    findByPid: (pid: number) => IApplicationController | undefined;
+    resolveApp: (idOrPid: string | number) => IApplicationController | undefined;
+    launch: (id: string, entryKey?: string, argument?: string) => Promise<any>;
+    suspend: (idOrPid: string | number) => boolean;
+    resume: (idOrPid: string | number) => boolean;
+    kill: (idOrPid: string | number, signal?: "SIGTERM" | "SIGKILL" | "SIGSTOP" | "SIGCONT") => boolean;
+    close: (id: string) => void;
+    list: import("vue").ComputedRef<any[]>;
+    categories: import("vue").ComputedRef<Record<string, IApplicationController[]>>;
+    apps: import("vue").Reactive<Map<string, IApplicationController>>;
+    get: (id: string) => any;
+    isAppDefined: (id: string) => boolean;
+    getSortedEntries: (sortBy?: import("./application/useDesktopApplicationRegistry.js").SortBy, visibility?: import("./application/useDesktopApplicationRegistry.js").Visibility) => import("vue").ComputedRef<any[]>;
+};
+export declare const useDesktopApplications: typeof useDesktopApplication;

package/dist/runtime/composables/useDesktopApplication.js

@@ -0,0 +1,17 @@
+import { useDesktopApplicationRegistry } from "./application/useDesktopApplicationRegistry.js";
+import { useDesktopApplicationProcess } from "./application/useDesktopApplicationProcess.js";
+import { useDesktopApplicationExec } from "./application/useDesktopApplicationExec.js";
+import { useDesktopApplicationDefine } from "./application/useDesktopApplicationDefine.js";
+export function useDesktopApplication() {
+  const registry = useDesktopApplicationRegistry();
+  const process = useDesktopApplicationProcess();
+  const exec = useDesktopApplicationExec();
+  const define = useDesktopApplicationDefine();
+  return {
+    ...registry,
+    ...process,
+    ...exec,
+    ...define
+  };
+}
+export const useDesktopApplications = useDesktopApplication;

package/dist/runtime/composables/useDesktopCommands.d.ts

@@ -0,0 +1,12 @@
+export declare function useDesktopCommands(): {
+    register: (command: DesktopCommand) => void;
+    list: () => string[];
+    get: (name: string) => DesktopCommand | undefined;
+    all: () => DesktopCommand[];
+    exec: (input: string) => Promise<CommandOutput | void>;
+    addCommand: (command: DesktopCommand) => void;
+    listCommands: () => string[];
+    getCommand: (name: string) => DesktopCommand | undefined;
+    getAllCommands: () => DesktopCommand[];
+    execCommand: (input: string) => Promise<CommandOutput | void>;
+};

package/dist/runtime/composables/useDesktopCommands.js

@@ -0,0 +1,348 @@
+import { useDesktopApplication } from "./useDesktopApplication.js";
+import { useDesktopWindow } from "./window/useDesktopWindow.js";
+import { useDesktopWorkspaceStore } from "../stores/storeDesktopWorkspace.js";
+import { useDesktopNotification } from "./useDesktopNotification.js";
+import { useDesktopIPC } from "./useDesktopIPC.js";
+import { useDesktopHooks } from "./useDesktopHooks.js";
+import { debugLog } from "../utils/utilDebug.js";
+const commands = /* @__PURE__ */ new Map();
+const systemBootTimestamp = Date.now();
+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`;
+}
+const BUILTIN_COMMANDS = [
+  { name: "help", description: "Show available kernel and application commands", usage: "help [command]" },
+  { name: "ps", description: "List all registered processes, PIDs, and XState states", usage: "ps [-a]" },
+  { name: "open", description: "Launch an application by ID or short name", usage: "open <app-name>" },
+  { name: "kill", description: "Send a signal (SIGTERM/SIGKILL/SIGSTOP/SIGCONT) to a PID or app", usage: "kill [-s SIGNAL] <pid|app>" },
+  { name: "suspend", description: "Suspend a running process (SIGSTOP)", usage: "suspend <pid|app>" },
+  { name: "resume", description: "Resume a suspended process (SIGCONT)", usage: "resume <pid|app>" },
+  { name: "ws", description: "List or switch virtual workspaces (1..4)", usage: "ws [index]" },
+  { name: "tile", description: "Tile open windows in active workspace (horizontal|vertical|grid)", usage: "tile [horizontal|vertical|grid]" },
+  { name: "notify", description: "Dispatch a desktop system notification", usage: "notify <message>" },
+  { name: "ipc", description: "Emit an IPC event or inspect recent kernel events", usage: "ipc [emit <channel> <payload> | log]" },
+  { name: "uptime", description: "Show Open Web Desktop uptime and active process count", usage: "uptime" },
+  { name: "echo", description: "Print arguments to standard output", usage: "echo <text>" }
+];
+function buildHelpList() {
+  const appCmds = Array.from(commands.values()).sort(
+    (a, b) => a.name.localeCompare(b.name)
+  );
+  const allNames = [
+    ...BUILTIN_COMMANDS.map((c) => c.name),
+    ...appCmds.map((c) => c.name)
+  ];
+  const colWidth = Math.max(12, ...allNames.map((n) => n.length)) + 4;
+  const builtinRows = BUILTIN_COMMANDS.map(
+    (cmd) => `  ${padEnd(cmd.name, colWidth)}${cmd.description}`
+  ).join("\n");
+  const appRows = appCmds.map(
+    (cmd) => `  ${padEnd(cmd.name, colWidth)}${cmd.description ?? `Run ${cmd.name} (${cmd.applicationId})`}`
+  ).join("\n");
+  return `Open Web Desktop \u2014 Built-in Commands:
+` + builtinRows + (appRows ? `
+
+Application Commands:
+${appRows}` : "") + `
+
+Type 'help <command>' for usage details.`;
+}
+function buildHelpDetail(cmd) {
+  const lines = [];
+  lines.push(`  ${cmd.name}${cmd.description ? ` \u2014 ${cmd.description}` : ""}`);
+  lines.push("");
+  if (cmd.usage) {
+    lines.push(`  Usage: ${cmd.usage}`);
+    lines.push("");
+  }
+  if (cmd.args && cmd.args.length > 0) {
+    lines.push("  Arguments:");
+    const argColW = Math.max(...cmd.args.map((a) => a.name.length)) + 4;
+    for (const arg of cmd.args) {
+      const required = arg.required ? "" : " (optional)";
+      lines.push(
+        `    ${padEnd(arg.name, argColW)}${arg.description ?? ""}${required}`
+      );
+    }
+    lines.push("");
+  }
+  if (cmd.options && cmd.options.length > 0) {
+    lines.push("  Options:");
+    const optColW = Math.max(...cmd.options.map((o) => o.flag.length)) + 4;
+    for (const opt of cmd.options) {
+      lines.push(`    ${padEnd(opt.flag, optColW)}${opt.description ?? ""}`);
+    }
+    lines.push("");
+  }
+  return lines.join("\n").trimEnd();
+}
+export function useDesktopCommands() {
+  const register = (command) => {
+    commands.set(command.name, command);
+    debugLog(`Registered command: ${command.name} \u2192 ${command.applicationId}`);
+  };
+  const list = () => {
+    return [
+      ...BUILTIN_COMMANDS.map((c) => c.name),
+      ...Array.from(commands.keys())
+    ];
+  };
+  const get = (name) => {
+    return commands.get(name);
+  };
+  const all = () => {
+    return Array.from(commands.values());
+  };
+  const runCommandInternal = async (trimmed, name, rest) => {
+    const applications = useDesktopApplication();
+    const windows = useDesktopWindow();
+    const workspaceStore = useDesktopWorkspaceStore();
+    const notifications = useDesktopNotification();
+    const ipc = useDesktopIPC();
+    if (name === "help") {
+      const target = rest[0];
+      if (!target) {
+        return { message: buildHelpList() };
+      }
+      const builtin = BUILTIN_COMMANDS.find((c) => c.name === target);
+      if (builtin) {
+        return {
+          message: `  ${builtin.name} \u2014 ${builtin.description}
+  Usage: ${builtin.usage}`
+        };
+      }
+      const cmd = commands.get(target);
+      if (!cmd) {
+        return {
+          message: `help: command not found: '${target}'
+Type 'help' to list available commands.`,
+          isError: true
+        };
+      }
+      return { message: buildHelpDetail(cmd) };
+    }
+    if (name === "ps") {
+      const procs = applications.processes.value;
+      const header = `  ${padEnd("PID", 8)}${padEnd("STATE", 20)}${padEnd("WIN", 6)}${padEnd("UPTIME", 12)}APPLICATION`;
+      const divider = `  ${"-".repeat(72)}`;
+      const rows = procs.map((p) => {
+        const pidStr = p.pid ? String(p.pid) : "-";
+        const upStr = p.startedAt ? formatDuration(Date.now() - p.startedAt) : "-";
+        return `  ${padEnd(pidStr, 8)}${padEnd(p.state, 20)}${padEnd(String(p.windowCount), 6)}${padEnd(upStr, 12)}${p.title} (${p.id})`;
+      });
+      return {
+        message: [header, divider, ...rows].join("\n")
+      };
+    }
+    if (name === "open") {
+      const target = rest[0];
+      if (!target) {
+        return {
+          message: `Usage: open <app-name>
+Available apps: ${applications.processes.value.map((p) => p.title.toLowerCase()).join(", ")}`,
+          isError: true
+        };
+      }
+      try {
+        await applications.launch(target, void 0, rest.slice(1).join(" "));
+        const app = applications.resolveApp(target);
+        return {
+          message: `Launched ${app?.config.title ?? target} (PID ${app?.pid ?? "active"})`
+        };
+      } catch (err) {
+        return {
+          message: `open: ${err?.message ?? String(err)}`,
+          isError: true
+        };
+      }
+    }
+    if (name === "kill") {
+      let signal = "SIGTERM";
+      let target = rest[0];
+      if (target === "-9" || target === "-SIGKILL") {
+        signal = "SIGKILL";
+        target = rest[1];
+      } else if (target === "-s" && rest[1]) {
+        const sig = rest[1].toUpperCase();
+        if (sig === "SIGKILL" || sig === "SIGTERM" || sig === "SIGSTOP" || sig === "SIGCONT") {
+          signal = sig;
+        }
+        target = rest[2];
+      }
+      if (!target) {
+        return {
+          message: `Usage: kill [-9 | -s SIGNAL] <pid|app-id>`,
+          isError: true
+        };
+      }
+      const app = applications.resolveApp(target);
+      if (!app) {
+        return {
+          message: `kill: process '${target}' not found`,
+          isError: true
+        };
+      }
+      const pid = app.pid;
+      applications.kill(target, signal);
+      return {
+        message: `Sent ${signal} to ${app.config.title} (${app.id}${pid ? `, PID ${pid}` : ""})`
+      };
+    }
+    if (name === "suspend") {
+      const target = rest[0];
+      if (!target) {
+        return { message: "Usage: suspend <pid|app>", isError: true };
+      }
+      const ok = applications.suspend(target);
+      if (!ok) {
+        return { message: `suspend: running process '${target}' not found`, isError: true };
+      }
+      return { message: `Suspended process '${target}' (SIGSTOP)` };
+    }
+    if (name === "resume") {
+      const target = rest[0];
+      if (!target) {
+        return { message: "Usage: resume <pid|app>", isError: true };
+      }
+      const ok = applications.resume(target);
+      if (!ok) {
+        return { message: `resume: suspended process '${target}' not found`, isError: true };
+      }
+      return { message: `Resumed process '${target}' (SIGCONT)` };
+    }
+    if (name === "ws") {
+      const arg = rest[0];
+      const list2 = workspaceStore.list;
+      if (!arg) {
+        const lines = list2.map((id, idx2) => {
+          const activeMark = id === workspaceStore.active ? "*" : " ";
+          const winCount = windows.list.value.filter((w) => w.state.workspace === id).length;
+          return `  ${activeMark} Workspace ${idx2 + 1} [${id}] \u2014 ${winCount} window(s)`;
+        });
+        return { message: `Virtual Workspaces:
+${lines.join("\n")}` };
+      }
+      const idx = Number.parseInt(arg, 10) - 1;
+      if (Number.isNaN(idx) || idx < 0 || idx >= list2.length) {
+        return {
+          message: `ws: invalid workspace index '${arg}'. Valid range: 1..${list2.length}`,
+          isError: true
+        };
+      }
+      const targetId = list2[idx];
+      workspaceStore.setWorkspace(targetId);
+      ipc.emit("workspace:switched", { index: idx + 1, workspaceId: targetId }, { source: "cli" });
+      return { message: `Switched to Workspace ${idx + 1} [${targetId}]` };
+    }
+    if (name === "tile") {
+      const modeArg = (rest[0] || "horizontal").toLowerCase();
+      const mode = modeArg === "grid" || modeArg === "vertical" ? modeArg : "horizontal";
+      const count = windows.tileWindows(mode);
+      return {
+        message: count > 0 ? `Tiled ${count} active window(s) in '${mode}' layout.` : `No active windows in current workspace to tile.`
+      };
+    }
+    if (name === "notify") {
+      const body = rest.join(" ");
+      if (!body) {
+        return { message: "Usage: notify <message>", isError: true };
+      }
+      notifications.add({
+        title: "System CLI Notification",
+        body,
+        icon: "i-heroicons-command-line",
+        appId: "kernel.cli"
+      });
+      return { message: `Notification dispatched: "${body}"` };
+    }
+    if (name === "ipc") {
+      const sub = rest[0] || "log";
+      if (sub === "emit") {
+        const channel = rest[1];
+        const payload = rest.slice(2).join(" ");
+        if (!channel) {
+          return { message: "Usage: ipc emit <channel> [payload]", isError: true };
+        }
+        const evt = ipc.emit(channel, { message: payload || "CLI ping" }, { source: "cli" });
+        return { message: `Emitted IPC event [${evt.id}] on channel '${channel}'` };
+      }
+      const recent = ipc.events.value.slice(0, 10);
+      if (recent.length === 0) {
+        return { message: "No IPC kernel events recorded." };
+      }
+      const lines = recent.map((e) => {
+        const time = new Date(e.timestamp).toLocaleTimeString([], { hour12: false });
+        return `  [${time}] ${padEnd(e.channel, 20)} (${e.source}) \u2192 ${JSON.stringify(e.payload ?? {})}`;
+      });
+      return { message: `Recent Kernel IPC Events:
+${lines.join("\n")}` };
+    }
+    if (name === "uptime") {
+      const up = formatDuration(Date.now() - systemBootTimestamp);
+      const runningCount = applications.running.value.length;
+      const winCount = windows.list.value.length;
+      return {
+        message: `Open Web Desktop up ${up} | ${runningCount} active process(es) | ${winCount} open window(s)`
+      };
+    }
+    if (name === "echo") {
+      return { message: rest.join(" ") };
+    }
+    if (!commands.has(name)) {
+      return {
+        message: `Command not found: '${name}'
+Type 'help' to list available commands.`,
+        isError: true
+      };
+    }
+    const application = commands.get(name);
+    return applications.exec(application.applicationId, trimmed);
+  };
+  const exec = async (input) => {
+    const trimmed = input.trim();
+    const [name, ...rest] = trimmed.split(/\s+/);
+    if (!name) return;
+    const { callHook } = useDesktopHooks();
+    const execCtx = {
+      input: trimmed,
+      commandName: name,
+      args: rest,
+      cancel: false,
+      overrideOutput: void 0
+    };
+    await callHook("command:before-exec", execCtx);
+    if (execCtx.cancel) {
+      return execCtx.overrideOutput;
+    }
+    const output = execCtx.overrideOutput ?? await runCommandInternal(
+      execCtx.input,
+      execCtx.commandName,
+      execCtx.args
+    );
+    await callHook("command:after-exec", {
+      input: execCtx.input,
+      commandName: execCtx.commandName,
+      output
+    });
+    return output;
+  };
+  return {
+    register,
+    list,
+    get,
+    all,
+    exec,
+    // Retrocompatibility aliases for legacy apps (like app-terminal)
+    addCommand: register,
+    listCommands: list,
+    getCommand: get,
+    getAllCommands: all,
+    execCommand: exec
+  };
+}

package/dist/runtime/composables/useDesktopConfig.d.ts

@@ -0,0 +1,3 @@
+/** Reactive view of `runtimeConfig.public.desktop` (full desktop.config merge + coreVersion). */
+export declare function useDesktopConfig(): import("vue").ComputedRef<unknown>;
+export declare function useDesktopExtension<T = Record<string, unknown>>(key: string): import("vue").ComputedRef<T | undefined>;