@parall/daemon 1.31.0 → 1.32.1

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"manifest.d.ts","sourceRoot":"","sources":["../../src/clip-runtime/manifest.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAE5C,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,aAAa,CAAC;CAC1B;AAED,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,cAAc,EAAE,aAAa,EAAE,CAAC;IAChC,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,YAAY,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE;QAAE,OAAO,CAAC,EAAE,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IACtE,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IACpB,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACpC;AAED,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,QAAQ;IACvB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAUD,UAAU,eAAe;IACvB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,YAAY,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE;QAAE,OAAO,CAAC,EAAE,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IACtE,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IACpB,QAAQ,CAAC,EAAE,aAAa,EAAE,CAAC;CAC5B;AAED,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,QAAQ,GAAG,IAAI,CAQzD;AAYD,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,UAAU,GAAG,eAAe,CAkBrE;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,OAAO,GAAG,aAAa,EAAE,CA+C/D;AAED,wBAAgB,cAAc,CAAC,IAAI,EAAE,UAAU,EAAE,QAAQ,EAAE,aAAa,GAAG,aAAa,CAoBvF;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,WAAW,EAAE,WAAW,GAAG,aAAa,CAevE;AAED,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,UAAU,GAAG,MAAM,CAY1D"}

package/dist/clip-runtime/manifest.js

