@owear/core 0.1.0 → 0.1.3

package/dist/index.js

@@ -13,258 +13,29 @@
 //     win.loadURL('http://localhost:5173')
 //   })
 //
-import * as net from 'node:net';
-import { EventEmitter } from 'node:events';
 import * as os from 'node:os';
-import * as path from 'node:path';
-import * as fs from 'node:fs';
-class ControlChannel extends EventEmitter {
-    socket = null;
-    buffer = '';
-    nextId = 1;
-    pending = new Map();
-    connect(socketPath) {
-        return new Promise((resolve, reject) => {
-            const sock = net.connect(socketPath);
-            sock.once('connect', () => {
-                this.socket = sock;
-                resolve();
-            });
-            sock.once('error', (err) => {
-                this.socket = null;
-                this.rejectAllPending(err);
-                reject(err);
-            });
-            sock.on('data', (chunk) => {
-                this.buffer += chunk.toString('utf8');
-                let idx;
-                while ((idx = this.buffer.indexOf('\n')) >= 0) {
-                    const line = this.buffer.slice(0, idx);
-                    this.buffer = this.buffer.slice(idx + 1);
-                    if (line.trim())
-                        this.handleLine(line);
-                }
-            });
-            sock.on('close', () => {
-                this.socket = null;
-                this.rejectAllPending(new Error('conexión cerrada'));
-                this.emit('disconnected');
-            });
-        });
-    }
-    rejectAllPending(err) {
-        for (const { reject } of this.pending.values()) {
-            reject(err);
-        }
-        this.pending.clear();
-    }
-    handleLine(line) {
-        let msg;
-        try {
-            msg = JSON.parse(line);
-        }
-        catch {
-            return;
-        }
-        if (msg.event) {
-            this.emit(msg.event, msg.params);
-            return;
-        }
-        const p = this.pending.get(msg.id);
-        if (!p)
-            return;
-        this.pending.delete(msg.id);
-        if (msg.ok)
-            p.resolve(msg.result);
-        else
-            p.reject(new Error(msg.error ?? 'error de control'));
-    }
-    call(cmd, params = {}) {
-        if (!this.socket)
-            return Promise.reject(new Error('control socket desconectado'));
-        const id = this.nextId++;
-        return new Promise((resolve, reject) => {
-            this.pending.set(id, { resolve, reject });
-            this.socket.write(JSON.stringify({ id, cmd, params }) + '\n');
-        });
-    }
-}
-// ── app ─────────────────────────────────────────────────────────────────────
-const channel = new ControlChannel();
-function socketPathFromEnv() {
-    if (process.env.OW_CONTROL_SOCKET)
-        return process.env.OW_CONTROL_SOCKET;
-    // fallback: último socket vivo en XDG_RUNTIME_DIR (útil para depurar)
-    const dir = process.env.XDG_RUNTIME_DIR;
-    if (dir) {
-        try {
-            const socks = fs
-                .readdirSync(dir)
-                .filter((f) => f.startsWith('owear-') && f.endsWith('.sock'))
-                .sort();
-            if (socks.length)
-                return path.join(dir, socks[socks.length - 1]);
-        }
-        catch {
-            /* noop */
-        }
-    }
-    throw new Error('Owear: OW_CONTROL_SOCKET no definida. Lanza la app con `ow dev` o `ow build && owear`.');
-}
-let readyPromise = null;
-export const app = {
-    /** Conecta con el kernel. Resuelve cuando el canal de control está listo. */
-    whenReady() {
-        if (!readyPromise) {
-            readyPromise = channel.connect(socketPathFromEnv()).then(() => undefined);
-        }
-        return readyPromise;
-    },
-    quit(exitCode = 0) {
-        return channel.call('app.quit', { exitCode }).catch(() => undefined);
-    },
-    info() {
-        return channel.call('app.info');
-    },
-    /**
-     * Localiza (o descarga) un runtime Node. Prioridad: OW_NODE_BIN → Node del
-     * sistema → caché de Owear → descarga oficial. `source` indica de dónde
-     * salió ("env" | "system" | "cache" | "downloaded").
-     */
-    ensureNodeRuntime(range = 'latest') {
-        return channel.call('node.ensure', { range });
-    },
-    /** Acceso crudo al canal (para módulos custom del SDK). */
-    __channel: channel,
-};
-/**
- * Invoca una función de un módulo nativo del kernel desde el proceso
- * principal (fs, process, net, clipboard…). Es el equivalente de `ow.invoke()`
- * del renderer, pero sin depender de una ventana: es la pieza que permite
- * portar APIs de Electron al main process.
- *
- *   const txt = await invokeNative<string>('fs', 'readText', '/etc/hostname')
- */
-export function invokeNative(module, method, ...args) {
-    return channel.call('module.invoke', { module, method, args });
-}
-/** Módulos nativos cargados, con versión, origen y funciones. */
-export function listNativeModules() {
-    return channel.call('module.list');
-}
-/** Metadatos de un módulo nativo concreto. Rechaza si no existe. */
-export function nativeModuleInfo(name) {
-    return channel.call('module.info', { name });
-}
-// ── BrowserWindow ───────────────────────────────────────────────────────────
-export class BrowserWindow extends EventEmitter {
-    _id = null;
-    _options;
-    _onWindowEvent;
-    _onDisconnected;
-    constructor(options = {}) {
-        super();
-        this._options = options;
-        if (!readyPromise) {
-            throw new Error('BrowserWindow creado antes de app.whenReady()');
-        }
-        this._onWindowEvent = (params) => {
-            if (params.windowId !== this._id)
-                return;
-            this.emit(params.name, params.payload);
-            if (params.name === 'closed')
-                this._unwireEvents();
-        };
-        this._onDisconnected = () => this.emit('disconnected');
-        readyPromise.then(() => this._create()).catch((e) => this.emit('error', e));
-    }
-    async _create() {
-        const params = { ...this._options };
-        const res = await channel.call('window.create', params);
-        this._id = res.windowId;
-        this._wireEvents();
-        this.emit('ready-to-show', this._id);
-    }
-    _wireEvents() {
-        channel.on('window.event', this._onWindowEvent);
-        channel.on('disconnected', this._onDisconnected);
-    }
-    _unwireEvents() {
-        channel.off('window.event', this._onWindowEvent);
-        channel.off('disconnected', this._onDisconnected);
-    }
-    get id() {
-        return this._id;
-    }
-    requireId() {
-        if (this._id == null)
-            throw new Error('ventana aún no creada');
-        return this._id;
-    }
-    // ── carga ──────────────────────────────────────────────────────────────
-    loadURL(url) {
-        return channel.call('window.loadURL', { windowId: this.requireId(), url });
-    }
-    /** Evalúa JS; devuelve el resultado JSON-serializado. */
-    eval(js) {
-        return channel.call('window.eval', { windowId: this.requireId(), js });
-    }
-    // ── ciclo de vida ──────────────────────────────────────────────────────
-    show() {
-        return channel.call('window.show', { windowId: this.requireId() });
-    }
-    hide() {
-        return channel.call('window.hide', { windowId: this.requireId() });
-    }
-    focus() {
-        return channel.call('window.focus', { windowId: this.requireId() });
-    }
-    close() {
-        return channel.call('window.close', { windowId: this.requireId() });
-    }
-    destroy() {
-        return channel.call('window.destroy', { windowId: this.requireId() });
-    }
-    minimize() {
-        return channel.call('window.minimize', { windowId: this.requireId() });
-    }
-    maximize() {
-        return channel.call('window.maximize', { windowId: this.requireId(), enabled: true });
-    }
-    unmaximize() {
-        return channel.call('window.maximize', { windowId: this.requireId(), enabled: false });
-    }
-    setFullScreen(enabled) {
-        return channel.call('window.setFullScreen', { windowId: this.requireId(), enabled });
-    }
-    /**
-     * Responde a un `closeRequested` (F3.4).
-     * `allow=false` cancela el cierre; `true` destruye la ventana.
-     * Si nadie responde en `OW_CLOSE_TIMEOUT_MS` (default 1000 ms), el kernel
-     * cierra igualmente.
-     */
-    closeRespond(requestId, allow) {
-        return channel.call('window.respondCloseRequest', {
-            windowId: this.requireId(),
-            requestId,
-            allow,
-        });
-    }
-    // ── estado ─────────────────────────────────────────────────────────────
-    isMaximized() {
-        return channel.call('window.isMaximized', { windowId: this.requireId() });
-    }
-    isMinimized() {
-        return channel.call('window.isMinimized', { windowId: this.requireId() });
-    }
-    getBounds() {
-        return channel.call('window.getBounds', { windowId: this.requireId() });
-    }
-    setBounds(b) {
-        return channel.call('window.setBounds', { windowId: this.requireId(), ...b });
-    }
-    setTitle(title) {
-        return channel.call('window.setTitle', { windowId: this.requireId(), title });
-    }
-}
+export { NativeImage, nativeImage } from './nativeimage.js';
+export { invokeNative } from './channel.js';
+export { listNativeModules, nativeModuleInfo } from './modules.js';
+export { theme, nativeTheme } from './theme.js';
+export { screen } from './screen.js';
+export { powerMonitor, powerSaveBlocker } from './power.js';
+export { safeStorage } from './safestorage.js';
+export { session } from './session.js';
+export { webRequest } from './webrequest.js';
+export { dialog } from './dialog.js';
+export { WebContents } from './webcontents.js';
+export { BrowserWindow } from './browserwindow.js';
+export { MenuItem, Menu } from './menu.js';
+export { Tray } from './tray.js';
+export { nodeHandlers, nodeContextHandlers } from './ipc/node.js';
+export { protocolHandlers } from './protocol.js';
+export { portRecords, makeMainPort, allocPortId } from './port.js';
+export { app } from './app.js';
+export { readyPromise } from './app.js';
+// ── instalador (D1): bridge + API del modo instalador/desinstalador ──────────
+export { installer } from './installer.js';
+export { defineBridge } from './bridge.js';
+// ── workers Node (utilityProcess.fork) ──────────────────────────────────────
+export { forkWorker, resolveWorkerEntry } from './node/worker.js';
 export const platform = os.platform();

