@addai/node 0.30.12 → 0.30.14

package/dist/direct/protocol.d.ts

@@ -0,0 +1,46 @@
+/** A separate protocol: never sent through the entity request queue or desktop relay. */
+export declare const DIRECT_PROTOCOL = 1;
+export declare const MAX_FRAME: number;
+export declare const MAX_INPUT: number;
+export declare const UUID: RegExp;
+export type Provider = 'claude' | 'codex';
+export type DirectRequest = {
+    type: 'request';
+    id: string;
+    op: 'describe' | 'list' | 'create' | 'attach' | 'input' | 'resize' | 'detach' | 'stop' | 'resume' | 'ack' | 'aios-result' | 'aios-access' | 'chat';
+    sessionId?: string;
+    provider?: Provider;
+    cwd?: string;
+    title?: string;
+    cols?: number;
+    rows?: number;
+    data?: string;
+    seq?: number;
+    aios?: boolean;
+    attachmentId?: string;
+    callId?: string;
+    ok?: boolean;
+    result?: unknown;
+    error?: string;
+    chat?: {
+        action: 'open' | 'history' | 'conversations' | 'send' | 'reply' | 'cancel' | 'detach';
+        binding?: unknown;
+        fresh?: boolean;
+        before?: number;
+        messageId?: string;
+        text?: string;
+        callId?: string;
+        ok?: boolean;
+        result?: unknown;
+        error?: string;
+        decision?: 'accept' | 'decline';
+        answers?: {
+            [id: string]: {
+                answers: string[];
+            };
+        };
+    };
+};
+export declare function parseRequest(value: unknown): DirectRequest;
+/** HTTPS in production; plaintext is limited to explicit loopback development. */
+export declare function relayUrl(raw: string, route: string): string;

