@parall/daemon 1.30.0 → 1.32.0

package/dist/clip-runtime/clip-provider.js

@@ -0,0 +1,402 @@
+/**
+ * ClipProvider — Connect-RPC client that connects the Daemon to the Clip
+ * Service (Hub) as a Provider. Uses Node.js http2 directly with Connect
+ * protocol bidi streaming (envelope-framed JSON over HTTP/2).
+ *
+ * Protocol: POST /clip.v1.ClipHubService/ProviderStream
+ *   Content-Type: application/connect+json
+ *   Authorization: Bearer mck_xxx
+ *   Body: envelope-framed ProviderMessage stream
+ *   Response: envelope-framed HubMessage stream
+ *
+ * Connect envelope format (JSON mode):
+ *   [flags:1][length:4 big-endian][JSON payload]
+ *   flags=0x00 data, flags=0x02 end-of-stream (trailers)
+ */
+import * as http2 from 'node:http2';
+import { ClipCommandError } from './process.js';
+// ---------------------------------------------------------------------------
+// Connect envelope helpers
+// ---------------------------------------------------------------------------
+const ENVELOPE_FLAG_DATA = 0x00;
+const ENVELOPE_FLAG_TRAILER = 0x02;
+function encodeEnvelope(msg) {
+    const json = Buffer.from(JSON.stringify(msg), 'utf-8');
+    const header = Buffer.alloc(5);
+    header[0] = ENVELOPE_FLAG_DATA;
+    header.writeUInt32BE(json.length, 1);
+    return Buffer.concat([header, json]);
+}
+/**
+ * Incremental envelope decoder. Feed chunks via push(), receive decoded
+ * messages from flush(). Handles partial reads across chunk boundaries.
+ */
+class EnvelopeDecoder {
+    buf = Buffer.alloc(0);
+    push(chunk) {
+        this.buf = this.buf.length === 0 ? Buffer.from(chunk) : Buffer.concat([this.buf, chunk]);
+    }
+    /** Drain all complete envelopes from the internal buffer. */
+    static MAX_FRAME_LENGTH = 16 * 1024 * 1024; // 16 MiB
+    *flush() {
+        while (this.buf.length >= 5) {
+            const flags = this.buf[0];
+            const length = this.buf.readUInt32BE(1);
+            if (length > EnvelopeDecoder.MAX_FRAME_LENGTH) {
+                this.buf = Buffer.alloc(0);
+                throw new Error(`envelope frame too large: ${length} bytes`);
+            }
+            if (this.buf.length < 5 + length)
+                break; // incomplete frame
+            const payload = this.buf.subarray(5, 5 + length);
+            this.buf = Buffer.from(this.buf.subarray(5 + length));
+            yield { flags, payload };
+        }
+    }
+}
+export class ClipProvider {
+    opts;
+    session = null;
+    stream = null;
+    stopped = false;
+    connected = false;
+    reconnectAttempt = 0;
+    reconnectTimer = null;
+    heartbeatTimer = null;
+    statusUnsubscribe = null;
+    manifestUnsubscribe = null;
+    needsReregister = false;
+    intentionalClose = false;
+    static RECONNECT_BASE_MS = 5_000;
+    static RECONNECT_MAX_MS = 60_000;
+    static HEARTBEAT_INTERVAL_MS = 30_000;
+    constructor(opts) {
+        this.opts = opts;
+    }
+    /** Connect to the Clip Service and register local clips. Reconnects on failure. */
+    async connect() {
+        this.stopped = false;
+        // Subscribe to clip status changes so we can forward them to the Hub
+        this.subscribeStatusChanges();
+        await this.openStream();
+    }
+    /** Disconnect and stop reconnection. */
+    async disconnect() {
+        this.stopped = true;
+        this.unsubscribeStatusChanges();
+        this.clearReconnectTimer();
+        this.clearHeartbeatTimer();
+        this.closeStream();
+        this.closeSession();
+        this.connected = false;
+    }
+    isConnected() {
+        return this.connected;
+    }
+    // ---------------------------------------------------------------------------
+    // Stream lifecycle
+    // ---------------------------------------------------------------------------
+    async openStream() {
+        if (this.stopped)
+            return;
+        try {
+            this.closeStream();
+            this.closeSession();
+            const url = new URL(this.opts.serviceUrl);
+            const authority = url.origin;
+            this.session = http2.connect(authority);
+            this.session.on('error', (err) => {
+                this.opts.log.warn(`[clip-provider] h2 session error: ${String(err)}`);
+                this.handleDisconnect();
+            });
+            this.session.on('close', () => {
+                this.handleDisconnect();
+            });
+            this.stream = this.session.request({
+                ':method': 'POST',
+                ':path': '/clip.v1.ClipHubService/ProviderStream',
+                'content-type': 'application/connect+json',
+                'connect-protocol-version': '1',
+                authorization: `Bearer ${this.opts.authKey}`,
+            });
+            this.stream.on('error', (err) => {
+                this.opts.log.warn(`[clip-provider] stream error: ${String(err)}`);
+                this.handleDisconnect();
+            });
+            // Read response envelopes
+            const decoder = new EnvelopeDecoder();
+            this.stream.on('data', (chunk) => {
+                decoder.push(chunk);
+                for (const envelope of decoder.flush()) {
+                    if (envelope.flags === ENVELOPE_FLAG_TRAILER) {
+                        // End-of-stream trailers — connection closing
+                        this.opts.log.info('[clip-provider] received end-of-stream trailer');
+                        continue;
+                    }
+                    try {
+                        const msg = JSON.parse(envelope.payload.toString('utf-8'));
+                        this.handleHubMessage(msg);
+                    }
+                    catch (err) {
+                        this.opts.log.warn(`[clip-provider] failed to parse hub message: ${String(err)}`);
+                    }
+                }
+            });
+            this.stream.on('end', () => {
+                this.opts.log.info('[clip-provider] stream ended by hub');
+                this.handleDisconnect();
+            });
+            this.stream.on('close', () => {
+                this.handleDisconnect();
+            });
+            // Send ProviderRegister as the first message
+            await this.sendRegister();
+        }
+        catch (err) {
+            this.opts.log.warn(`[clip-provider] connect failed: ${String(err)}`);
+            this.scheduleReconnect();
+        }
+    }
+    handleDisconnect() {
+        if (this.stopped || this.intentionalClose)
+            return;
+        if (!this.connected && this.reconnectTimer)
+            return; // already scheduling
+        this.connected = false;
+        this.clearHeartbeatTimer();
+        this.scheduleReconnect();
+    }
+    scheduleReconnect() {
+        if (this.stopped || this.reconnectTimer)
+            return;
+        const delay = Math.min(ClipProvider.RECONNECT_BASE_MS * Math.pow(2, this.reconnectAttempt), ClipProvider.RECONNECT_MAX_MS);
+        this.reconnectAttempt++;
+        this.opts.log.info(`[clip-provider] reconnecting in ${delay}ms (attempt ${this.reconnectAttempt})`);
+        this.reconnectTimer = setTimeout(() => {
+            this.reconnectTimer = null;
+            void this.openStream();
+        }, delay);
+        this.reconnectTimer.unref?.();
+    }
+    clearReconnectTimer() {
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = null;
+        }
+    }
+    clearHeartbeatTimer() {
+        if (this.heartbeatTimer) {
+            clearInterval(this.heartbeatTimer);
+            this.heartbeatTimer = null;
+        }
+    }
+    startHeartbeat() {
+        this.clearHeartbeatTimer();
+        this.heartbeatTimer = setInterval(() => {
+            // If a clip manifest was populated since last heartbeat, reconnect to
+            // re-register all clips with their now-available commands.
+            if (this.needsReregister) {
+                this.needsReregister = false;
+                this.opts.log.info('[clip-provider] manifest updated — reconnecting to re-register clips');
+                this.intentionalClose = true;
+                this.closeStream();
+                this.closeSession();
+                this.intentionalClose = false;
+                this.connected = false;
+                this.clearHeartbeatTimer();
+                this.clearReconnectTimer();
+                void this.openStream();
+                return;
+            }
+            this.sendProviderMessage({ heartbeat: {} }).catch((err) => {
+                this.opts.log.warn(`[clip-provider] heartbeat send failed: ${String(err)}`);
+            });
+        }, ClipProvider.HEARTBEAT_INTERVAL_MS);
+        this.heartbeatTimer.unref?.();
+    }
+    closeStream() {
+        if (this.stream) {
+            try {
+                this.stream.close();
+            }
+            catch {
+                /* already closed */
+            }
+            this.stream = null;
+        }
+    }
+    closeSession() {
+        if (this.session) {
+            try {
+                this.session.close();
+            }
+            catch {
+                /* already closed */
+            }
+            this.session = null;
+        }
+    }
+    // ---------------------------------------------------------------------------
+    // Status change forwarding
+    // ---------------------------------------------------------------------------
+    subscribeStatusChanges() {
+        const mgr = this.opts.clipManager;
+        // Forward clip status changes to the Hub
+        this.statusUnsubscribe = mgr.addStatusListener((name, status, _message) => {
+            if (!this.connected)
+                return;
+            const protoStatus = status === 'running'
+                ? 'CLIP_ONLINE_STATUS_ONLINE'
+                : status === 'error'
+                    ? 'CLIP_ONLINE_STATUS_ERROR'
+                    : 'CLIP_ONLINE_STATUS_OFFLINE';
+            this.sendProviderMessage({
+                clipStatusChanged: { alias: name, status: protoStatus },
+            }).catch((err) => {
+                this.opts.log.warn(`[clip-provider] status change send failed: ${String(err)}`);
+            });
+        });
+        // Listen for manifest updates so we can re-register with populated commands
+        this.manifestUnsubscribe = mgr.addManifestListener(() => {
+            this.needsReregister = true;
+        });
+    }
+    unsubscribeStatusChanges() {
+        this.statusUnsubscribe?.();
+        this.statusUnsubscribe = null;
+        this.manifestUnsubscribe?.();
+        this.manifestUnsubscribe = null;
+    }
+    // ---------------------------------------------------------------------------
+    // Message handling
+    // ---------------------------------------------------------------------------
+    handleHubMessage(msg) {
+        if (msg.registered) {
+            this.handleRegistered(msg.registered);
+        }
+        else if (msg.invokeCommand) {
+            void this.handleInvokeCommand(msg.invokeCommand);
+        }
+        else if (msg.heartbeat !== undefined) {
+            // Respond to hub heartbeat with provider heartbeat
+            this.sendProviderMessage({ heartbeat: {} }).catch(() => { });
+        }
+    }
+    handleRegistered(reg) {
+        if (reg.accepted) {
+            this.opts.log.info(`[clip-provider] registered with hub (org=${reg.orgId})`);
+            this.connected = true;
+            this.reconnectAttempt = 0;
+            this.startHeartbeat();
+        }
+        else {
+            this.opts.log.error(`[clip-provider] registration rejected: ${reg.message}`);
+            // Don't reconnect on rejection — likely a permanent auth error
+            this.stopped = true;
+            this.closeStream();
+            this.closeSession();
+        }
+    }
+    async handleInvokeCommand(cmd) {
+        const { requestId, clipAlias, commandName } = cmd;
+        const timeoutMs = cmd.timeoutMs ?? 30_000;
+        try {
+            let input;
+            if (cmd.input) {
+                const decoded = Buffer.from(cmd.input, 'base64').toString('utf-8');
+                try {
+                    input = JSON.parse(decoded);
+                }
+                catch {
+                    input = decoded;
+                }
+            }
+            let timer;
+            const output = await Promise.race([
+                this.opts.clipManager.invoke(clipAlias, commandName, input),
+                new Promise((_, reject) => {
+                    timer = setTimeout(() => reject(new Error('invoke timeout')), timeoutMs);
+                }),
+            ]).finally(() => {
+                if (timer)
+                    clearTimeout(timer);
+            });
+            // Encode output as base64 bytes
+            const outputBytes = Buffer.from(typeof output === 'string' ? output : JSON.stringify(output ?? null), 'utf-8').toString('base64');
+            await this.sendProviderMessage({
+                invokeResult: { requestId, output: outputBytes, done: true },
+            });
+        }
+        catch (err) {
+            // Only a ClipCommandError is a clip application-level error safe to
+            // surface; send its bare message (no "ClipCommandError:" prefix) and flag
+            // it. Everything else (spawn failure, crash, timeout) is an internal error
+            // the Hub maps to a generic 500 without leaking the message.
+            const isCommandError = err instanceof ClipCommandError;
+            await this.sendProviderMessage({
+                invokeResult: {
+                    requestId,
+                    error: isCommandError ? err.message : String(err),
+                    errorIsCommand: isCommandError,
+                    done: true,
+                },
+            }).catch(() => { }); // best-effort error response
+        }
+    }
+    // ---------------------------------------------------------------------------
+    // Sending
+    // ---------------------------------------------------------------------------
+    async sendRegister() {
+        const clips = this.buildClipRegistrations();
+        await this.sendProviderMessage({
+            register: {
+                providerName: this.opts.providerName,
+                clips,
+                orgId: this.opts.orgId,
+            },
+        });
+    }
+    async sendProviderMessage(msg) {
+        if (!this.stream || this.stream.closed || this.stream.destroyed) {
+            throw new Error('stream not open');
+        }
+        const envelope = encodeEnvelope(msg);
+        return new Promise((resolve, reject) => {
+            this.stream.write(envelope, (err) => {
+                if (err)
+                    reject(err);
+                else
+                    resolve();
+            });
+        });
+    }
+    // ---------------------------------------------------------------------------
+    // Clip registration helpers
+    // ---------------------------------------------------------------------------
+    buildClipRegistrations() {
+        const clips = this.opts.clipManager.getRegisteredClips();
+        return clips.map((clip) => this.clipConfigToRegistration(clip));
+    }
+    clipConfigToRegistration(clip) {
+        const manifest = clip.manifest;
+        const commands = manifest
+            ? manifest.commandDetails.map((cmd) => this.commandDetailToInfo(cmd))
+            : [];
+        return {
+            alias: clip.name,
+            name: manifest?.package ?? clip.package ?? clip.name,
+            version: manifest?.version ?? clip.version ?? '',
+            commands,
+        };
+    }
+    commandDetailToInfo(detail) {
+        return {
+            name: detail.name,
+            description: detail.description ?? '',
+            inputSchema: detail.input ? Buffer.from(detail.input, 'utf-8').toString('base64') : undefined,
+            outputSchema: detail.output
+                ? Buffer.from(detail.output, 'utf-8').toString('base64')
+                : undefined,
+        };
+    }
+}