package/dist/installer.d.ts

@@ -0,0 +1,112 @@
+export type InstallerMode = 'app' | 'installer' | 'uninstaller';
+/** Entrada del plan de instalación (ruta en payload → destino). */
+export interface PayloadEntry {
+    /** Ruta relativa dentro del payload embebido. */
+    rel: string;
+    /** Ruta destino (relativa al directorio de instalación). */
+    dst: string;
+    size: number;
+    dir: boolean;
+}
+/** Metadatos de la app que se instala (de `installer.json`). */
+export interface InstallerInfo {
+    appId?: string;
+    appName?: string;
+    version?: string;
+    mode?: InstallerMode;
+    publisher?: string;
+    icon?: string;
+    [k: string]: unknown;
+}
+export interface PlanOptions {
+    /** `minimal` = binario único; `layout` = árbol organizado. */
+    mode?: 'minimal' | 'layout';
+    /** `flat` = basename; `tree` = ruta relativa (default según mode). */
+    layout?: 'flat' | 'tree';
+    /** Orden de colocación (prefijos de ruta o grupos). */
+    order?: string[];
+}
+export interface InstallOptions extends PlanOptions {
+    /** Directorio de instalación. */
+    dir: string;
+    /** Ruta del desinstalador (si se indica, se registra en el S.O.). */
+    uninstaller?: string;
+    /** Publisher para el registro de desinstalación. */
+    publisher?: string;
+}
+export interface InstallResult {
+    installed: boolean;
+    dir: string;
+    mode: string;
+    files: number;
+}
+export interface UninstallResult {
+    removed: number;
+    dir: string;
+}
+export interface VerifyResult {
+    ok: boolean;
+    mismatches: string[];
+}
+export interface StateResult {
+    installed: boolean;
+    version?: string;
+    mode?: string;
+    app?: string;
+}
+export interface ShortcutOptions {
+    execPath: string;
+    iconPath?: string;
+    desktop?: boolean;
+    menu?: boolean;
+    startup?: boolean;
+}
+export interface LaunchOptions {
+    path: string;
+    args?: string[];
+}
+/**
+ * API del modo instalador. Requiere un binario compilado como instalador
+ * (payload embebido + `OW_MODE=installer`).
+ */
+export declare const installer: {
+    /** Modo del binario actual: 'app' | 'installer' | 'uninstaller'. */
+    mode(): Promise<InstallerMode>;
+    /** Metadatos de la app a instalar (config empaquetada por `ow build`). */
+    info(): Promise<InstallerInfo>;
+    /** Bridge embebido (contrato app ↔ installer). */
+    bridge<T = unknown>(): Promise<T | null>;
+    /** Lista los ficheros del payload embebido. */
+    payloadList(): Promise<PayloadEntry[]>;
+    /** Lee un fichero del payload (base64). */
+    payloadRead(path: string): Promise<{
+        path: string;
+        data: string;
+        size: number;
+    }>;
+    /** Plan de instalación (sin escribir nada). */
+    plan(opts?: PlanOptions): Promise<PayloadEntry[]>;
+    /** Instala el payload en `dir` (respeta `order`/`layout`). */
+    install(opts: InstallOptions): Promise<InstallResult>;
+    /** Desinstala (usa el manifiesto guardado en `dir`). */
+    uninstall(opts: {
+        dir: string;
+        keepData?: boolean;
+    }): Promise<UninstallResult>;
+    /** Verifica integridad de una instalación (hashes). */
+    verify(opts: {
+        dir: string;
+    }): Promise<VerifyResult>;
+    /** Estado de instalación en `dir`. */
+    state(opts: {
+        dir: string;
+    }): Promise<StateResult>;
+    /** Crea accesos directos / integración de escritorio. */
+    shortcuts(opts: ShortcutOptions): Promise<boolean>;
+    /** Lanza un ejecutable en segundo plano (p. ej. la app instalada). */
+    launch(opts: LaunchOptions): Promise<boolean>;
+    /** ¿El proceso corre elevado (root/admin)? */
+    elevate(): Promise<{
+        elevated: boolean;
+    }>;
+};