package/dist/direct/protocol.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UUID = exports.MAX_INPUT = exports.MAX_FRAME = exports.DIRECT_PROTOCOL = void 0;
+exports.parseRequest = parseRequest;
+exports.relayUrl = relayUrl;
+/** A separate protocol: never sent through the entity request queue or desktop relay. */
+exports.DIRECT_PROTOCOL = 1;
+exports.MAX_FRAME = 256 * 1024;
+exports.MAX_INPUT = 32 * 1024;
+exports.UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+function parseRequest(value) {
+    if (!value || typeof value !== 'object')
+        throw new Error('Invalid request.');
+    const r = value;
+    if (r.type !== 'request' || !exports.UUID.test(r.id ?? ''))
+        throw new Error('Invalid request ID.');
+    if (!['describe', 'list', 'create', 'attach', 'input', 'resize', 'detach', 'stop', 'resume', 'ack', 'aios-result', 'aios-access', 'chat'].includes(r.op)) {
+        throw new Error('Unknown operation.');
+    }
+    if (!['describe', 'list'].includes(r.op) && !exports.UUID.test(r.sessionId ?? ''))
+        throw new Error('Invalid session ID.');
+    if (r.op === 'chat') {
+        const c = r.chat;
+        if (!c || !['open', 'history', 'conversations', 'send', 'reply', 'cancel', 'detach'].includes(c.action) || Buffer.byteLength(JSON.stringify(c)) > 64 * 1024)
+            throw new Error('Invalid chat request.');
+        if (c.action !== 'open' && !exports.UUID.test(r.attachmentId ?? ''))
+            throw new Error('Invalid chat attachment.');
+        if (c.action === 'open' && (c.fresh !== undefined && typeof c.fresh !== 'boolean'))
+            throw new Error('Invalid chat creation request.');
+        if (c.action === 'send' && (!exports.UUID.test(c.messageId ?? '') || typeof c.text !== 'string' || !c.text.trim() || c.text.length > exports.MAX_INPUT))
+            throw new Error('Invalid chat message.');
+        if (c.before !== undefined && (!Number.isSafeInteger(c.before) || c.before < 1))
+            throw new Error('Invalid chat history cursor.');
+        if (c.action === 'reply') {
+            if (!exports.UUID.test(c.callId ?? '') || (c.ok !== undefined && typeof c.ok !== 'boolean') || (c.decision !== undefined && !['accept', 'decline'].includes(c.decision)) ||
+                (c.error !== undefined && (typeof c.error !== 'string' || c.error.length > 1000)))
+                throw new Error('Invalid chat reply.');
+            if (c.answers !== undefined && (!c.answers || typeof c.answers !== 'object' || Array.isArray(c.answers) || Object.values(c.answers).some(a => !a || !Array.isArray(a.answers) || a.answers.some(t => typeof t !== 'string' || t.length > 4000))))
+                throw new Error('Invalid question answer.');
+        }
+    }
+    if (r.aios !== undefined && typeof r.aios !== 'boolean')
+        throw new Error('Invalid +Ai access setting.');
+    if (r.op === 'aios-access' && (typeof r.aios !== 'boolean' || !exports.UUID.test(r.attachmentId ?? '')))
+        throw new Error('Invalid +Ai access setting.');
+    if (r.op === 'aios-result') {
+        if (!exports.UUID.test(r.callId ?? '') || !exports.UUID.test(r.attachmentId ?? '') || typeof r.ok !== 'boolean' ||
+            (r.error !== undefined && (typeof r.error !== 'string' || r.error.length > 500)) ||
+            Buffer.byteLength(JSON.stringify(r.result) ?? '') > 64 * 1024)
+            throw new Error('Invalid +Ai result.');
+    }
+    if (r.op === 'create') {
+        if (r.provider !== 'claude' && r.provider !== 'codex')
+            throw new Error('Choose Claude Code or Codex.');
+        if (typeof r.cwd !== 'string' || !r.cwd.trim() || r.cwd.length > 4096 || /[\x00-\x1f]/.test(r.cwd)) {
+            throw new Error('Choose a project folder.');
+        }
+        if (r.title !== undefined && (typeof r.title !== 'string' || r.title.length > 100 || /[\x00-\x1f]/.test(r.title))) {
+            throw new Error('Invalid session title.');
+        }
+    }
+    if (r.op === 'input' && (typeof r.data !== 'string' || r.data.length > exports.MAX_INPUT))
+        throw new Error('Input is too large.');
+    if (r.op === 'ack' && (!Number.isSafeInteger(r.seq) || r.seq < 0))
+        throw new Error('Invalid output acknowledgment.');
+    if (r.op === 'resize' || r.op === 'create' || r.op === 'resume' || r.op === 'attach') {
+        if (!Number.isInteger(r.cols) || r.cols < 20 || r.cols > 400 ||
+            !Number.isInteger(r.rows) || r.rows < 5 || r.rows > 150)
+            throw new Error('Invalid terminal size.');
+    }
+    return r;
+}
+/** HTTPS in production; plaintext is limited to explicit loopback development. */
+function relayUrl(raw, route) {
+    const url = new URL(raw);
+    const local = ['127.0.0.1', 'localhost', '[::1]'].includes(url.hostname);
+    if (url.protocol !== 'wss:' && !(local && url.protocol === 'ws:'))
+        throw new Error('Direct sessions require a secure relay URL.');
+    if (url.username || url.password || url.search || url.hash || (url.pathname !== '/' && url.pathname !== '')) {
+        throw new Error('Use the relay origin without credentials, paths or query parameters.');
+    }
+    url.pathname = route;
+    return url.toString();
+}

