dsh-plugin-dshm 0.0.0-stage → 0.1.1

package/lib/methods/index.js

@@ -0,0 +1,206 @@
+import { randomUUID } from 'node:crypto';
+import { methods } from '../protocol/scripts/contract.mjs';
+import { DmpError } from '../errors.js';
+export const capabilities = ['sessions', 'timeline', 'timeline.stream', 'send', 'interactions.approval', 'interactions.question', 'send.steer', 'queue.edit', 'model.select', 'permission.select', 'files.read', 'files.download', 'changes', 'deliverables', 'jobs', 'devices', 'attachments'];
+const implemented = new Set(['host.info', 'unsubscribe', 'sessions.list', 'sessions.watch', 'workspaces.list', 'sessions.create',
+    'session.watch', 'session.history', 'session.send', 'session.interrupt', 'interactions.list', 'interaction.answer', 'tool.output', 'timeline.text', 'session.queue.update', 'models.catalog', 'session.setModel', 'permissions.catalog', 'session.setPermission', 'files.list', 'files.read', 'files.stat', 'files.download', 'changes.summary', 'changes.diff', 'deliverables.list', 'deliverables.download', 'jobs.watch', 'job.watch', 'devices.list', 'devices.watch', 'devices.rename', 'devices.revoke', 'attachments.begin', 'attachments.finish', 'push.register', 'push.unregister']);
+const maxFrameBytes = 1048576;
+const clone = (value) => structuredClone(value);
+const encodedSize = (result) => Buffer.byteLength(JSON.stringify({ t: 'res', id: Number.MAX_SAFE_INTEGER, ok: true, result }));
+const orderSeq = (value) => {
+    const item = value;
+    return item.order.seq;
+};
+/** Remove oldest complete display groups until a snapshot/page fits. */
+export function fitPage(result) {
+    const out = clone(result);
+    if (encodedSize(out) <= maxFrameBytes)
+        return out;
+    if (!Array.isArray(out.items) || out.resumed === true)
+        throw new DmpError('too-large', 'Snapshot exceeds the frame budget', { limit: maxFrameBytes });
+    const items = out.items;
+    while (items.length && encodedSize(out) > maxFrameBytes) {
+        const oldest = Math.min(...items.map(orderSeq));
+        const keep = items.filter(item => orderSeq(item) !== oldest);
+        if (!keep.length)
+            throw new DmpError('too-large', 'A complete display group exceeds the frame budget', { limit: maxFrameBytes });
+        out.items = keep;
+        items.splice(0, items.length, ...keep);
+        out.items = items;
+        out.hasMoreBefore = true;
+    }
+    if (encodedSize(out) > maxFrameBytes)
+        throw new DmpError('too-large', 'Snapshot metadata exceeds the frame budget', { limit: maxFrameBytes });
+    return out;
+}
+export class CreationLedger {
+    entries = new Map();
+    async create(deviceId, params, peer) {
+        for (const [id, entry] of this.entries)
+            if (!entry.inFlight && entry.expires <= Date.now())
+                this.entries.delete(id);
+        const key = `${deviceId}:${params.sendId}`;
+        const parameters = JSON.stringify({ workspaceId: params.workspaceId, ...(params.text !== undefined ? { text: params.text } : {}) });
+        const old = this.entries.get(key);
+        if (old && old.expires <= Date.now())
+            this.entries.delete(key);
+        let entry = this.entries.get(key);
+        if (entry && entry.parameters !== parameters)
+            throw new DmpError('conflict', 'sendId already names different creation parameters');
+        if (!entry) {
+            entry = { key, parameters, sessionId: randomUUID(), expires: Date.now() + 86400000, created: false, prompted: false };
+            this.entries.set(key, entry);
+        }
+        if (entry.inFlight)
+            return entry.inFlight;
+        const target = entry;
+        // Socket cancellation must not forget a creation that may already exist.
+        // The target identity is reserved before crossing the native boundary.
+        const signal = AbortSignal.timeout(30000);
+        target.inFlight = (async () => {
+            if (!target.created) {
+                const snapshot = await peer.request('sessions.list', {}, signal);
+                const existing = snapshot.sessions.some(item => item.sessionId === target.sessionId);
+                if (!existing)
+                    await peer.create(String(params.workspaceId), target.sessionId, signal);
+                target.created = true;
+            }
+            if (typeof params.text === 'string' && params.text.length && !target.prompted) {
+                await peer.request('session.send', { sessionId: target.sessionId, sendId: params.sendId, text: params.text, mode: 'queue' }, signal);
+                target.prompted = true;
+            }
+            return { sessionId: target.sessionId };
+        })();
+        try {
+            return await target.inFlight;
+        }
+        finally {
+            target.inFlight = undefined;
+        }
+    }
+}
+export function createMethods(peer, context, ledger) {
+    const subscriptions = new Map();
+    let disposed = false;
+    const dispose = async () => {
+        if (disposed)
+            return;
+        disposed = true;
+        await Promise.allSettled([...subscriptions.values()].map(watch => watch.dispose()));
+        subscriptions.clear();
+        await peer.dispose();
+    };
+    return {
+        dispose,
+        async upload(sessionId, name, mime, bytes, signal) {
+            if (disposed)
+                throw new DmpError('dsh-unavailable');
+            return peer.upload(sessionId, name, mime, bytes, signal);
+        },
+        async request(method, params, signal) {
+            if (disposed)
+                throw new DmpError('dsh-unavailable');
+            const removingPush = method === 'push.unregister' && context.push;
+            if (!implemented.has(method) || !removingPush && methods[method]?.cap && !context.identity.caps.includes(methods[method].cap))
+                throw new DmpError('unsupported');
+            if (method === 'host.info')
+                return { result: { host: context.identity.host, bridgeVersion: context.identity.version,
+                        dshVersion: context.identity.dshVersion, dshStatus: context.identity.dshStatus, caps: context.identity.caps, time: new Date().toISOString() } };
+            if (method === 'push.register' || method === 'push.unregister') {
+                if (!context.push)
+                    throw new DmpError('unsupported');
+                if (method === 'push.register')
+                    context.push.register(context.deviceId, params);
+                else
+                    context.push.unregister(context.deviceId);
+                return { result: {} };
+            }
+            if (method === 'unsubscribe') {
+                const id = String(params.subId), watch = subscriptions.get(id);
+                subscriptions.delete(id);
+                await watch?.dispose();
+                return { result: {} };
+            }
+            if (method === 'devices.list')
+                return { result: { devices: context.devices.list() } };
+            if (method === 'devices.rename')
+                return { result: { device: context.devices.rename(String(params.deviceId), String(params.name)) } };
+            if (method === 'devices.revoke') {
+                context.devices.revoke(String(params.deviceId));
+                return { result: {} };
+            }
+            if (method === 'devices.watch') {
+                const subId = randomUUID();
+                const stop = context.devices.watch(() => {
+                    if (!disposed && subscriptions.has(subId))
+                        context.emit(subId, { kind: 'devices.replace', data: { devices: context.devices.list() } });
+                });
+                subscriptions.set(subId, { result: {}, dispose: stop });
+                return { result: { subId, devices: context.devices.list() } };
+            }
+            if (method === 'attachments.begin') {
+                await peer.request(method, params, signal);
+                return { result: context.uploads.begin(params) };
+            }
+            if (method === 'attachments.finish')
+                return { result: await context.uploads.finish(String(params.uploadId), signal) };
+            if (method === 'sessions.create')
+                return { result: await ledger.create(context.deviceId, params, peer) };
+            if (method === 'session.send') {
+                if (params.mode === 'steer' && !context.identity.caps.includes('send.steer') || Array.isArray(params.attachments) && params.attachments.length && !context.identity.caps.includes('attachments'))
+                    throw new DmpError('unsupported');
+                if ((typeof params.text !== 'string' || !params.text.trim()) && !(Array.isArray(params.attachments) && params.attachments.length))
+                    throw new DmpError('invalid-params', 'Text must not be empty');
+            }
+            if (method === 'tool.output' || method === 'timeline.text' || method === 'files.download' || method === 'deliverables.download')
+                return { bytes: await peer.content(method, params, signal), mime: method === 'files.download' || method === 'deliverables.download' ? 'application/octet-stream' : 'text/plain; charset=utf-8' };
+            if (method === 'sessions.watch' || method === 'session.watch' || method === 'jobs.watch' || method === 'job.watch') {
+                const subId = randomUUID();
+                const pending = [];
+                let ready = false;
+                const emit = (event) => {
+                    if (disposed || signal.aborted)
+                        return;
+                    if (!ready)
+                        pending.push(event);
+                    else if (subscriptions.has(subId))
+                        context.emit(subId, event);
+                };
+                let watch = await peer.watch(method, params, emit, signal);
+                let result;
+                try {
+                    result = fitPage({ ...watch.result, subId });
+                }
+                catch (error) {
+                    await watch.dispose();
+                    if (method !== 'session.watch' || watch.result.resumed !== true)
+                        throw error;
+                    // A resume merge cannot drop changed items. Reopen as a fresh window.
+                    pending.length = 0;
+                    const { sinceSeq: _sinceSeq, ...fresh } = params;
+                    watch = await peer.watch(method, fresh, emit, signal);
+                    try {
+                        result = fitPage({ ...watch.result, subId });
+                    }
+                    catch (retryError) {
+                        await watch.dispose();
+                        throw retryError;
+                    }
+                }
+                if (disposed || signal.aborted) {
+                    await watch.dispose();
+                    throw new DmpError('cancelled');
+                }
+                const stopWatching = method === 'session.watch' ? context.push?.watch(String(params.sessionId)) : undefined;
+                subscriptions.set(subId, { ...watch, async dispose() { stopWatching?.(); await watch.dispose(); } });
+                // The RPC response gets enqueued before live events from the new watch.
+                setImmediate(() => { ready = true; if (!disposed && subscriptions.has(subId))
+                    for (const event of pending)
+                        context.emit(subId, event); pending.length = 0; });
+                return { result };
+            }
+            const result = await peer.request(method, params, signal);
+            return { result: method === 'session.history' ? fitPage(result) : result };
+        },
+    };
+}