package/dist/installer.js

@@ -0,0 +1,72 @@
+// Copyright 2026 Owear Contributors
+// SPDX-License-Identifier: Apache-2.0
+//
+// @owear/core/src/installer.ts — API `installer` (modo instalador/desinstalador).
+//
+// Disponible en binarios compilados en modo installer/uninstaller (`OW_MODE`).
+// El instalador es una app Owear aparte que lleva embebido el payload de la app
+// y el bridge (contrato app ↔ installer).
+//
+//   import { installer } from '@owear/core'
+//   const mode = await installer.mode()            // 'installer'
+//   const plan = await installer.plan({ mode: 'minimal' })
+//   await installer.install({ dir: '~/.local/opt/miapp', mode: 'minimal' })
+import { invokeNative } from './channel.js';
+/**
+ * API del modo instalador. Requiere un binario compilado como instalador
+ * (payload embebido + `OW_MODE=installer`).
+ */
+export const installer = {
+    /** Modo del binario actual: 'app' | 'installer' | 'uninstaller'. */
+    mode() {
+        return invokeNative('installer', 'mode');
+    },
+    /** Metadatos de la app a instalar (config empaquetada por `ow build`). */
+    info() {
+        return invokeNative('installer', 'info');
+    },
+    /** Bridge embebido (contrato app ↔ installer). */
+    bridge() {
+        return invokeNative('installer', 'bridge');
+    },
+    /** Lista los ficheros del payload embebido. */
+    payloadList() {
+        return invokeNative('installer', 'payloadList');
+    },
+    /** Lee un fichero del payload (base64). */
+    payloadRead(path) {
+        return invokeNative('installer', 'payloadRead', { path });
+    },
+    /** Plan de instalación (sin escribir nada). */
+    plan(opts = {}) {
+        return invokeNative('installer', 'plan', opts);
+    },
+    /** Instala el payload en `dir` (respeta `order`/`layout`). */
+    install(opts) {
+        return invokeNative('installer', 'install', opts);
+    },
+    /** Desinstala (usa el manifiesto guardado en `dir`). */
+    uninstall(opts) {
+        return invokeNative('installer', 'uninstall', opts);
+    },
+    /** Verifica integridad de una instalación (hashes). */
+    verify(opts) {
+        return invokeNative('installer', 'verify', opts);
+    },
+    /** Estado de instalación en `dir`. */
+    state(opts) {
+        return invokeNative('installer', 'state', opts);
+    },
+    /** Crea accesos directos / integración de escritorio. */
+    shortcuts(opts) {
+        return invokeNative('installer', 'shortcuts', opts);
+    },
+    /** Lanza un ejecutable en segundo plano (p. ej. la app instalada). */
+    launch(opts) {
+        return invokeNative('installer', 'launch', opts);
+    },
+    /** ¿El proceso corre elevado (root/admin)? */
+    elevate() {
+        return invokeNative('installer', 'elevate');
+    },
+};