package/dist/clip-runtime/index.d.ts

@@ -0,0 +1,7 @@
+export { ClipProcessManager, type ClipProcessManagerOptions } from './process-manager.js';
+export { ClipProcess, ClipCommandError, type ClipProcessStatus, type InvokeEvent, type InvokeResult, } from './process.js';
+export { type IpcMessage, type IpcManifest, type ListClipInfo, type ListCommandInfo, type IpcError, MessageType, NdjsonReader, NdjsonWriter, } from './ipc.js';
+export { type ClipConfig, type ManifestCache, type CommandDetail, type ClipJson, } from './manifest.js';
+export { ClipProvider, type ClipProviderOptions } from './clip-provider.js';
+export { installClip, removeClip, parseSource, type InstallOptions, type InstallResult, } from './clip-installer.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/clip-runtime/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/clip-runtime/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,KAAK,yBAAyB,EAAE,MAAM,sBAAsB,CAAC;AAC1F,OAAO,EACL,WAAW,EACX,gBAAgB,EAChB,KAAK,iBAAiB,EACtB,KAAK,WAAW,EAChB,KAAK,YAAY,GAClB,MAAM,cAAc,CAAC;AACtB,OAAO,EACL,KAAK,UAAU,EACf,KAAK,WAAW,EAChB,KAAK,YAAY,EACjB,KAAK,eAAe,EACpB,KAAK,QAAQ,EACb,WAAW,EACX,YAAY,EACZ,YAAY,GACb,MAAM,UAAU,CAAC;AAClB,OAAO,EACL,KAAK,UAAU,EACf,KAAK,aAAa,EAClB,KAAK,aAAa,EAClB,KAAK,QAAQ,GACd,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,YAAY,EAAE,KAAK,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAC5E,OAAO,EACL,WAAW,EACX,UAAU,EACV,WAAW,EACX,KAAK,cAAc,EACnB,KAAK,aAAa,GACnB,MAAM,qBAAqB,CAAC"}