package/dist/direct/relay-main.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/direct/relay-main.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const relay_1 = require("./relay");
+if (require.main === module) {
+    const { SUPABASE_URL, SUPABASE_ANON_KEY, DIRECT_ALLOWED_ORIGINS } = process.env;
+    if (!SUPABASE_URL || !SUPABASE_ANON_KEY || !DIRECT_ALLOWED_ORIGINS) {
+        throw new Error('Configure SUPABASE_URL, SUPABASE_ANON_KEY and DIRECT_ALLOWED_ORIGINS.');
+    }
+    const origins = DIRECT_ALLOWED_ORIGINS.split(',').map(s => s.trim()).filter(Boolean);
+    for (const origin of origins) {
+        const parsed = new URL(origin);
+        if (parsed.origin !== origin || (parsed.protocol !== 'https:' && !['localhost', '127.0.0.1'].includes(parsed.hostname))) {
+            throw new Error('Allowed origins must be exact HTTPS origins (or loopback development origins).');
+        }
+    }
+    const relay = (0, relay_1.createDirectRelay)({ auth: (0, relay_1.supabaseRelayAuth)(SUPABASE_URL, SUPABASE_ANON_KEY), origins });
+    const port = Number(process.env.PORT ?? 8788);
+    relay.server.listen(port, process.env.HOST ?? '127.0.0.1', () => console.log(`[direct-relay] listening on ${port}`));
+    process.once('SIGTERM', () => { void relay.close(); });
+    process.once('SIGINT', () => { void relay.close(); });
+}

package/dist/direct/relay.d.ts

@@ -0,0 +1,26 @@
+import { type IncomingMessage } from 'node:http';
+export interface NodeIdentity {
+    id: string;
+    ownerId: string;
+    name: string;
+}
+export interface UserIdentity {
+    id: string;
+    expiresAt: number;
+}
+export interface RelayAuth {
+    node(token: string): Promise<NodeIdentity | null>;
+    user(token: string): Promise<UserIdentity | null>;
+}
+export interface RelayOptions {
+    auth: RelayAuth;
+    origins: string[];
+    recheckMs?: number;
+}
+/** Independent server and node registry; never imported into the desktop relay. */
+export declare function createDirectRelay(options: RelayOptions): {
+    server: import("http").Server<typeof IncomingMessage, typeof import("http").ServerResponse>;
+    close(): Promise<void>;
+};
+/** Uses existing auth and runtime tables. No new SQL or existing RPC replacements. */
+export declare function supabaseRelayAuth(url: string, anonKey: string): RelayAuth;

package/dist/direct/relay.js