@@ -0,0 +1,181 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+export function loadClipJson(dir) {
+    const filePath = path.join(dir, 'clip.json');
+    try {
+        const content = fs.readFileSync(filePath, 'utf-8');
+        return JSON.parse(content);
+    }
+    catch {
+        return null;
+    }
+}
+function loadPackageJson(dir) {
+    const filePath = path.join(dir, 'package.json');
+    try {
+        const content = fs.readFileSync(filePath, 'utf-8');
+        return JSON.parse(content);
+    }
+    catch {
+        return null;
+    }
+}
+export function loadProjectMetadata(clip) {
+    const meta = {};
+    const clipJson = loadClipJson(clip.path);
+    if (clipJson) {
+        meta.package = clipJson.name;
+        meta.version = clipJson.version;
+        meta.description = clipJson.description;
+        meta.main = clipJson.main;
+        meta.web = clipJson.web;
+    }
+    const pkgJson = loadPackageJson(clip.path);
+    if (pkgJson) {
+        if (!meta.package)
+            meta.package = pkgJson.name;
+        if (!meta.version)
+            meta.version = pkgJson.version;
+        if (!meta.description)
+            meta.description = pkgJson.description;
+        if (!meta.main)
+            meta.main = pkgJson.main;
+    }
+    return meta;
+}
+/**
+ * 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 function parseIpcCommands(data) {
+    if (!data)
+        return [];
+    if (Array.isArray(data)) {
+        if (data.length === 0)
+            return [];
+        if (typeof data[0] === 'string') {
+            return data.map((name) => ({ name: name.trim() }));
+        }
+        return data
+            .map((item) => {
+            const name = (item.name ?? item.command ?? item.id ?? '');
+            return {
+                name: String(name).trim(),
+                description: item.description ? String(item.description).trim() : undefined,
+                input: item.input
+                    ? typeof item.input === 'string'
+                        ? item.input
+                        : JSON.stringify(item.input)
+                    : undefined,
+                output: item.output
+                    ? typeof item.output === 'string'
+                        ? item.output
+                        : JSON.stringify(item.output)
+                    : undefined,
+            };
+        })
+            .filter((c) => c.name);
+    }
+    if (typeof data === 'object' && data !== null) {
+        const record = data;
+        return Object.entries(record)
+            .map(([name, details]) => ({
+            name: name.trim(),
+            description: details?.description ? String(details.description).trim() : undefined,
+            input: details?.input
+                ? typeof details.input === 'string'
+                    ? details.input
+                    : JSON.stringify(details.input)
+                : undefined,
+            output: details?.output
+                ? typeof details.output === 'string'
+                    ? details.output
+                    : JSON.stringify(details.output)
+                : undefined,
+        }))
+            .filter((c) => c.name);
+    }
+    return [];
+}
+export function enrichManifest(clip, manifest) {
+    const meta = loadProjectMetadata(clip);
+    const enriched = { ...manifest };
+    if (!enriched.name)
+        enriched.name = clip.name;
+    if (!enriched.package && meta.package)
+        enriched.package = meta.package;
+    if (!enriched.version && meta.version)
+        enriched.version = meta.version;
+    if (!enriched.description && meta.description)
+        enriched.description = meta.description;
+    if (!enriched.domain && meta.domain)
+        enriched.domain = meta.domain;
+    if (meta.commands && meta.commands.length > 0 && enriched.commandDetails.length === 0) {
+        enriched.commandDetails = meta.commands;
+        enriched.commands = meta.commands.map((c) => c.name);
+    }
+    if (enriched.hasWeb === undefined && meta.web) {
+        enriched.hasWeb = true;
+    }
+    return finalizeManifest(enriched);
+}
+/**
+ * Build a ManifestCache from IPC register message manifest data.
+ */
+export function manifestFromIpc(ipcManifest) {
+    const details = parseIpcCommands(ipcManifest.commands);
+    return {
+        name: '',
+        package: ipcManifest.package,
+        version: ipcManifest.version,
+        domain: ipcManifest.domain,
+        description: ipcManifest.description,
+        commands: details.map((c) => c.name),
+        commandDetails: details,
+        hasWeb: ipcManifest.has_web,
+        dependencies: ipcManifest.dependencies,
+        patterns: ipcManifest.patterns,
+        entities: ipcManifest.entities,
+    };
+}
+export function resolveEntrypoint(clip) {
+    const clipJson = loadClipJson(clip.path);
+    if (clipJson?.main)
+        return path.join(clip.path, clipJson.main);
+    const pkgJson = loadPackageJson(clip.path);
+    if (pkgJson?.main)
+        return path.join(clip.path, pkgJson.main);
+    if (pkgJson?.bin) {
+        const binPath = typeof pkgJson.bin === 'string' ? pkgJson.bin : Object.values(pkgJson.bin)[0];
+        if (binPath)
+            return path.join(clip.path, binPath);
+    }
+    const defaultEntry = path.join(clip.path, 'index.ts');
+    if (fs.existsSync(defaultEntry))
+        return defaultEntry;
+    return path.join(clip.path, 'index.js');
+}
+function finalizeManifest(manifest) {
+    const m = { ...manifest };
+    m.name = (m.name ?? '').trim();
+    m.package = m.package?.trim();
+    m.version = m.version?.trim();
+    m.domain = m.domain?.trim();
+    m.description = m.description?.trim();
+    if (m.commandDetails.length > 0) {
+        const seen = new Set();
+        m.commandDetails = m.commandDetails
+            .map((c) => ({ ...c, name: c.name.trim(), description: c.description?.trim() }))
+            .filter((c) => {
+            if (!c.name || seen.has(c.name))
+                return false;
+            seen.add(c.name);
+            return true;
+        })
+            .sort((a, b) => a.name.localeCompare(b.name));
+        m.commands = m.commandDetails.map((c) => c.name);
+    }
+    return m;
+}

package/dist/clip-runtime/process-manager.d.ts