package/dist/clip-runtime/index.js

@@ -0,0 +1,5 @@
+export { ClipProcessManager } from './process-manager.js';
+export { ClipProcess, ClipCommandError, } from './process.js';
+export { MessageType, NdjsonReader, NdjsonWriter, } from './ipc.js';
+export { ClipProvider } from './clip-provider.js';
+export { installClip, removeClip, parseSource, } from './clip-installer.js';

package/dist/clip-runtime/ipc.d.ts

@@ -0,0 +1,94 @@
+import type { Readable, Writable } from 'node:stream';
+export declare const MessageType: {
+    readonly Register: "register";
+    readonly Registered: "registered";
+    readonly Invoke: "invoke";
+    readonly Result: "result";
+    readonly Error: "error";
+    readonly Chunk: "chunk";
+    readonly Done: "done";
+    readonly ListClips: "list_clips";
+    readonly ListClipsResult: "list_clips_result";
+    readonly Data: "data";
+    readonly DataResult: "data_result";
+    readonly Heartbeat: "heartbeat";
+};
+export interface IpcMessage {
+    id?: string;
+    type: string;
+    alias?: string;
+    clip?: string;
+    command?: string;
+    input?: unknown;
+    output?: unknown;
+    error?: string;
+    manifest?: IpcManifest;
+    clips?: ListClipInfo[];
+    operation?: string;
+    path?: string;
+    content?: string;
+    mime?: string;
+    uri?: string;
+    entries?: unknown;
+    stat?: unknown;
+}
+export interface IpcManifest {
+    package?: string;
+    version?: string;
+    domain?: string;
+    description?: string;
+    commands?: unknown;
+    has_web?: boolean;
+    dependencies?: Record<string, {
+        package?: string;
+        version?: string;
+    }>;
+    patterns?: string[];
+    entities?: Record<string, unknown>;
+}
+export interface ListClipInfo {
+    name: string;
+    package?: string;
+    version?: string;
+    domain?: string;
+    description?: string;
+    patterns?: string[];
+    commands?: ListCommandInfo[];
+}
+export interface ListCommandInfo {
+    name: string;
+    description?: string;
+    input?: string;
+    output?: string;
+}
+export interface IpcError {
+    message: string;
+    code?: string;
+}
+export declare const IPC_CLOSED_ERROR: Error;
+/**
+ * NDJSON reader for ChildProcess stdout.
+ * Corresponds to Pinix process.go readLoop's bufio.Scanner (8 MB line limit).
+ */
+export declare class NdjsonReader {
+    private rl;
+    private closed;
+    constructor(stream: Readable);
+    [Symbol.asyncIterator](): AsyncIterableIterator<IpcMessage>;
+    close(): void;
+}
+/**
+ * NDJSON writer for ChildProcess stdin.
+ * Uses a Promise chain to serialize writes (corresponds to Pinix sendMu sync.Mutex).
+ */
+export declare class NdjsonWriter {
+    private stream;
+    private chain;
+    private _closed;
+    constructor(stream: Writable);
+    get closed(): boolean;
+    send(message: IpcMessage): Promise<void>;
+    private doWrite;
+    close(): void;
+}
+//# sourceMappingURL=ipc.d.ts.map