package/dist/ipc/node.d.ts

@@ -0,0 +1,7 @@
+export type NodeHandler = (...args: any[]) => unknown | Promise<unknown>;
+/** Handler con contexto: recibe la ventana de origen y luego los args. */
+export type ContextNodeHandler = (context: {
+    windowId: number;
+}, ...args: any[]) => unknown | Promise<unknown>;
+export declare const nodeHandlers: Map<string, NodeHandler>;
+export declare const nodeContextHandlers: Map<string, ContextNodeHandler>;

package/dist/ipc/node.js

@@ -0,0 +1,25 @@
+// Copyright 2026 Owear Contributors
+// SPDX-License-Identifier: Apache-2.0
+//
+// @owear/core/src/ipc/node.ts — puente Node (renderer ↔ main).
+import { channel } from '../channel.js';
+export const nodeHandlers = new Map();
+export const nodeContextHandlers = new Map();
+channel.on('node.request', (params) => {
+    const { reqId, fn, args, windowId } = params ?? {};
+    const handler = nodeHandlers.get(fn);
+    const ctxHandler = nodeContextHandlers.get(fn);
+    const argsArr = Array.isArray(args) ? args : args === undefined ? [] : [args];
+    Promise.resolve()
+        .then(() => ctxHandler
+        ? ctxHandler({ windowId: typeof windowId === 'number' ? windowId : 0 }, ...argsArr)
+        : handler
+            ? handler(...argsArr)
+            : undefined)
+        .then((result) => channel.call('node.respond', { reqId, ok: true, result }), (err) => channel.call('node.respond', {
+        reqId,
+        ok: false,
+        result: { message: err instanceof Error ? err.message : String(err) },
+    }))
+        .catch(() => undefined);
+});

