@kitsuned/webos-service 1.0.7

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Andrey Smirnov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/idle-timer.d.ts

@@ -0,0 +1,10 @@
+export declare class IdleTimer {
+    private readonly idleTimeout;
+    private readonly onQuit;
+    private counter;
+    private timer;
+    constructor(idleTimeout?: number | null, onQuit?: (() => void) | null);
+    acquire(): void;
+    release(): void;
+    private tick;
+}

package/dist/idle-timer.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IdleTimer = void 0;
+class IdleTimer {
+    idleTimeout;
+    onQuit;
+    counter = 0;
+    timer = null;
+    constructor(idleTimeout = null, onQuit = null) {
+        this.idleTimeout = idleTimeout;
+        this.onQuit = onQuit;
+        if (idleTimeout) {
+            this.timer = setTimeout(this.tick.bind(this), idleTimeout * 1000);
+        }
+        else {
+            // keep process alive by resuming stdin stream
+            process.stdin.resume();
+        }
+    }
+    acquire() {
+        this.counter++;
+        if (this.timer !== null) {
+            clearTimeout(this.timer);
+        }
+    }
+    release() {
+        this.counter--;
+        if (this.idleTimeout && this.counter === 0) {
+            this.timer = setTimeout(this.tick.bind(this), this.idleTimeout * 1000);
+        }
+    }
+    tick() {
+        this.onQuit?.();
+    }
+}
+exports.IdleTimer = IdleTimer;

package/dist/index.d.ts

@@ -0,0 +1,38 @@
+import { Message } from './message';
+type AnyRecord = Record<string, any>;
+export type LunaErrorResponse = {
+    returnValue: false;
+    errorCode?: number;
+    errorText: string;
+};
+export type LunaSuccessResponse<T> = {
+    returnValue?: true;
+} & T;
+export type LunaResponse<T extends AnyRecord> = LunaSuccessResponse<T> | LunaErrorResponse;
+export type Executor<TReq extends AnyRecord, TResp extends AnyRecord | void, TNext extends AnyRecord> = (payload: TReq, message: Message<TReq>) => AsyncGenerator<TNext, TResp> | Promise<TResp> | TResp;
+export type Client = Pick<Service, 'oneshot' | 'subscribe' | 'stream'> & {
+    id: string | null;
+};
+export declare const isLegacyBus: boolean;
+export declare class Service {
+    readonly id: string;
+    private readonly handleOutbound;
+    private readonly handlePublic;
+    private readonly handlePrivate;
+    private readonly idleTimer;
+    private readonly methods;
+    private readonly pending;
+    constructor(serviceId?: string, idleTimeout?: number | null, publicBus?: boolean);
+    register<TReq extends AnyRecord, TResp extends AnyRecord | void = AnyRecord | void, TNext extends AnyRecord = AnyRecord>(method: string, executor: Executor<TReq, TResp, TNext>, { bus }?: {
+        bus?: 'public' | 'private' | 'both';
+    }): void;
+    subscribe<T extends AnyRecord>(uri: string, params: AnyRecord, callback: (response: LunaResponse<T>) => void): () => void;
+    stream<T extends AnyRecord>(uri: string, params?: AnyRecord): AsyncGenerator<LunaResponse<T>, void>;
+    oneshot<T extends AnyRecord>(uri: string, params?: AnyRecord): Promise<LunaResponse<T>>;
+    unregister(): void;
+    private drainExecutor;
+    private handleRequest;
+    private handleCancel;
+    private handleQuit;
+}
+export {};

package/dist/index.js