package/lib/pairing/state.d.ts

@@ -0,0 +1,26 @@
+export interface DeviceRecord {
+    name: string;
+    model: string;
+    publicKey: string;
+    secureEnclave: boolean;
+    pairedAt: string;
+    lastSeenAt?: string;
+    revokedAt?: string;
+}
+declare function writePrivate(file: string, value: string | Buffer): void;
+export declare class HostState {
+    readonly directory: string;
+    readonly hostId: string;
+    readonly key: Buffer;
+    readonly cert: Buffer;
+    readonly fingerprint: string;
+    readonly devicesFile: string;
+    devices: Record<string, DeviceRecord>;
+    constructor(directory: string);
+    readDevices(): Record<string, DeviceRecord>;
+    reload(): void;
+    save(): void;
+    pair(record: Omit<DeviceRecord, 'pairedAt'>): string;
+    revoke(id: string): boolean;
+}
+export { writePrivate };

package/lib/pairing/state.js

@@ -0,0 +1,89 @@
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+import { execFileSync } from 'node:child_process';
+function writePrivate(file, value) {
+    const temporary = `${file}.${process.pid}.tmp`;
+    fs.writeFileSync(temporary, value, { mode: 0o600 });
+    fs.chmodSync(temporary, 0o600);
+    fs.renameSync(temporary, file);
+}
+export class HostState {
+    directory;
+    hostId;
+    key;
+    cert;
+    fingerprint;
+    devicesFile;
+    devices;
+    constructor(directory) {
+        this.directory = directory;
+        fs.mkdirSync(directory, { recursive: true, mode: 0o700 });
+        fs.chmodSync(directory, 0o700);
+        const keyFile = path.join(directory, 'key.pem'), certFile = path.join(directory, 'cert.pem');
+        if (fs.existsSync(certFile) !== fs.existsSync(keyFile))
+            throw new Error('Incomplete DSHM TLS identity; restore both certificate and key');
+        if (!fs.existsSync(certFile)) {
+            const temporaryKey = path.join(directory, 'new-key.pem'), temporaryCert = path.join(directory, 'new-cert.pem');
+            try {
+                // Node emits named-curve PKCS8. LibreSSL's `req -newkey ec` can encode
+                // explicit parameters that Electron's BoringSSL cannot load.
+                const keys = crypto.generateKeyPairSync('ec', { namedCurve: 'prime256v1' });
+                writePrivate(temporaryKey, keys.privateKey.export({ type: 'pkcs8', format: 'pem' }));
+                execFileSync('openssl', ['req', '-new', '-x509', '-sha256', '-key', temporaryKey, '-out', temporaryCert, '-days', '825', '-subj', '/CN=DSHM Bridge'], { stdio: 'ignore' });
+                fs.chmodSync(temporaryKey, 0o600);
+                fs.chmodSync(temporaryCert, 0o600);
+                fs.renameSync(temporaryKey, keyFile);
+                fs.renameSync(temporaryCert, certFile);
+            }
+            finally {
+                fs.rmSync(temporaryKey, { force: true });
+                fs.rmSync(temporaryCert, { force: true });
+            }
+        }
+        fs.chmodSync(keyFile, 0o600);
+        fs.chmodSync(certFile, 0o600);
+        this.key = fs.readFileSync(keyFile);
+        this.cert = fs.readFileSync(certFile);
+        this.fingerprint = crypto.createHash('sha256').update(new crypto.X509Certificate(this.cert).raw).digest('base64url');
+        const hostIdFile = path.join(directory, 'host-id');
+        if (!fs.existsSync(hostIdFile))
+            writePrivate(hostIdFile, crypto.randomUUID());
+        fs.chmodSync(hostIdFile, 0o600);
+        this.hostId = fs.readFileSync(hostIdFile, 'utf8').trim();
+        this.devicesFile = path.join(directory, 'devices.json');
+        if (!fs.existsSync(this.devicesFile))
+            writePrivate(this.devicesFile, '{}');
+        fs.chmodSync(this.devicesFile, 0o600);
+        this.devices = this.readDevices();
+    }
+    readDevices() {
+        const value = JSON.parse(fs.readFileSync(this.devicesFile, 'utf8'));
+        if (!value || typeof value !== 'object' || Array.isArray(value))
+            throw new Error('Invalid DSHM device registry');
+        for (const record of Object.values(value)) {
+            if (!record || typeof record !== 'object' || typeof record.name !== 'string' || typeof record.model !== 'string' || typeof record.publicKey !== 'string' || typeof record.secureEnclave !== 'boolean' || typeof record.pairedAt !== 'string' || (record.revokedAt !== undefined && typeof record.revokedAt !== 'string'))
+                throw new Error('Invalid DSHM device record');
+        }
+        return value;
+    }
+    reload() { this.devices = this.readDevices(); }
+    save() { writePrivate(this.devicesFile, JSON.stringify(this.devices, null, 2)); }
+    pair(record) {
+        this.reload();
+        const id = crypto.randomUUID();
+        this.devices[id] = { ...record, pairedAt: new Date().toISOString() };
+        this.save();
+        return id;
+    }
+    revoke(id) {
+        this.reload();
+        const record = this.devices[id];
+        if (!record)
+            return false;
+        record.revokedAt = new Date().toISOString();
+        this.save();
+        return true;
+    }
+}
+export { writePrivate };