@@ -0,0 +1,57 @@
+import { type ClipProcessStatus } from './process.js';
+import type { ClipConfig, ManifestCache } from './manifest.js';
+export interface ClipProcessManagerOptions {
+    bunPath?: string;
+    clipsDir: string;
+    dataDir: string;
+}
+export declare class ClipProcessManager {
+    private bunPath;
+    private clipsDir;
+    private dataDir;
+    private processes;
+    private startingUp;
+    private statuses;
+    private clipConfigs;
+    private shuttingDown;
+    private statusListeners;
+    private manifestListeners;
+    constructor(opts: ClipProcessManagerOptions);
+    /** Backward-compat: set a single status listener (wraps addStatusListener). */
+    set onStatusChange(fn: ((name: string, status: ClipProcessStatus, message: string) => void) | undefined);
+    /** Subscribe to clip status changes. Returns an unsubscribe function. */
+    addStatusListener(fn: (name: string, status: ClipProcessStatus, message: string) => void): () => void;
+    addManifestListener(fn: (clip: ClipConfig) => void): () => void;
+    private notifyManifestUpdate;
+    private resolveBun;
+    registerClip(config: ClipConfig): void;
+    unregisterClip(name: string): Promise<void>;
+    startClip(name: string): Promise<void>;
+    stopClip(name: string): Promise<void>;
+    stopAll(): Promise<void>;
+    /**
+     * Invoke a command on a clip. Auto-starts if sleeping, retries once on process crash.
+     * Application-level errors (ClipCommandError) are NOT retried.
+     * Corresponds to Pinix ProcessManager.Invoke().
+     */
+    invoke(name: string, command: string, input?: unknown): Promise<unknown>;
+    invokeStream(name: string, command: string, input?: unknown, onChunk?: (chunk: unknown) => void): Promise<unknown>;
+    loadManifest(name: string): Promise<ManifestCache>;
+    clipStatus(name: string): {
+        status: ClipProcessStatus;
+        message: string;
+    };
+    isRunning(name: string): boolean;
+    getRegisteredClips(): ClipConfig[];
+    /**
+     * Load clip configs from the clips directory.
+     * Reads clip-config.json if present, or scans subdirectories for clip.json files.
+     */
+    loadInstalledClips(): Promise<void>;
+    private ensureProcess;
+    private spawnProcess;
+    private ensureClipDataDir;
+    private removeIfSame;
+    private setStatus;
+}
+//# sourceMappingURL=process-manager.d.ts.map

package/dist/clip-runtime/process-manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"process-manager.d.ts","sourceRoot":"","sources":["../../src/clip-runtime/process-manager.ts"],"names":[],"mappings":"AAEA,OAAO,EAGL,KAAK,iBAAiB,EAEvB,MAAM,cAAc,CAAC;AAEtB,OAAO,KAAK,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAQ/D,MAAM,WAAW,yBAAyB;IACxC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,qBAAa,kBAAkB;IAC7B,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,SAAS,CAAkC;IACnD,OAAO,CAAC,UAAU,CAA2C;IAC7D,OAAO,CAAC,QAAQ,CAAsC;IACtD,OAAO,CAAC,WAAW,CAAiC;IACpD,OAAO,CAAC,YAAY,CAAqB;IACzC,OAAO,CAAC,eAAe,CAEhB;IACP,OAAO,CAAC,iBAAiB,CAAyC;gBAEtD,IAAI,EAAE,yBAAyB;IAM3C,+EAA+E;IAC/E,IAAI,cAAc,CAAC,EAAE,EACjB,CAAC,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,iBAAiB,EAAE,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC,GACpE,SAAS,EAQZ;IAED,yEAAyE;IACzE,iBAAiB,CACf,EAAE,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,iBAAiB,EAAE,OAAO,EAAE,MAAM,KAAK,IAAI,GACrE,MAAM,IAAI;IAQb,mBAAmB,CAAC,EAAE,EAAE,CAAC,IAAI,EAAE,UAAU,KAAK,IAAI,GAAG,MAAM,IAAI;IAQ/D,OAAO,CAAC,oBAAoB;IAU5B,OAAO,CAAC,UAAU;IAOlB,YAAY,CAAC,MAAM,EAAE,UAAU,GAAG,IAAI;IAOhC,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAkB3C,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAItC,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAarC,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAkB9B;;;;OAIG;IACG,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC;IAgBxE,YAAY,CAChB,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,EACf,KAAK,CAAC,EAAE,OAAO,EACf,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,GACjC,OAAO,CAAC,OAAO,CAAC;IAgBb,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC;IAOxD,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG;QAAE,MAAM,EAAE,iBAAiB,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE;IAMxE,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAKhC,kBAAkB,IAAI,UAAU,EAAE;IAIlC;;;OAGG;IACG,kBAAkB,IAAI,OAAO,CAAC,IAAI,CAAC;YA0D3B,aAAa;YAwBb,YAAY;IAgD1B,OAAO,CAAC,iBAAiB;IAMzB,OAAO,CAAC,YAAY;IAMpB,OAAO,CAAC,SAAS;CAUlB"}