@@ -0,0 +1,174 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Service = exports.isLegacyBus = void 0;
+const palmbus_1 = __importDefault(require("palmbus"));
+const fs_1 = require("fs");
+const path_1 = require("path");
+const async_utils_1 = require("@kitsuned/async-utils");
+const message_1 = require("./message");
+const idle_timer_1 = require("./idle-timer");
+function extractMethodPath(path) {
+    const lastSlashIndex = path.lastIndexOf('/');
+    if (lastSlashIndex <= 0) {
+        return ['/', path.slice(1)];
+    }
+    return [path.slice(0, lastSlashIndex), path.slice(lastSlashIndex + 1)];
+}
+function readServiceIdFromConfig() {
+    const path = (0, path_1.join)(process.cwd(), './services.json');
+    let config;
+    try {
+        config = JSON.parse((0, fs_1.readFileSync)(path, 'utf8'));
+    }
+    catch {
+        throw new Error('Failed to read "services.json" to get Service ID');
+    }
+    if (!config.id) {
+        throw new Error('Service ID is missing in "services.json"');
+    }
+    return config.id;
+}
+exports.isLegacyBus = (0, fs_1.existsSync)('/var/run/ls2/ls-hubd.private.pid');
+class Service {
+    id;
+    handleOutbound;
+    handlePublic;
+    handlePrivate;
+    idleTimer;
+    methods = new Map();
+    pending = new Map();
+    constructor(serviceId, idleTimeout = null, publicBus = true) {
+        this.idleTimer = new idle_timer_1.IdleTimer(idleTimeout, this.handleQuit.bind(this));
+        this.id = serviceId ?? readServiceIdFromConfig();
+        if (exports.isLegacyBus) {
+            this.handlePublic = new palmbus_1.default.Handle(this.id, true);
+            this.handlePublic.addListener('request', this.handleRequest.bind(this));
+            this.handlePublic.addListener('cancel', this.handleCancel.bind(this));
+            this.handlePrivate = new palmbus_1.default.Handle(this.id, false);
+            this.handlePrivate.addListener('request', this.handleRequest.bind(this));
+            this.handlePrivate.addListener('cancel', this.handleCancel.bind(this));
+        }
+        else {
+            const handle = new palmbus_1.default.Handle(this.id);
+            handle.addListener('request', this.handleRequest.bind(this));
+            handle.addListener('cancel', this.handleCancel.bind(this));
+            this.handlePublic = handle;
+            this.handlePrivate = handle;
+        }
+        this.handleOutbound = publicBus ? this.handlePublic : this.handlePrivate;
+    }
+    register(method, executor, { bus = 'both' } = {}) {
+        if (bus === 'public') {
+            this.handlePublic.registerMethod(...extractMethodPath(method));
+        }
+        else if (bus === 'private') {
+            this.handlePrivate.registerMethod(...extractMethodPath(method));
+        }
+        else if (bus === 'both') {
+            if (this.handlePublic !== this.handlePrivate) {
+                this.handlePublic.registerMethod(...extractMethodPath(method));
+            }
+            this.handlePrivate.registerMethod(...extractMethodPath(method));
+        }
+        this.methods.set(method, executor);
+    }
+    subscribe(uri, params, callback) {
+        const subscription = this.handleOutbound.subscribe(uri, JSON.stringify(params));
+        subscription.addListener('response', pMessage => {
+            const message = message_1.Message.fromPalmMessage(pMessage);
+            callback(message.payload);
+        });
+        return () => subscription.cancel();
+    }
+    async *stream(uri, params = { subscribe: true }) {
+        const sink = new async_utils_1.AsyncSink();
+        const cancel = this.subscribe(uri, params, payload => sink.push(payload));
+        try {
+            yield* sink;
+        }
+        finally {
+            cancel();
+        }
+    }
+    async oneshot(uri, params = {}) {
+        const generator = this.stream(uri, params);
+        const { value } = await generator.next();
+        await generator.return();
+        return value;
+    }
+    unregister() {
+        this.pending.clear();
+        this.handleOutbound.unregister();
+    }
+    async drainExecutor(executor, message) {
+        if (typeof executor !== 'object') {
+            executor = {};
+        }
+        if (Symbol.asyncIterator in executor) {
+            const isSubscription = message.payload.subscribe === true;
+            let it;
+            do {
+                if (message.cancelled) {
+                    await executor.throw(new Error('Subscription cancelled'));
+                    break;
+                }
+                it = await executor.next();
+                if (it.done) {
+                    message.respond({ returnValue: true, ...it.value });
+                }
+                else if (isSubscription && it.value) {
+                    message.respond(it.value);
+                }
+            } while (!it.done);
+            return;
+        }
+        if ('then' in executor) {
+            message.respond({ returnValue: true, ...await executor });
+            return;
+        }
+        message.respond({ returnValue: true, ...executor });
+    }
+    handleRequest(pMessage) {
+        const message = message_1.Message.fromPalmMessage(pMessage);
+        // essential to receive 'cancel' event
+        if (pMessage.isSubscription()) {
+            this.handleOutbound.subscriptionAdd(pMessage.uniqueToken(), pMessage);
+            this.pending.set(pMessage.uniqueToken(), message);
+        }
+        Promise.resolve(message)
+            .then(async (message) => {
+            // Luna won't allow calls to unregistered methods
+            const impl = this.methods.get(message.method);
+            this.idleTimer.acquire();
+            return this.drainExecutor(impl(message.payload, message), message);
+        })
+            .catch(e => {
+            console.error('webos-service: handleRequest:', e);
+            message.respond({
+                returnValue: false,
+                errorCode: -1,
+                errorText: e instanceof Error ? e.message : String(e),
+                errorStack: 'stack' in e.stack ? String(e.stack) : null,
+            });
+        })
+            .finally(() => {
+            this.pending.delete(pMessage.uniqueToken());
+            this.idleTimer.release();
+        });
+    }
+    handleCancel(pMessage) {
+        const token = pMessage.uniqueToken();
+        const message = this.pending.get(token);
+        if (message) {
+            message.cancelled = true;
+        }
+    }
+    handleQuit() {
+        this.handleOutbound.unregister();
+        process.nextTick(() => process.exit(0));
+    }
+}
+exports.Service = Service;