package/dist/clip-runtime/ipc.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ipc.d.ts","sourceRoot":"","sources":["../../src/clip-runtime/ipc.ts"],"names":[],"mappings":"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"}

package/dist/clip-runtime/ipc.js

@@ -0,0 +1,98 @@
+import { createInterface } from 'node:readline';
+// Message type constants — must match Pinix ipc.go exactly
+export const MessageType = {
+    Register: 'register',
+    Registered: 'registered',
+    Invoke: 'invoke',
+    Result: 'result',
+    Error: 'error',
+    Chunk: 'chunk',
+    Done: 'done',
+    ListClips: 'list_clips',
+    ListClipsResult: 'list_clips_result',
+    Data: 'data',
+    DataResult: 'data_result',
+    Heartbeat: 'heartbeat',
+};
+export const IPC_CLOSED_ERROR = new Error('ipc client closed');
+/**
+ * NDJSON reader for ChildProcess stdout.
+ * Corresponds to Pinix process.go readLoop's bufio.Scanner (8 MB line limit).
+ */
+export class NdjsonReader {
+    rl;
+    closed = false;
+    constructor(stream) {
+        this.rl = createInterface({ input: stream, crlfDelay: Infinity });
+    }
+    async *[Symbol.asyncIterator]() {
+        for await (const line of this.rl) {
+            if (this.closed)
+                break;
+            const trimmed = line.trim();
+            if (!trimmed)
+                continue;
+            try {
+                const msg = JSON.parse(trimmed);
+                if (!msg.type) {
+                    console.warn("[clip-ipc] message missing 'type' field, skipping");
+                    continue;
+                }
+                yield msg;
+            }
+            catch {
+                console.warn('[clip-ipc] failed to parse NDJSON line, skipping');
+            }
+        }
+    }
+    close() {
+        this.closed = true;
+        this.rl.close();
+    }
+}
+/**
+ * NDJSON writer for ChildProcess stdin.
+ * Uses a Promise chain to serialize writes (corresponds to Pinix sendMu sync.Mutex).
+ */
+export class NdjsonWriter {
+    stream;
+    chain = Promise.resolve();
+    _closed = false;
+    constructor(stream) {
+        this.stream = stream;
+    }
+    get closed() {
+        return this._closed;
+    }
+    async send(message) {
+        if (this._closed)
+            throw IPC_CLOSED_ERROR;
+        const p = this.chain.then(() => this.doWrite(message));
+        this.chain = p.catch(() => { });
+        return p;
+    }
+    doWrite(message) {
+        return new Promise((resolve, reject) => {
+            if (this._closed) {
+                reject(IPC_CLOSED_ERROR);
+                return;
+            }
+            const data = JSON.stringify(message) + '\n';
+            this.stream.write(data, (err) => {
+                if (err) {
+                    this._closed = true;
+                    reject(err);
+                }
+                else {
+                    resolve();
+                }
+            });
+        });
+    }
+    close() {
+        this._closed = true;
+        if (!this.stream.destroyed) {
+            this.stream.end();
+        }
+    }
+}