@@ -0,0 +1,334 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDirectRelay = createDirectRelay;
+exports.supabaseRelayAuth = supabaseRelayAuth;
+const node_http_1 = require("node:http");
+const node_crypto_1 = require("node:crypto");
+const ws_1 = __importStar(require("ws"));
+const protocol_1 = require("./protocol");
+function send(ws, value) {
+    if (ws.readyState !== ws_1.default.OPEN)
+        return false;
+    if (ws.bufferedAmount > 4 * 1024 * 1024) {
+        ws.close(1013, 'Connection cannot keep up. Reconnect.');
+        return false;
+    }
+    ws.send(JSON.stringify(value));
+    return true;
+}
+function bearer(req) {
+    const header = req.headers.authorization;
+    return header?.startsWith('Bearer ') ? header.slice(7) : null;
+}
+/** Independent server and node registry; never imported into the desktop relay. */
+function createDirectRelay(options) {
+    const relayId = (0, node_crypto_1.randomUUID)();
+    const nodes = new Map();
+    const viewers = new Map();
+    const sockets = new Set();
+    const origins = new Set(options.origins);
+    const wss = new ws_1.WebSocketServer({ noServer: true, maxPayload: protocol_1.MAX_FRAME, perMessageDeflate: false });
+    const server = (0, node_http_1.createServer)(async (req, res) => {
+        const pathname = new URL(req.url ?? '/', 'http://relay').pathname;
+        res.setHeader('Cache-Control', 'no-store');
+        if (pathname === '/health' && req.method === 'GET') {
+            res.setHeader('Content-Type', 'application/json');
+            res.end(JSON.stringify({ ok: true, protocol: protocol_1.DIRECT_PROTOCOL, relayId }));
+            return;
+        }
+        const origin = req.headers.origin;
+        if (!origin || !origins.has(origin)) {
+            res.writeHead(403);
+            res.end();
+            return;
+        }
+        res.setHeader('Access-Control-Allow-Origin', origin);
+        res.setHeader('Vary', 'Origin');
+        if (req.method === 'OPTIONS' && pathname === '/nodes') {
+            res.setHeader('Access-Control-Allow-Headers', 'Authorization');
+            res.setHeader('Access-Control-Allow-Methods', 'GET');
+            res.writeHead(204);
+            res.end();
+            return;
+        }
+        if (req.method !== 'GET' || pathname !== '/nodes') {
+            res.writeHead(404);
+            res.end();
+            return;
+        }
+        try {
+            const token = bearer(req);
+            const user = token ? await options.auth.user(token) : null;
+            if (!user || user.expiresAt <= Date.now()) {
+                res.writeHead(401);
+                res.end();
+                return;
+            }
+            res.setHeader('Content-Type', 'application/json');
+            res.end(JSON.stringify([...nodes.values()].filter(n => n.identity.ownerId === user.id)
+                .map(n => ({ id: n.identity.id, name: n.identity.name }))));
+        }
+        catch {
+            res.writeHead(503);
+            res.end();
+        }
+    });
+    function dropNode(node) {
+        if (nodes.get(node.identity.id) !== node)
+            return;
+        nodes.delete(node.identity.id);
+        for (const viewer of viewers.values())
+            if (viewer.node === node)
+                viewer.ws.close(1012, 'Machine disconnected. Reconnecting preserves running sessions.');
+    }
+    function dropViewer(viewer) {
+        if (viewers.get(viewer.id) !== viewer)
+            return;
+        viewers.delete(viewer.id);
+        send(viewer.node.ws, { type: 'detach_viewer', viewerId: viewer.id });
+    }
+    server.on('upgrade', (req, socket, head) => {
+        const url = new URL(req.url ?? '/', 'http://relay');
+        const match = /^\/client\/([0-9a-f-]{36})$/i.exec(url.pathname);
+        const isNode = url.pathname === '/node';
+        // Tokens are accepted only in the first frame, never in access-log URLs.
+        if (url.search || (!isNode && (!match || !protocol_1.UUID.test(match[1]) || !origins.has(req.headers.origin ?? '')))) {
+            socket.destroy();
+            return;
+        }
+        wss.handleUpgrade(req, socket, head, ws => {
+            sockets.add(ws);
+            let authenticating = false;
+            let node;
+            let viewer;
+            let inFlight = 0;
+            let windowStart = Date.now();
+            let frames = 0;
+            const timeout = setTimeout(() => ws.close(4001, 'Authentication required.'), 8000);
+            ws.on('error', () => { });
+            ws.on('pong', () => { if (node)
+                node.alive = true; if (viewer)
+                viewer.alive = true; });
+            ws.on('close', () => {
+                clearTimeout(timeout);
+                sockets.delete(ws);
+                if (node)
+                    dropNode(node);
+                if (viewer)
+                    dropViewer(viewer);
+            });
+            ws.on('message', async (raw, binary) => {
+                try {
+                    if (binary) {
+                        ws.close(1003, 'JSON frames required.');
+                        return;
+                    }
+                    const message = JSON.parse(raw.toString());
+                    if (!node && !viewer) {
+                        if (authenticating || message.type !== 'authenticate' || typeof message.token !== 'string' || message.token.length > 16_384) {
+                            ws.close(4001, 'Authentication required.');
+                            return;
+                        }
+                        authenticating = true;
+                        if (isNode) {
+                            const identity = await options.auth.node(message.token);
+                            if (!identity || !protocol_1.UUID.test(identity.id) || !protocol_1.UUID.test(identity.ownerId)) {
+                                ws.close(4001, 'Authentication failed.');
+                                return;
+                            }
+                            if (ws.readyState !== ws_1.default.OPEN)
+                                return;
+                            const prior = nodes.get(identity.id);
+                            if (prior) {
+                                dropNode(prior);
+                                prior.ws.close(1012, 'Direct-session worker replaced.');
+                            }
+                            node = { ws, identity, token: message.token, alive: true };
+                            nodes.set(identity.id, node);
+                            send(ws, { type: 'ready', protocol: protocol_1.DIRECT_PROTOCOL, runtimeId: identity.id, relayId });
+                        }
+                        else {
+                            const user = await options.auth.user(message.token);
+                            const target = nodes.get(match[1]);
+                            // Raw machine access is owner-only. Workspace/entity grants never imply shell access.
+                            if (!user || user.expiresAt <= Date.now() || !target || target.identity.ownerId !== user.id) {
+                                ws.close(4003, 'Machine unavailable or access denied.');
+                                return;
+                            }
+                            if (ws.readyState !== ws_1.default.OPEN)
+                                return;
+                            viewer = { ws, id: (0, node_crypto_1.randomUUID)(), node: target, user, token: message.token, alive: true };
+                            viewers.set(viewer.id, viewer);
+                            send(ws, { type: 'ready', protocol: protocol_1.DIRECT_PROTOCOL, chat: 1 });
+                        }
+                        clearTimeout(timeout);
+                        return;
+                    }
+                    if (node) {
+                        if (!['response', 'snapshot', 'event'].includes(message.type) || !protocol_1.UUID.test(message.viewerId ?? ''))
+                            return;
+                        const target = viewers.get(message.viewerId);
+                        if (!target || target.node !== node || target.user.id !== node.identity.ownerId)
+                            return;
+                        const { viewerId: _viewerId, ...out } = message;
+                        send(target.ws, out);
+                        return;
+                    }
+                    if (!viewer || viewer.user.expiresAt <= Date.now() || nodes.get(viewer.node.identity.id) !== viewer.node) {
+                        ws.close(4001, 'Reconnect to authenticate.');
+                        return;
+                    }
+                    if (Date.now() - windowStart > 1000) {
+                        frames = 0;
+                        windowStart = Date.now();
+                    }
+                    if (++frames > 240 || ++inFlight > 128) {
+                        ws.close(1008, 'Too many requests.');
+                        return;
+                    }
+                    try {
+                        const request = (0, protocol_1.parseRequest)(message);
+                        send(viewer.node.ws, { type: 'request', viewerId: viewer.id, ownerId: viewer.user.id, request });
+                    }
+                    finally {
+                        inFlight--;
+                    }
+                }
+                catch {
+                    ws.close(1008, 'Invalid direct-session message.');
+                }
+            });
+        });
+    });
+    let checking = false;
+    const interval = setInterval(async () => {
+        if (checking)
+            return;
+        checking = true;
+        try {
+            await Promise.all([...nodes.values()].map(async (node) => {
+                if (!node.alive) {
+                    node.ws.terminate();
+                    return;
+                }
+                node.alive = false;
+                node.ws.ping();
+                try {
+                    const identity = await options.auth.node(node.token);
+                    if (!identity || identity.id !== node.identity.id || identity.ownerId !== node.identity.ownerId)
+                        node.ws.close(4001, 'Pairing changed.');
+                }
+                catch {
+                    node.ws.close(1013, 'Unable to verify pairing.');
+                }
+            }));
+            await Promise.all([...viewers.values()].map(async (viewer) => {
+                if (!viewer.alive || viewer.user.expiresAt <= Date.now()) {
+                    viewer.ws.close(4001, 'Reconnect to authenticate.');
+                    return;
+                }
+                viewer.alive = false;
+                viewer.ws.ping();
+                try {
+                    const user = await options.auth.user(viewer.token);
+                    if (!user || user.id !== viewer.user.id || user.expiresAt <= Date.now())
+                        viewer.ws.close(4001, 'Authentication expired.');
+                }
+                catch {
+                    viewer.ws.close(1013, 'Unable to verify authentication.');
+                }
+            }));
+        }
+        finally {
+            checking = false;
+        }
+    }, options.recheckMs ?? 30_000);
+    interval.unref();
+    return {
+        server,
+        async close() {
+            clearInterval(interval);
+            for (const ws of sockets)
+                ws.terminate();
+            wss.close();
+            if (server.listening)
+                await new Promise(resolve => server.close(() => resolve()));
+        },
+    };
+}
+/** Uses existing auth and runtime tables. No new SQL or existing RPC replacements. */
+function supabaseRelayAuth(url, anonKey) {
+    async function json(route, key, token, init = {}) {
+        const response = await fetch(`${url.replace(/\/$/, '')}${route}`, {
+            ...init, signal: AbortSignal.timeout(8000),
+            headers: { apikey: key, Authorization: `Bearer ${token}`, 'Content-Type': 'application/json' },
+        });
+        if (!response.ok)
+            throw new Error('Authentication service unavailable.');
+        return response.json();
+    }
+    return {
+        async node(token) {
+            // The existing SECURITY DEFINER RPC validates the pairing token and returns
+            // only its own runtime. No administrator key or unrestricted table read.
+            const r = await json('/rest/v1/rpc/runtime_self', anonKey, anonKey, { method: 'POST', body: JSON.stringify({ p_token: token }) });
+            if (!r || !protocol_1.UUID.test(r.id ?? '') || !protocol_1.UUID.test(r.owner_user_id ?? ''))
+                return null;
+            return { id: r.id, ownerId: r.owner_user_id, name: typeof r.name === 'string' && r.name ? r.name : 'Paired machine' };
+        },
+        async user(token) {
+            // Verify with Supabase before inspecting the already-verified token's expiration.
+            let user;
+            try {
+                user = await json('/auth/v1/user', anonKey, token);
+            }
+            catch {
+                return null;
+            }
+            if (!user.id || !protocol_1.UUID.test(user.id))
+                return null;
+            try {
+                const claims = JSON.parse(Buffer.from(token.split('.')[1], 'base64url').toString());
+                if (claims.sub !== user.id || !Number.isFinite(claims.exp))
+                    return null;
+                return { id: user.id, expiresAt: claims.exp * 1000 };
+            }
+            catch {
+                return null;
+            }
+        },
+    };
+}

