@parall/daemon 1.30.0 → 1.32.0

package/dist/clip-runtime/process.js

@@ -0,0 +1,350 @@
+import { spawn } from 'node:child_process';
+import { createInterface } from 'node:readline';
+import { clearAllProviderCreds } from '../runtimes.js';
+import { NdjsonReader, NdjsonWriter, MessageType } from './ipc.js';
+import { manifestFromIpc, enrichManifest, resolveEntrypoint, } from './manifest.js';
+const CLIP_REGISTER_TIMEOUT_MS = 10_000;
+const CLIP_STOP_TIMEOUT_MS = 5_000;
+function sanitizeEnvForClip(extra) {
+    const env = { ...process.env };
+    clearAllProviderCreds(env);
+    delete env.PRLL_API_KEY;
+    delete env.PRLL_PROVIDER_CONFIG;
+    delete env.PRLL_DAEMON_MODE;
+    Object.assign(env, extra);
+    return env;
+}
+export class ClipCommandError extends Error {
+    code;
+    constructor(message, code) {
+        super(message);
+        this.name = 'ClipCommandError';
+        this.code = code;
+    }
+}
+function makeDeferred() {
+    let resolve;
+    let reject;
+    const promise = new Promise((res, rej) => {
+        resolve = res;
+        reject = rej;
+    });
+    return { promise, resolve, reject };
+}
+export class ClipProcess {
+    clip;
+    child = null;
+    reader = null;
+    writer = null;
+    registered = false;
+    manifest = null;
+    pending = new Map();
+    nextId = 0;
+    aborted = false;
+    stopping = false;
+    readyDeferred = makeDeferred();
+    readyResolved = false;
+    doneDeferred = makeDeferred();
+    doneResolved = false;
+    exitError;
+    constructor(clip) {
+        this.clip = clip;
+    }
+    /**
+     * Spawn the Bun subprocess and start the IPC read loop.
+     * Corresponds to Pinix startLocked().
+     */
+    spawn(bunPath, env) {
+        const entrypoint = resolveEntrypoint(this.clip);
+        this.child = spawn(bunPath, ['run', entrypoint, '--ipc'], {
+            cwd: this.clip.path,
+            env: sanitizeEnvForClip({
+                ...env,
+                PINIX_URL: env.PINIX_URL || 'http://127.0.0.1:9000',
+                PINIX_DATA_DIR: env.PINIX_DATA_DIR || '',
+            }),
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        this.writer = new NdjsonWriter(this.child.stdin);
+        this.reader = new NdjsonReader(this.child.stdout);
+        // stderr → daemon log with clip name prefix
+        const stderrRl = createInterface({ input: this.child.stderr, crlfDelay: Infinity });
+        stderrRl.on('line', (line) => {
+            console.log(`[clip:${this.clip.name}] ${line}`);
+        });
+        this.readLoop().catch((err) => this.finish(err));
+        this.child.on('exit', (code, signal) => {
+            const err = this.stopping
+                ? undefined
+                : signal
+                    ? new Error(`clip "${this.clip.name}" killed by ${signal}`)
+                    : code !== 0
+                        ? new Error(`clip "${this.clip.name}" exited with code ${code}`)
+                        : undefined;
+            this.finish(err);
+        });
+        this.child.on('error', (err) => {
+            this.finish(err);
+        });
+    }
+    async waitReady(timeoutMs = CLIP_REGISTER_TIMEOUT_MS) {
+        let timer;
+        const timeout = new Promise((_, reject) => {
+            timer = setTimeout(() => {
+                this.abort(new Error(`clip "${this.clip.name}" did not register within ${timeoutMs}ms`));
+                reject(new Error(`clip "${this.clip.name}" did not register within ${timeoutMs}ms`));
+            }, timeoutMs);
+        });
+        try {
+            await Promise.race([this.readyDeferred.promise, timeout]);
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+    waitDone() {
+        return this.doneDeferred.promise;
+    }
+    async invoke(command, input) {
+        return this.invokeStream(command, input);
+    }
+    async invokeStream(command, input, onChunk) {
+        if (!this.alive())
+            throw new Error(`clip "${this.clip.name}" is not running`);
+        const requestId = String(this.nextId++);
+        const events = [];
+        const resultPromise = new Promise((resolve, reject) => {
+            this.pending.set(requestId, (event) => {
+                switch (event.type) {
+                    case MessageType.Result: {
+                        this.pending.delete(requestId);
+                        resolve({ output: event.output });
+                        break;
+                    }
+                    case MessageType.Error: {
+                        this.pending.delete(requestId);
+                        const msg = event.error?.message ?? 'unknown clip error';
+                        if (event.processExit) {
+                            reject(new Error(msg));
+                        }
+                        else {
+                            reject(new ClipCommandError(msg, event.error?.code));
+                        }
+                        break;
+                    }
+                    case MessageType.Chunk: {
+                        if (onChunk)
+                            onChunk(event.output);
+                        events.push(event);
+                        break;
+                    }
+                    case MessageType.Done: {
+                        this.pending.delete(requestId);
+                        let output = event.output;
+                        if (output === undefined && events.length > 0) {
+                            output = events.map((e) => e.output);
+                        }
+                        resolve({ output });
+                        break;
+                    }
+                }
+            });
+        });
+        const invokeMsg = {
+            id: requestId,
+            type: MessageType.Invoke,
+            command,
+            input: input ?? {},
+        };
+        try {
+            await this.send(invokeMsg);
+        }
+        catch (err) {
+            this.pending.delete(requestId);
+            throw err;
+        }
+        return resultPromise;
+    }
+    async stop(timeoutMs = CLIP_STOP_TIMEOUT_MS) {
+        if (!this.child || !this.alive())
+            return;
+        this.stopping = true;
+        this.child.kill('SIGTERM');
+        let timer;
+        const timeout = new Promise((resolve) => {
+            timer = setTimeout(() => {
+                if (this.child && this.alive()) {
+                    this.child.kill('SIGKILL');
+                }
+                resolve();
+            }, timeoutMs);
+        });
+        try {
+            await Promise.race([this.doneDeferred.promise, timeout]);
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+    alive() {
+        return (this.child !== null &&
+            !this.aborted &&
+            this.child.exitCode === null &&
+            this.child.signalCode === null);
+    }
+    getManifest() {
+        return this.manifest;
+    }
+    getError() {
+        return this.exitError;
+    }
+    // --- internal ---
+    async readLoop() {
+        if (!this.reader)
+            return;
+        for await (const msg of this.reader) {
+            try {
+                this.handleMessage(msg);
+            }
+            catch (err) {
+                console.warn(`[clip:${this.clip.name}] error handling message:`, err);
+            }
+        }
+    }
+    handleMessage(msg) {
+        // First message must be register
+        if (!this.registered && msg.type !== MessageType.Register) {
+            console.warn(`[clip:${this.clip.name}] expected register as first message, got "${msg.type}"`);
+            return;
+        }
+        switch (msg.type) {
+            case MessageType.Register:
+                this.handleRegister(msg);
+                break;
+            case MessageType.Result:
+            case MessageType.Error:
+            case MessageType.Chunk:
+            case MessageType.Done:
+                this.dispatchInvokeEvent(msg);
+                break;
+            case MessageType.Data:
+                this.handleData(msg);
+                break;
+            case MessageType.ListClips:
+                // Clip-to-clip list request — respond with empty for now (Phase 2)
+                this.send({
+                    id: msg.id,
+                    type: MessageType.ListClipsResult,
+                    clips: [],
+                }).catch(() => { });
+                break;
+            case MessageType.Invoke:
+                // Clip-to-clip invoke — not routed in Phase 1
+                this.send({
+                    id: msg.id,
+                    type: MessageType.Error,
+                    error: 'clip-to-clip invoke not supported yet',
+                }).catch(() => { });
+                break;
+            case MessageType.Heartbeat:
+                break;
+            default:
+                console.warn(`[clip:${this.clip.name}] unknown message type: ${msg.type}`);
+        }
+    }
+    handleRegister(msg) {
+        if (this.registered) {
+            console.warn(`[clip:${this.clip.name}] duplicate register message, ignoring`);
+            return;
+        }
+        let manifest;
+        if (msg.manifest) {
+            manifest = manifestFromIpc(msg.manifest);
+        }
+        else {
+            manifest = {
+                name: this.clip.name,
+                commands: [],
+                commandDetails: [],
+            };
+        }
+        manifest = enrichManifest(this.clip, manifest);
+        this.manifest = manifest;
+        this.registered = true;
+        this.send({ type: MessageType.Registered }).catch((err) => {
+            console.error(`[clip:${this.clip.name}] failed to send registered:`, err);
+        });
+        this.signalReady();
+    }
+    dispatchInvokeEvent(msg) {
+        if (!msg.id) {
+            console.warn(`[clip:${this.clip.name}] invoke response missing id`);
+            return;
+        }
+        const callback = this.pending.get(msg.id);
+        if (!callback) {
+            console.warn(`[clip:${this.clip.name}] no pending invoke for id ${msg.id}`);
+            return;
+        }
+        const event = { type: msg.type };
+        if (msg.output !== undefined)
+            event.output = msg.output;
+        if (msg.error)
+            event.error = { message: msg.error };
+        callback(event);
+    }
+    handleData(msg) {
+        // Data operations (file I/O) — stub for Phase 1
+        this.send({
+            id: msg.id,
+            type: MessageType.DataResult,
+            error: 'data operations not implemented yet',
+        }).catch(() => { });
+    }
+    async send(msg) {
+        if (!this.writer)
+            throw new Error('writer not initialized');
+        return this.writer.send(msg);
+    }
+    signalReady() {
+        if (this.readyResolved)
+            return;
+        this.readyResolved = true;
+        this.readyDeferred.resolve();
+    }
+    finish(err) {
+        if (this.doneResolved)
+            return;
+        this.doneResolved = true;
+        this.exitError = err;
+        // Close stdin to signal the child
+        if (this.child?.stdin && !this.child.stdin.destroyed) {
+            this.child.stdin.end();
+        }
+        this.reader?.close();
+        this.writer?.close();
+        // Reject all pending invokes with process-exit flag (not ClipCommandError)
+        const errorEvent = {
+            type: MessageType.Error,
+            error: { message: err?.message ?? 'clip process exited' },
+            processExit: true,
+        };
+        for (const [id, callback] of this.pending) {
+            callback(errorEvent);
+        }
+        this.pending.clear();
+        // If not yet registered, reject the ready promise
+        if (!this.readyResolved) {
+            this.readyResolved = true;
+            this.readyDeferred.reject(err ?? new Error('clip process exited before registering'));
+        }
+        this.doneDeferred.resolve();
+    }
+    abort(err) {
+        this.aborted = true;
+        this.finish(err);
+        if (this.child && this.child.exitCode === null && !this.child.killed) {
+            this.child.kill('SIGKILL');
+        }
+    }
+}

package/dist/config.d.ts

@@ -47,6 +47,12 @@ export type ClaudeDaemonConfig = {
      */
     supervisorRestartBackoffMs: number;
     supervisorRestartBackoffMaxMs: number;
+    /** CDN base URL for daemon bundle manifest (includes channel prefix). */
+    updateCdnUrl: string;
+    /** Update check interval in ms. Default 6h. Set 0 to disable periodic check. */
+    updateIntervalMs: number;
+    /** Disable self-update entirely (K8s env auto-disables). */
+    updateDisabled: boolean;
 };
 export declare function daemonConfigDir(env?: NodeJS.ProcessEnv): string;
 export declare function daemonConfigPath(env?: NodeJS.ProcessEnv): string;
@@ -63,5 +69,12 @@ export declare function sharedClaudeCredentialsFileFor(rootClaudeHome: string):
 export declare function agentClaudeCredentialsFileFor(agentClaudeHome: string): string;
 /** Per-agent workspace dir where the agent runs git commands. */
 export declare function agentWorkspaceDirFor(rootStateDir: string, agentId: string): string;
+/**
+ * Resolve the bundle directory for self-update storage.
+ * Desktop: ~/Library/Application Support/Parall/daemon/ (set via env)
+ * Default: ~/.parall-daemon/bundle/ — always a writable overlay directory,
+ * never the npm global install dir (which may be root-owned or read-only).
+ */
+export declare function resolveBundleDir(env?: NodeJS.ProcessEnv): string;
 export declare function resolveWsUrl(apiUrl: string, explicitWsUrl?: string, swimlaneName?: string): string;
 //# sourceMappingURL=config.d.ts.map

package/dist/config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,kBAAkB,GAAG;IAC/B,MAAM,EAAE,MAAM,CAAC;IACf,qCAAqC;IACrC,MAAM,EAAE,MAAM,CAAC;IACf,2GAA2G;IAC3G,QAAQ,EAAE,MAAM,CAAC;IACjB,yFAAyF;IACzF,YAAY,EAAE,MAAM,CAAC;IACrB,kGAAkG;IAClG,cAAc,EAAE,MAAM,CAAC;IACvB,wEAAwE;IACxE,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,oDAAoD;IACpD,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,iFAAiF;IACjF,cAAc,EAAE,MAAM,CAAC;IACvB,iFAAiF;IACjF,mBAAmB,EAAE,MAAM,CAAC;IAC5B,oDAAoD;IACpD,gBAAgB,EAAE,MAAM,CAAC;IACzB,oFAAoF;IACpF,mBAAmB,EAAE,MAAM,CAAC;IAC5B;;;;;OAKG;IACH,kBAAkB,EAAE,MAAM,CAAC;IAC3B,qBAAqB,EAAE,MAAM,CAAC;IAC9B;;;;OAIG;IACH,0BAA0B,EAAE,MAAM,CAAC;IACnC,6BAA6B,EAAE,MAAM,CAAC;CACvC,CAAC;AA2BF,wBAAgB,eAAe,CAAC,GAAG,GAAE,MAAM,CAAC,UAAwB,GAAG,MAAM,CAE5E;AAED,wBAAgB,gBAAgB,CAAC,GAAG,GAAE,MAAM,CAAC,UAAwB,GAAG,MAAM,CAE7E;AAyBD,wBAAgB,yBAAyB,CAAC,GAAG,GAAE,MAAM,CAAC,UAAwB,GAAG,kBAAkB,CA6ClG;AASD,wDAAwD;AACxD,wBAAgB,gBAAgB,CAAC,YAAY,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAE9E;AAED;;mEAEmE;AACnE,wBAAgB,kBAAkB,CAAC,cAAc,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAElF;AAED,+EAA+E;AAC/E,wBAAgB,8BAA8B,CAAC,cAAc,EAAE,MAAM,GAAG,MAAM,CAE7E;AAED,uEAAuE;AACvE,wBAAgB,6BAA6B,CAAC,eAAe,EAAE,MAAM,GAAG,MAAM,CAE7E;AAED,iEAAiE;AACjE,wBAAgB,oBAAoB,CAAC,YAAY,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAElF;AAED,wBAAgB,YAAY,CAAC,MAAM,EAAE,MAAM,EAAE,aAAa,CAAC,EAAE,MAAM,EAAE,YAAY,CAAC,EAAE,MAAM,GAAG,MAAM,CAMlG"}
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,kBAAkB,GAAG;IAC/B,MAAM,EAAE,MAAM,CAAC;IACf,qCAAqC;IACrC,MAAM,EAAE,MAAM,CAAC;IACf,2GAA2G;IAC3G,QAAQ,EAAE,MAAM,CAAC;IACjB,yFAAyF;IACzF,YAAY,EAAE,MAAM,CAAC;IACrB,kGAAkG;IAClG,cAAc,EAAE,MAAM,CAAC;IACvB,wEAAwE;IACxE,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,oDAAoD;IACpD,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,iFAAiF;IACjF,cAAc,EAAE,MAAM,CAAC;IACvB,iFAAiF;IACjF,mBAAmB,EAAE,MAAM,CAAC;IAC5B,oDAAoD;IACpD,gBAAgB,EAAE,MAAM,CAAC;IACzB,oFAAoF;IACpF,mBAAmB,EAAE,MAAM,CAAC;IAC5B;;;;;OAKG;IACH,kBAAkB,EAAE,MAAM,CAAC;IAC3B,qBAAqB,EAAE,MAAM,CAAC;IAC9B;;;;OAIG;IACH,0BAA0B,EAAE,MAAM,CAAC;IACnC,6BAA6B,EAAE,MAAM,CAAC;IACtC,yEAAyE;IACzE,YAAY,EAAE,MAAM,CAAC;IACrB,gFAAgF;IAChF,gBAAgB,EAAE,MAAM,CAAC;IACzB,4DAA4D;IAC5D,cAAc,EAAE,OAAO,CAAC;CACzB,CAAC;AA2BF,wBAAgB,eAAe,CAAC,GAAG,GAAE,MAAM,CAAC,UAAwB,GAAG,MAAM,CAE5E;AAED,wBAAgB,gBAAgB,CAAC,GAAG,GAAE,MAAM,CAAC,UAAwB,GAAG,MAAM,CAE7E;AAyBD,wBAAgB,yBAAyB,CACvC,GAAG,GAAE,MAAM,CAAC,UAAwB,GACnC,kBAAkB,CA0DpB;AASD,wDAAwD;AACxD,wBAAgB,gBAAgB,CAAC,YAAY,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAE9E;AAED;;mEAEmE;AACnE,wBAAgB,kBAAkB,CAAC,cAAc,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAElF;AAED,+EAA+E;AAC/E,wBAAgB,8BAA8B,CAAC,cAAc,EAAE,MAAM,GAAG,MAAM,CAE7E;AAED,uEAAuE;AACvE,wBAAgB,6BAA6B,CAAC,eAAe,EAAE,MAAM,GAAG,MAAM,CAE7E;AAED,iEAAiE;AACjE,wBAAgB,oBAAoB,CAAC,YAAY,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAElF;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,GAAG,GAAE,MAAM,CAAC,UAAwB,GAAG,MAAM,CAG7E;AAED,wBAAgB,YAAY,CAC1B,MAAM,EAAE,MAAM,EACd,aAAa,CAAC,EAAE,MAAM,EACtB,YAAY,CAAC,EAAE,MAAM,GACpB,MAAM,CAMR"}

package/dist/config.js

@@ -1,6 +1,6 @@
-import * as fs from "node:fs";
-import * as os from "node:os";
-import * as path from "node:path";
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
 function requireEnv(env, name) {
     const value = env[name]?.trim();
     if (!value) {
@@ -25,10 +25,10 @@ function parseMsAllowZero(value, fallback) {
     return Number.isFinite(n) && n >= 0 ? n : fallback;
 }
 export function daemonConfigDir(env = process.env) {
-    return path.join(env.HOME || os.homedir(), ".parall-daemon");
+    return path.join(env.HOME || os.homedir(), '.parall-daemon');
 }
 export function daemonConfigPath(env = process.env) {
-    return path.join(daemonConfigDir(env), "config.json");
+    return path.join(daemonConfigDir(env), 'config.json');
 }
 function tryLoadConfigFile(env) {
     const cfgPath = daemonConfigPath(env);
@@ -51,8 +51,8 @@ function tryLoadConfigFile(env) {
     }
 }
 export function resolveClaudeDaemonConfig(env = process.env) {
-    let apiUrl = env.PRLL_API_URL?.trim() || "";
-    let apiKey = env.PRLL_API_KEY?.trim() || "";
+    let apiUrl = env.PRLL_API_URL?.trim() || '';
+    let apiKey = env.PRLL_API_KEY?.trim() || '';
     // Fall back to config file for values not provided via env.
     if (!apiUrl || !apiKey) {
         const file = tryLoadConfigFile(env);
@@ -64,21 +64,21 @@ export function resolveClaudeDaemonConfig(env = process.env) {
         }
     }
     if (!apiUrl)
-        throw new Error("Missing required env var: PRLL_API_URL");
+        throw new Error('Missing required env var: PRLL_API_URL');
     if (!apiKey)
-        throw new Error("Missing required env var: PRLL_API_KEY");
-    if (!apiKey.startsWith("mck_")) {
+        throw new Error('Missing required env var: PRLL_API_KEY');
+    if (!apiKey.startsWith('mck_')) {
         // Fatal startup validation: the daemon must never run with an agent or
         // human key because child launch credentials are minted from this bearer.
         throw new Error(`PRLL_API_KEY does not look like a Machine bearer (expected prefix "mck_"). ` +
             `Daemon mode requires a machine-scoped key issued via POST /machines/{id}/keys.`);
     }
     const rootClaudeHome = resolvePath(env.PRLL_CLAUDE_HOME?.trim() || env.HOME || os.homedir());
-    const rootStateDir = resolvePath(env.PRLL_CLAUDE_STATE_DIR?.trim() || path.join(rootClaudeHome, ".parall-agent"));
+    const rootStateDir = resolvePath(env.PRLL_CLAUDE_STATE_DIR?.trim() || path.join(rootClaudeHome, '.parall-agent'));
     return {
         apiUrl,
         apiKey,
-        agentBin: env.PRLL_CLAUDE_AGENT_BIN?.trim() || "parall-claude-agent",
+        agentBin: env.PRLL_CLAUDE_AGENT_BIN?.trim() || 'parall-claude-agent',
         rootStateDir,
         rootClaudeHome,
         wsUrl: env.PRLL_WS_URL?.trim() || undefined,
@@ -91,6 +91,12 @@ export function resolveClaudeDaemonConfig(env = process.env) {
         bootstrapBackoffMaxMs: parseMs(env.PRLL_DAEMON_BOOTSTRAP_BACKOFF_MAX_MS, 60_000),
         supervisorRestartBackoffMs: parseMsAllowZero(env.PRLL_DAEMON_SUPERVISOR_RESTART_BACKOFF_MS, 5_000),
         supervisorRestartBackoffMaxMs: parseMs(env.PRLL_DAEMON_SUPERVISOR_RESTART_BACKOFF_MAX_MS, 5 * 60_000),
+        updateCdnUrl: env.PRLL_DAEMON_UPDATE_CDN_URL?.trim() ||
+            ((env.PRLL_DAEMON_UPDATE_CHANNEL?.trim() ?? 'production') === 'staging'
+                ? 'https://releases.staging.prll.sh/daemon/staging'
+                : 'https://releases.parall.com/daemon/production'),
+        updateIntervalMs: parseMsAllowZero(env.PRLL_DAEMON_UPDATE_INTERVAL_MS, 6 * 60 * 60_000),
+        updateDisabled: env.PRLL_DAEMON_UPDATE_DISABLED === 'true' || !!env.KUBERNETES_SERVICE_HOST,
     };
 }
 function assertSafeAgentId(agentId) {
@@ -101,31 +107,42 @@ function assertSafeAgentId(agentId) {
 }
 /** Per-agent state dir under the shared host volume. */
 export function agentStateDirFor(rootStateDir, agentId) {
-    return path.join(rootStateDir, "agents", assertSafeAgentId(agentId));
+    return path.join(rootStateDir, 'agents', assertSafeAgentId(agentId));
 }
 /** Per-agent HOME dir. Claude Code stores project/session state under
  * `${HOME}/.claude`, so each agent gets its own HOME root while the daemon
  * links shared OAuth credentials into that `.claude` directory. */
 export function agentClaudeHomeFor(rootClaudeHome, agentId) {
-    return path.join(rootClaudeHome, "agents", assertSafeAgentId(agentId));
+    return path.join(rootClaudeHome, 'agents', assertSafeAgentId(agentId));
 }
 /** Shared Claude Code OAuth credential written by server-side runtime auth. */
 export function sharedClaudeCredentialsFileFor(rootClaudeHome) {
-    return path.join(rootClaudeHome, ".claude", ".credentials.json");
+    return path.join(rootClaudeHome, '.claude', '.credentials.json');
 }
 /** Per-agent credential location inside that agent's isolated HOME. */
 export function agentClaudeCredentialsFileFor(agentClaudeHome) {
-    return path.join(agentClaudeHome, ".claude", ".credentials.json");
+    return path.join(agentClaudeHome, '.claude', '.credentials.json');
 }
 /** Per-agent workspace dir where the agent runs git commands. */
 export function agentWorkspaceDirFor(rootStateDir, agentId) {
-    return path.join(rootStateDir, "agents", assertSafeAgentId(agentId), "workspace");
+    return path.join(rootStateDir, 'agents', assertSafeAgentId(agentId), 'workspace');
+}
+/**
+ * Resolve the bundle directory for self-update storage.
+ * Desktop: ~/Library/Application Support/Parall/daemon/ (set via env)
+ * Default: ~/.parall-daemon/bundle/ — always a writable overlay directory,
+ * never the npm global install dir (which may be root-owned or read-only).
+ */
+export function resolveBundleDir(env = process.env) {
+    if (env.PRLL_DAEMON_BUNDLE_DIR)
+        return resolvePath(env.PRLL_DAEMON_BUNDLE_DIR);
+    return path.join(daemonConfigDir(env), 'bundle');
 }
 export function resolveWsUrl(apiUrl, explicitWsUrl, swimlaneName) {
-    const base = explicitWsUrl || `${apiUrl.replace(/\/$/, "").replace(/^http/, "ws")}/ws`;
+    const base = explicitWsUrl || `${apiUrl.replace(/\/$/, '').replace(/^http/, 'ws')}/ws`;
     if (!swimlaneName)
         return base;
     const url = new URL(base);
-    url.searchParams.set("swimlane", swimlaneName);
+    url.searchParams.set('swimlane', swimlaneName);
     return url.toString();
 }

package/dist/filesystem.d.ts

@@ -1,4 +1,4 @@
-import type { FilesystemEntry } from "@parall/sdk";
+import type { FilesystemEntry } from '@parall/sdk';
 export declare function browseDenyReason(value: string): string;
 export declare function listDirectory(dirPath: string): Promise<{
     entries: FilesystemEntry[];

package/dist/filesystem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"filesystem.d.ts","sourceRoot":"","sources":["../src/filesystem.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAqCnD,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAkBtD;AAoBD,wBAAsB,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC;IAAE,OAAO,EAAE,eAAe,EAAE,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,CA8C5G"}
+{"version":3,"file":"filesystem.d.ts","sourceRoot":"","sources":["../src/filesystem.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAqCnD,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAkBtD;AAkBD,wBAAsB,aAAa,CACjC,OAAO,EAAE,MAAM,GACd,OAAO,CAAC;IAAE,OAAO,EAAE,eAAe,EAAE,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,CA8CzD"}