package/dist/clip-runtime/manifest.d.ts

@@ -0,0 +1,74 @@
+import type { IpcManifest } from './ipc.js';
+export interface ClipConfig {
+    name: string;
+    package?: string;
+    version?: string;
+    source: string;
+    path: string;
+    token?: string;
+    manifest?: ManifestCache;
+}
+export interface ManifestCache {
+    name: string;
+    package?: string;
+    version?: string;
+    domain?: string;
+    description?: string;
+    commands: string[];
+    commandDetails: CommandDetail[];
+    hasWeb?: boolean;
+    dependencies?: Record<string, {
+        package?: string;
+        version?: string;
+    }>;
+    patterns?: string[];
+    entities?: Record<string, unknown>;
+}
+export interface CommandDetail {
+    name: string;
+    description?: string;
+    input?: string;
+    output?: string;
+}
+export interface ClipJson {
+    name?: string;
+    version?: string;
+    description?: string;
+    runtime?: string;
+    main?: string;
+    web?: string;
+    author?: string;
+    license?: string;
+    repository?: string;
+}
+interface ProjectMetadata {
+    package?: string;
+    version?: string;
+    description?: string;
+    domain?: string;
+    main?: string;
+    web?: string;
+    dependencies?: Record<string, {
+        package?: string;
+        version?: string;
+    }>;
+    patterns?: string[];
+    commands?: CommandDetail[];
+}
+export declare function loadClipJson(dir: string): ClipJson | null;
+export declare function loadProjectMetadata(clip: ClipConfig): ProjectMetadata;
+/**
+ * Parse IPC commands in any of the three Pinix-supported formats:
+ * 1. string[] → ["add", "remove"]
+ * 2. CommandDetail[] → [{ name: "add", description: "..." }]
+ * 3. Record<string, object> → { "add": { description: "..." } }
+ */
+export declare function parseIpcCommands(data: unknown): CommandDetail[];
+export declare function enrichManifest(clip: ClipConfig, manifest: ManifestCache): ManifestCache;
+/**
+ * Build a ManifestCache from IPC register message manifest data.
+ */
+export declare function manifestFromIpc(ipcManifest: IpcManifest): ManifestCache;
+export declare function resolveEntrypoint(clip: ClipConfig): string;
+export {};
+//# sourceMappingURL=manifest.d.ts.map