package/dist/menu.d.ts

@@ -0,0 +1,56 @@
+import { BrowserWindow } from './browserwindow.js';
+export type MenuItemRole = 'undo' | 'redo' | 'cut' | 'copy' | 'paste' | 'pasteAndMatchStyle' | 'selectAll' | 'delete' | 'reload' | 'forceReload' | 'toggleDevTools' | 'resetZoom' | 'zoomIn' | 'zoomOut' | 'togglefullscreen' | 'minimize' | 'close' | 'quit' | 'about' | 'hide' | 'hideOthers' | 'unhide';
+export interface MenuItemConstructorOptions {
+    id?: string;
+    label?: string;
+    role?: MenuItemRole;
+    type?: 'normal' | 'separator' | 'submenu' | 'checkbox' | 'radio';
+    checked?: boolean;
+    enabled?: boolean;
+    visible?: boolean;
+    accelerator?: string;
+    sublabel?: string;
+    toolTip?: string;
+    submenu?: Array<MenuItemConstructorOptions | MenuItem> | Menu;
+    click?: (menuItem: MenuItem, window: BrowserWindow | undefined) => void;
+}
+export declare class MenuItem {
+    id: string;
+    label: string;
+    role?: MenuItemRole;
+    type: 'normal' | 'separator' | 'submenu' | 'checkbox' | 'radio';
+    checked: boolean;
+    enabled: boolean;
+    visible: boolean;
+    accelerator?: string;
+    sublabel?: string;
+    toolTip?: string;
+    submenu?: Menu;
+    click?: (menuItem: MenuItem, window: BrowserWindow | undefined) => void;
+    constructor(opts?: MenuItemConstructorOptions, idHint?: string);
+    _toJSON(): Record<string, unknown>;
+}
+/**
+ * Menú (estilo Electron, "Owear"): se construye en el main y los clicks llaman
+ * handlers del main.
+ *   Menu.setApplicationMenu(Menu.buildFromTemplate([...]))   // menubar (Windows)
+ *   menu.popup({ window: win })                              // contextual
+ */
+export declare class Menu {
+    items: MenuItem[];
+    private static _appMenu;
+    constructor(items?: MenuItem[]);
+    static buildFromTemplate(template: Array<MenuItemConstructorOptions | MenuItem>, idPrefix?: string): Menu;
+    static setApplicationMenu(menu: Menu | null): void;
+    static getApplicationMenu(): Menu | null;
+    append(item: MenuItem): void;
+    /** JSON del menú (registra los items para el dispatch de clicks). */
+    _toJSON(): unknown[];
+    /** Menú contextual nativo. `window` resuelve el id del click. */
+    popup(options?: {
+        window?: BrowserWindow;
+        x?: number;
+        y?: number;
+        items?: Array<MenuItemConstructorOptions | MenuItem>;
+    }): void;
+}