package/dist/clip-runtime/process-manager.js

@@ -0,0 +1,333 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { ClipProcess, ClipCommandError, } from './process.js';
+import { findBunBinary } from './bun-resolver.js';
+export class ClipProcessManager {
+    bunPath;
+    clipsDir;
+    dataDir;
+    processes = new Map();
+    startingUp = new Map();
+    statuses = new Map();
+    clipConfigs = new Map();
+    shuttingDown = new Set();
+    statusListeners = [];
+    manifestListeners = [];
+    constructor(opts) {
+        this.bunPath = opts.bunPath ?? '';
+        this.clipsDir = opts.clipsDir;
+        this.dataDir = opts.dataDir;
+    }
+    /** Backward-compat: set a single status listener (wraps addStatusListener). */
+    set onStatusChange(fn) {
+        // Remove any previously installed compat listener, then add the new one.
+        // We store the unsubscribe handle on the function itself to avoid an extra field.
+        const prev = this._compatUnsub;
+        if (prev)
+            prev();
+        if (fn) {
+            this._compatUnsub = this.addStatusListener(fn);
+        }
+    }
+    /** Subscribe to clip status changes. Returns an unsubscribe function. */
+    addStatusListener(fn) {
+        this.statusListeners.push(fn);
+        return () => {
+            const idx = this.statusListeners.indexOf(fn);
+            if (idx >= 0)
+                this.statusListeners.splice(idx, 1);
+        };
+    }
+    addManifestListener(fn) {
+        this.manifestListeners.push(fn);
+        return () => {
+            const idx = this.manifestListeners.indexOf(fn);
+            if (idx >= 0)
+                this.manifestListeners.splice(idx, 1);
+        };
+    }
+    notifyManifestUpdate(clip) {
+        for (const fn of this.manifestListeners) {
+            try {
+                fn(clip);
+            }
+            catch {
+                /* listener error should not break spawn */
+            }
+        }
+    }
+    resolveBun() {
+        if (!this.bunPath) {
+            this.bunPath = findBunBinary();
+        }
+        return this.bunPath;
+    }
+    registerClip(config) {
+        this.clipConfigs.set(config.name, config);
+        if (!this.statuses.has(config.name)) {
+            this.setStatus(config.name, 'sleeping', 'registered');
+        }
+    }
+    async unregisterClip(name) {
+        this.shuttingDown.add(name);
+        try {
+            const startup = this.startingUp.get(name);
+            if (startup) {
+                this.startingUp.delete(name);
+                await startup.then((proc) => proc.stop()).catch(() => { });
+            }
+            if (this.processes.has(name)) {
+                await this.stopClip(name);
+            }
+            this.clipConfigs.delete(name);
+            this.statuses.delete(name);
+        }
+        finally {
+            this.shuttingDown.delete(name);
+        }
+    }
+    async startClip(name) {
+        await this.ensureProcess(name);
+    }
+    async stopClip(name) {
+        this.shuttingDown.add(name);
+        try {
+            const proc = this.processes.get(name);
+            if (!proc)
+                return;
+            await proc.stop();
+            this.processes.delete(name);
+            this.setStatus(name, 'sleeping', 'stopped');
+        }
+        finally {
+            this.shuttingDown.delete(name);
+        }
+    }
+    async stopAll() {
+        // Mark all clips as shutting down before any async work
+        for (const name of this.processes.keys())
+            this.shuttingDown.add(name);
+        for (const name of this.startingUp.keys())
+            this.shuttingDown.add(name);
+        const stops = Array.from(this.processes.keys()).map((name) => this.stopClip(name));
+        // Also abort any in-flight startups (register window)
+        for (const [, startup] of this.startingUp) {
+            stops.push(startup.then((proc) => proc.stop()).catch(() => { }));
+        }
+        this.startingUp.clear();
+        await Promise.allSettled(stops);
+        // shuttingDown is cleared by individual stopClip finally blocks;
+        // clear any remaining entries from startingUp-only clips.
+        this.shuttingDown.clear();
+    }
+    /**
+     * Invoke a command on a clip. Auto-starts if sleeping, retries once on process crash.
+     * Application-level errors (ClipCommandError) are NOT retried.
+     * Corresponds to Pinix ProcessManager.Invoke().
+     */
+    async invoke(name, command, input) {
+        try {
+            const proc = await this.ensureProcess(name);
+            const result = await proc.invoke(command, input);
+            return result.output;
+        }
+        catch (err) {
+            if (err instanceof ClipCommandError)
+                throw err;
+            const old = this.processes.get(name);
+            if (old?.alive())
+                await old.stop().catch(() => { });
+            this.processes.delete(name);
+            const proc = await this.ensureProcess(name);
+            const result = await proc.invoke(command, input);
+            return result.output;
+        }
+    }
+    async invokeStream(name, command, input, onChunk) {
+        try {
+            const proc = await this.ensureProcess(name);
+            const result = await proc.invokeStream(command, input, onChunk);
+            return result.output;
+        }
+        catch (err) {
+            if (err instanceof ClipCommandError)
+                throw err;
+            const old = this.processes.get(name);
+            if (old?.alive())
+                await old.stop().catch(() => { });
+            this.processes.delete(name);
+            const proc = await this.ensureProcess(name);
+            const result = await proc.invokeStream(command, input, onChunk);
+            return result.output;
+        }
+    }
+    async loadManifest(name) {
+        const proc = await this.ensureProcess(name);
+        const manifest = proc.getManifest();
+        if (!manifest)
+            throw new Error(`clip "${name}" has no manifest`);
+        return manifest;
+    }
+    clipStatus(name) {
+        const entry = this.statuses.get(name);
+        if (!entry)
+            return { status: 'sleeping', message: 'unknown' };
+        return { status: entry.status, message: entry.message };
+    }
+    isRunning(name) {
+        const proc = this.processes.get(name);
+        return proc !== undefined && proc.alive();
+    }
+    getRegisteredClips() {
+        return Array.from(this.clipConfigs.values());
+    }
+    /**
+     * Load clip configs from the clips directory.
+     * Reads clip-config.json if present, or scans subdirectories for clip.json files.
+     */
+    async loadInstalledClips() {
+        const configFile = path.join(path.dirname(this.clipsDir), 'clip-config.json');
+        if (fs.existsSync(configFile)) {
+            try {
+                const content = fs.readFileSync(configFile, 'utf-8');
+                const configs = JSON.parse(content);
+                for (const config of configs) {
+                    this.registerClip(config);
+                }
+                return;
+            }
+            catch {
+                console.warn('[clip-manager] failed to parse clip-config.json, scanning directory');
+            }
+        }
+        if (!fs.existsSync(this.clipsDir))
+            return;
+        const entries = fs.readdirSync(this.clipsDir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (!entry.isDirectory())
+                continue;
+            const clipDir = path.join(this.clipsDir, entry.name);
+            // Try clip.json first, fall back to package.json
+            const clipJsonPath = path.join(clipDir, 'clip.json');
+            const pkgJsonPath = path.join(clipDir, 'package.json');
+            if (fs.existsSync(clipJsonPath)) {
+                try {
+                    const clipJson = JSON.parse(fs.readFileSync(clipJsonPath, 'utf-8'));
+                    this.registerClip({
+                        name: clipJson.name || entry.name,
+                        package: clipJson.name,
+                        version: clipJson.version,
+                        source: clipDir,
+                        path: clipDir,
+                    });
+                }
+                catch {
+                    console.warn(`[clip-manager] failed to parse clip.json in ${clipDir}`);
+                }
+            }
+            else if (fs.existsSync(pkgJsonPath)) {
+                try {
+                    const pkgJson = JSON.parse(fs.readFileSync(pkgJsonPath, 'utf-8'));
+                    this.registerClip({
+                        name: pkgJson.name || entry.name,
+                        package: pkgJson.name,
+                        version: pkgJson.version,
+                        source: clipDir,
+                        path: clipDir,
+                    });
+                }
+                catch {
+                    console.warn(`[clip-manager] failed to parse package.json in ${clipDir}`);
+                }
+            }
+        }
+    }
+    // --- internal ---
+    async ensureProcess(name) {
+        if (this.shuttingDown.has(name)) {
+            throw new Error(`clip "${name}" is shutting down`);
+        }
+        const existing = this.processes.get(name);
+        if (existing && existing.alive())
+            return existing;
+        // Deduplicate concurrent cold-start requests
+        const inflight = this.startingUp.get(name);
+        if (inflight)
+            return inflight;
+        const config = this.clipConfigs.get(name);
+        if (!config)
+            throw new Error(`clip "${name}" not registered`);
+        const startup = this.spawnProcess(config);
+        this.startingUp.set(name, startup);
+        try {
+            return await startup;
+        }
+        finally {
+            this.startingUp.delete(name);
+        }
+    }
+    async spawnProcess(config) {
+        const proc = new ClipProcess(config);
+        const clipDataDir = this.ensureClipDataDir(config);
+        const bunPath = this.resolveBun();
+        proc.spawn(bunPath, {
+            PINIX_DATA_DIR: clipDataDir,
+            // Expose the embedded bun's directory on the clip's PATH so a clip that
+            // shells out to `bun` by name resolves it — the daemon's launchd PATH
+            // does not include Frameworks/. Symmetric with installDeps(); relies on
+            // the embedded binary being named `bun` (Frameworks/bun).
+            PATH: `${path.dirname(bunPath)}${path.delimiter}${process.env.PATH ?? ''}`,
+        });
+        this.setStatus(config.name, 'running', 'starting');
+        try {
+            await proc.waitReady();
+            // Only expose to concurrent callers after registration completes
+            this.processes.set(config.name, proc);
+            this.setStatus(config.name, 'running', 'ready');
+            // Always cache manifest so Provider registrations have commands
+            const manifest = proc.getManifest();
+            if (manifest) {
+                config.manifest = manifest;
+                this.notifyManifestUpdate(config);
+            }
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            this.setStatus(config.name, 'error', message);
+            throw err;
+        }
+        // Monitor process exit in background
+        proc.waitDone().then(() => {
+            this.removeIfSame(config.name, proc);
+            const exitErr = proc.getError();
+            if (exitErr) {
+                this.setStatus(config.name, 'error', exitErr.message);
+            }
+            else {
+                this.setStatus(config.name, 'sleeping', 'exited');
+            }
+        });
+        return proc;
+    }
+    ensureClipDataDir(config) {
+        const dir = path.join(this.dataDir, config.name);
+        fs.mkdirSync(dir, { recursive: true });
+        return dir;
+    }
+    removeIfSame(name, proc) {
+        if (this.processes.get(name) === proc) {
+            this.processes.delete(name);
+        }
+    }
+    setStatus(name, status, message) {
+        this.statuses.set(name, { status, message, since: new Date() });
+        for (const fn of this.statusListeners) {
+            try {
+                fn(name, status, message);
+            }
+            catch {
+                /* listener must not break status propagation */
+            }
+        }
+    }
+}