package/dist/direct/sessions.d.ts

@@ -0,0 +1,61 @@
+import { type Provider } from './protocol';
+import { type DesktopCall } from './aios-tools';
+export interface SessionRecord {
+    id: string;
+    ownerId: string;
+    provider: Provider;
+    cwd: string;
+    title: string;
+    createdAt: string;
+    updatedAt: string;
+    status: 'running' | 'exited';
+    nativeSessionId?: string;
+    exitCode?: number;
+    reason?: string;
+    aios?: boolean;
+}
+export interface TerminalProcess {
+    write(data: string): void;
+    resize(cols: number, rows: number): void;
+    kill(): void;
+    pause?(): void;
+    resume?(): void;
+    onData(cb: (data: string) => void): unknown;
+    onExit(cb: (event: {
+        exitCode: number;
+    }) => void): unknown;
+}
+export interface SessionDeps {
+    directory: string;
+    roots: string[];
+    maxActive?: number;
+    providers: () => Record<Provider, boolean>;
+    spawn: (record: SessionRecord, size: {
+        cols: number;
+        rows: number;
+    }, resume: boolean, desktop: DesktopCall) => TerminalProcess;
+    emit: (viewerId: string, event: Record<string, unknown>) => void;
+    onCount?: (count: number) => void;
+    canStart?: () => boolean;
+}
+export declare function isWithin(root: string, folder: string): boolean;
+export declare class DirectSessions {
+    private deps;
+    private records;
+    private live;
+    private roots;
+    private shuttingDown;
+    constructor(deps: SessionDeps);
+    get count(): number;
+    private save;
+    private folder;
+    private owned;
+    private controlled;
+    private start;
+    request(viewerId: string, ownerId: string, value: unknown): Promise<unknown>;
+    detach(viewerId: string): void;
+    detachAll(): void;
+    stop(): void;
+    private cancelCalls;
+    callDesktop(id: string, name: string, args: Record<string, unknown>): Promise<unknown>;
+}