package/lib/pairing/window.d.ts

@@ -0,0 +1,18 @@
+export declare class PairingWindow {
+    private readonly directory;
+    private readonly quiet;
+    private state?;
+    private timer?;
+    private currentUrl?;
+    constructor(directory: string, quiet: boolean);
+    get url(): string | undefined;
+    get expiresAt(): string | undefined;
+    open(values: {
+        hostId: string;
+        name: string;
+        fingerprint: string;
+        addresses: string[];
+    }): string;
+    verify(value: string): 'ok' | 'bad-otp' | 'pairing-closed';
+    close(): void;
+}

package/lib/pairing/window.js

@@ -0,0 +1,57 @@
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+import qrcode from 'qrcode';
+import { writePrivate } from './state.js';
+export class PairingWindow {
+    directory;
+    quiet;
+    state;
+    timer;
+    currentUrl;
+    constructor(directory, quiet) {
+        this.directory = directory;
+        this.quiet = quiet;
+    }
+    get url() { return this.currentUrl; }
+    get expiresAt() { return this.state ? new Date(this.state.expires).toISOString() : undefined; }
+    open(values) {
+        this.close();
+        const otp = crypto.randomBytes(16);
+        this.state = { otp, expires: Date.now() + 300000, attempts: 0 };
+        const params = new URLSearchParams({ v: '1', host: values.hostId, name: values.name, fp: values.fingerprint, addrs: values.addresses.join(','), otp: otp.toString('base64url'), exp: String(Math.floor(this.state.expires / 1000)) });
+        this.currentUrl = `dshm://pair?${params}`;
+        writePrivate(path.join(this.directory, 'pairing-url.txt'), this.currentUrl);
+        this.timer = setTimeout(() => this.close(), 300000);
+        this.timer.unref();
+        if (!this.quiet) {
+            const url = this.currentUrl;
+            void qrcode.toString(url, { type: 'terminal', small: true }).then(qr => { if (this.currentUrl === url)
+                console.log(qr); });
+            console.log('DSHM pairing open for five minutes (one use). Keep the QR private.');
+        }
+        return this.currentUrl;
+    }
+    verify(value) {
+        if (!this.state || Date.now() >= this.state.expires || this.state.attempts >= 5) {
+            this.close();
+            return 'pairing-closed';
+        }
+        this.state.attempts++;
+        const received = Buffer.from(value, 'base64url');
+        const matches = received.length === this.state.otp.length && received.toString('base64url') === value && crypto.timingSafeEqual(received, this.state.otp);
+        if (!matches) {
+            if (this.state.attempts >= 5)
+                this.close();
+            return 'bad-otp';
+        }
+        return 'ok';
+    }
+    close() {
+        clearTimeout(this.timer);
+        this.timer = undefined;
+        this.state = undefined;
+        this.currentUrl = undefined;
+        fs.rmSync(path.join(this.directory, 'pairing-url.txt'), { force: true });
+    }
+}