package/dist/message.d.ts

@@ -0,0 +1,18 @@
+export interface PalmMessage {
+    category(): string;
+    method(): string;
+    isSubscription(): boolean;
+    uniqueToken(): string;
+    token(): string;
+    payload(): string;
+    respond(serialized: string): string;
+}
+export declare class Message<T extends Record<string, any>> {
+    readonly ls2Message: PalmMessage;
+    readonly method: string;
+    readonly payload: T;
+    cancelled: boolean;
+    protected constructor(ls2Message: PalmMessage);
+    respond(message: Record<string, any>): void;
+    static fromPalmMessage<T extends Record<string, any> = Record<string, any>>(pMessage: PalmMessage): Message<T>;
+}

package/dist/message.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Message = void 0;
+function joinCategoryWithMethod(pMessage) {
+    let category = pMessage.category();
+    // keep / as is; normalize /example -> /example/
+    if (!category.endsWith('/')) {
+        category += '/';
+    }
+    return category + pMessage.method();
+}
+class Message {
+    ls2Message;
+    method;
+    payload;
+    cancelled = false;
+    constructor(ls2Message) {
+        this.ls2Message = ls2Message;
+        this.method = joinCategoryWithMethod(ls2Message);
+        this.payload = JSON.parse(ls2Message.payload());
+    }
+    respond(message) {
+        this.ls2Message.respond(JSON.stringify(message));
+    }
+    static fromPalmMessage(pMessage) {
+        return new Message(pMessage);
+    }
+}
+exports.Message = Message;

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@kitsuned/webos-service",
+  "version": "1.0.7",
+  "license": "MIT",
+  "scripts": {
+    "build": "tsc"
+  },
+  "type": "commonjs",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    "node": "./dist/index.js",
+    "types": "./dist/index.d.ts"
+  },
+  "dependencies": {
+    "@kitsuned/async-utils": "^1.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "25.4.0",
+    "typescript": "5.9.3"
+  },
+  "files": [
+    "dist",
+    "LICENSE",
+    "README.md",
+    "package.json"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/kitsuned/webos-service.git"
+  },
+  "packageManager": "yarn@4.13.0"
+}