package/lib/projection/client.d.mts

@@ -0,0 +1,2 @@
+export function apply(ctx: any): void;
+export const inject: string[];

package/lib/projection/client.mjs

@@ -0,0 +1,11 @@
+// Only this browser boundary names DSH services and shared platform modules.
+import * as React from 'react';
+import * as primitives from '@deepseek-ai/dsh-client-ui-primitives';
+import { createSettingsCard } from '../ui/card.mjs';
+export const inject = ['slots'];
+const SettingsCard = createSettingsCard(React, primitives, 'api/dshm');
+export function apply(ctx) {
+    ctx.slots.inject('settings.section', () => ctx.slots.register({
+        name: 'settings.section', id: 'dshm', order: 60, label: () => 'DSHM',
+    }, SettingsCard));
+}

package/lib/projection/compatibility.d.mts

@@ -0,0 +1,2 @@
+export const supportedDSHVersions: readonly string[];
+export function supportsDSH(version: any): boolean;

package/lib/projection/compatibility.mjs

@@ -0,0 +1,4 @@
+// Enumerate verified carriers; a future prerelease is not implicitly compatible.
+// Keep package metadata and the release gate aligned with the native test receipt.
+export const supportedDSHVersions = Object.freeze(['0.2.1-rc.3', '0.2.1-rc.5']);
+export const supportsDSH = version => supportedDSHVersions.includes(version);

package/lib/projection/files.d.ts

@@ -0,0 +1,33 @@
+import type { DmpObject } from '../types.js';
+import type { NativeRecord } from './fold-recording.mjs';
+interface FileSession {
+    cwd: string;
+    records: readonly NativeRecord[];
+}
+export interface FileProjectionAccess {
+    home: string;
+    session(sessionId: string, signal: AbortSignal): Promise<FileSession>;
+    call(namespace: string, method: string, args: DmpObject, signal: AbortSignal): Promise<unknown>;
+    fetch(request: Request): Promise<Response>;
+    changeState?(sessionId: string, seq: number, state: {
+        available: boolean;
+        fileCount?: number;
+        added?: number;
+        deleted?: number;
+    }): void;
+}
+export declare class FileProjection {
+    private access;
+    constructor(access: FileProjectionAccess);
+    private allowed;
+    private target;
+    private declaredTarget;
+    private recheck;
+    private guardedCall;
+    private call;
+    request(method: string, params: DmpObject, signal: AbortSignal): Promise<DmpObject>;
+    content(method: string, params: DmpObject, signal: AbortSignal): Promise<Uint8Array>;
+    private changeFetch;
+    private changes;
+}
+export {};