@parall/daemon 1.28.1 → 1.29.1

package/dist/supervisor.js

@@ -4,11 +4,13 @@ import * as path from "node:path";
 import { ParallWs } from "@parall/sdk";
 import { agentClaudeCredentialsFileFor, agentClaudeHomeFor, agentStateDirFor, agentWorkspaceDirFor, sharedClaudeCredentialsFileFor, } from "./config.js";
 import { assertAgentKey, getRuntimeAdapter } from "./runtimes.js";
+import { prepareWorkspace } from "./workspace.js";
 const RUNTIME_PACKAGES = {
     'claude-code': '@parall/claude-agent',
     'codex': '@parall/codex-agent',
     'openclaw': '@parall/openclaw-agent',
 };
+const WORKSPACE_SETUP_RETRY_DELAY_MS = 5_000;
 /**
  * Sleep that wakes early on abort. Returns true if the full delay elapsed,
  * false if aborted. Used by bootstrap retry and the outer keepalive in
@@ -46,9 +48,14 @@ export class DaemonSupervisor {
     client;
     log;
     children = new Map();
+    spawningAgents = new Set();
+    pendingWorkspaceSetup = new Set();
+    workspaceSetupRetryTimers = new Map();
+    cancelledSpawns = new Set();
     ws = null;
     running = false;
     machineOrgId = null;
+    machineLlmSource = "parall";
     stopResolve = null;
     constructor(config, client, log) {
         this.config = config;
@@ -85,7 +92,10 @@ export class DaemonSupervisor {
         });
         this.ws.on("machine.hello", (_data) => {
             this.log.info("machine WS connected (machine.hello)");
-            void this.fullReconcile();
+            void (async () => {
+                await this.refreshMachineConfig();
+                await this.fullReconcile();
+            })();
         });
         this.ws.on("machine.agent.attached", (data) => {
             this.log.info(`WS: agent ${data.agent_id} attached`);
@@ -95,6 +105,18 @@ export class DaemonSupervisor {
             this.log.info(`WS: agent ${data.agent_id} detached`);
             void this.handleAgentDetached(data.agent_id);
         });
+        this.ws.on("machine.config.updated", (data) => {
+            const newSource = data.llm_source ?? "parall";
+            if (newSource !== this.machineLlmSource) {
+                this.log.info(`WS: llm_source changed ${this.machineLlmSource} → ${newSource}, respawning all agents`);
+                this.machineLlmSource = newSource;
+                void this.respawnAllChildren();
+            }
+        });
+        this.ws.on("machine.workspace.setup.requested", (data) => {
+            this.log.info(`WS: workspace setup requested for agent ${data.agent_id}`);
+            void this.handleWorkspaceSetupRequested(data.agent_id);
+        });
         this.ws.on("machine.stop", (data) => {
             this.log.info(`WS: machine.stop received (reason=${data.reason ?? "none"})`);
             void this.stop();
@@ -120,6 +142,10 @@ export class DaemonSupervisor {
             this.ws = null;
         }
         const exits = [];
+        for (const timer of this.workspaceSetupRetryTimers.values()) {
+            clearTimeout(timer);
+        }
+        this.workspaceSetupRetryTimers.clear();
         for (const state of this.children.values()) {
             state.shuttingDown = true;
             if (state.restartTimer) {
@@ -143,6 +169,7 @@ export class DaemonSupervisor {
             try {
                 const machine = await this.client.getMachineSelf();
                 this.machineOrgId = machine.org_id;
+                this.machineLlmSource = machine.llm_source ?? "parall";
                 this.log.info(`daemon online — machine_id=${machine.id} org=${machine.org_id} label=${machine.label}`);
                 return true;
             }
@@ -264,24 +291,31 @@ export class DaemonSupervisor {
         }
     }
     // ---- WS event handlers (incremental) ----
-    async handleAgentAttached(agentId) {
-        if (this.children.has(agentId))
-            return;
+    async fetchAttachedAgent(agentId) {
         let attached;
         try {
             attached = await this.client.listAttachedAgents();
         }
         catch (err) {
-            this.log.warn(`handleAgentAttached: listAttachedAgents failed: ${String(err)}`);
-            return;
+            this.log.warn(`fetchAttachedAgent: listAttachedAgents failed: ${String(err)}`);
+            return { kind: "retryable" };
         }
         const entry = attached.find((a) => (a.user?.id ?? a.profile.user_id) === agentId);
         if (!entry) {
-            this.log.warn(`handleAgentAttached: agent ${agentId} not found in attached list`);
-            return;
+            this.log.warn(`fetchAttachedAgent: agent ${agentId} not found in attached list`);
+            return { kind: "skip" };
         }
         if (entry.user && entry.user.status !== "active") {
             this.log.info(`agent ${agentId} not active (status=${entry.user.status}) — skipping`);
+            return { kind: "skip" };
+        }
+        return { kind: "found", entry };
+    }
+    async handleAgentAttached(agentId) {
+        if (this.children.has(agentId) || this.spawningAgents.has(agentId))
+            return;
+        const result = await this.fetchAttachedAgent(agentId);
+        if (result.kind !== "found") {
             return;
         }
         const orgId = this.machineOrgId;
@@ -289,9 +323,14 @@ export class DaemonSupervisor {
             this.log.warn(`agent ${agentId}: no org_id available yet; skipping`);
             return;
         }
-        await this.spawnAgent(agentId, orgId, entry);
+        await this.spawnAgent(agentId, orgId, result.entry);
     }
     async handleAgentDetached(agentId) {
+        this.pendingWorkspaceSetup.delete(agentId);
+        this.clearWorkspaceSetupRetry(agentId);
+        if (this.spawningAgents.has(agentId)) {
+            this.cancelledSpawns.add(agentId);
+        }
         const state = this.children.get(agentId);
         if (!state)
             return;
@@ -304,7 +343,87 @@ export class DaemonSupervisor {
         await this.terminateChild(state);
         this.children.delete(agentId);
     }
+    async handleWorkspaceSetupRequested(agentId) {
+        if (this.spawningAgents.has(agentId)) {
+            this.log.info(`agent ${agentId}: workspace setup already in progress; queueing one restart`);
+            this.pendingWorkspaceSetup.add(agentId);
+            return;
+        }
+        const result = await this.fetchAttachedAgent(agentId);
+        if (result.kind === "retryable") {
+            this.pendingWorkspaceSetup.add(agentId);
+            this.scheduleWorkspaceSetupRetry(agentId);
+            return;
+        }
+        if (result.kind === "skip") {
+            this.pendingWorkspaceSetup.delete(agentId);
+            this.clearWorkspaceSetupRetry(agentId);
+            return;
+        }
+        this.clearWorkspaceSetupRetry(agentId);
+        const state = this.children.get(agentId);
+        if (state) {
+            this.log.info(`agent ${agentId}: restarting for workspace setup`);
+            state.shuttingDown = true;
+            if (state.restartTimer) {
+                clearTimeout(state.restartTimer);
+                state.restartTimer = null;
+            }
+            await this.terminateChild(state);
+            this.children.delete(agentId);
+        }
+        const orgId = this.machineOrgId;
+        if (!orgId) {
+            this.log.warn(`agent ${agentId}: no org_id available yet; skipping`);
+            return;
+        }
+        await this.spawnAgent(agentId, orgId, result.entry);
+    }
+    scheduleWorkspaceSetupRetry(agentId) {
+        if (!this.running || this.workspaceSetupRetryTimers.has(agentId))
+            return;
+        const timer = setTimeout(() => {
+            this.workspaceSetupRetryTimers.delete(agentId);
+            if (this.running && this.pendingWorkspaceSetup.has(agentId)) {
+                void this.handleWorkspaceSetupRequested(agentId);
+            }
+        }, WORKSPACE_SETUP_RETRY_DELAY_MS);
+        timer.unref?.();
+        this.workspaceSetupRetryTimers.set(agentId, timer);
+    }
+    clearWorkspaceSetupRetry(agentId) {
+        const timer = this.workspaceSetupRetryTimers.get(agentId);
+        if (timer) {
+            clearTimeout(timer);
+            this.workspaceSetupRetryTimers.delete(agentId);
+        }
+    }
     // ---- Spawn / restart ----
+    async refreshMachineConfig() {
+        try {
+            const machine = await this.client.getMachineSelf();
+            const newSource = machine.llm_source ?? "parall";
+            if (newSource !== this.machineLlmSource) {
+                this.log.info(`machine config refreshed: llm_source ${this.machineLlmSource} → ${newSource}`);
+                this.machineLlmSource = newSource;
+                await this.respawnAllChildren();
+            }
+        }
+        catch (err) {
+            this.log.warn(`refreshMachineConfig failed: ${String(err)}`);
+        }
+    }
+    async respawnAllChildren() {
+        const states = [...this.children.values()];
+        for (const state of states) {
+            await this.terminateChild(state);
+        }
+        for (const state of states) {
+            if (!state.shuttingDown && this.running) {
+                await this.restartChildNow(state, "llm_source changed");
+            }
+        }
+    }
     async restartChildNow(state, reason) {
         if (!this.running || state.shuttingDown || state.child || state.restartTimer) {
             return;
@@ -320,6 +439,26 @@ export class DaemonSupervisor {
         }
     }
     async spawnAgent(agentId, orgId, attached) {
+        if (this.children.has(agentId) || this.spawningAgents.has(agentId)) {
+            return;
+        }
+        this.spawningAgents.add(agentId);
+        let shouldReplaySetupRequest = false;
+        try {
+            await this.spawnAgentOnce(agentId, orgId, attached);
+        }
+        finally {
+            this.spawningAgents.delete(agentId);
+            this.cancelledSpawns.delete(agentId);
+            shouldReplaySetupRequest = this.pendingWorkspaceSetup.delete(agentId);
+        }
+        if (shouldReplaySetupRequest && this.running) {
+            queueMicrotask(() => {
+                void this.handleWorkspaceSetupRequested(agentId);
+            });
+        }
+    }
+    async spawnAgentOnce(agentId, orgId, attached) {
         let credential;
         try {
             credential = await this.client.mintLaunchCredential(agentId);
@@ -329,19 +468,13 @@ export class DaemonSupervisor {
             return;
         }
         const stateDir = agentStateDirFor(this.config.rootStateDir, agentId);
-        const workspaceDir = attached.daemon_config?.workspace_path
-            || agentWorkspaceDirFor(this.config.rootStateDir, agentId);
+        const defaultWorkspaceDir = agentWorkspaceDirFor(this.config.rootStateDir, agentId);
         const isK8s = !!process.env.KUBERNETES_SERVICE_HOST;
         const claudeHome = isK8s
             ? agentClaudeHomeFor(this.config.rootClaudeHome, agentId)
             : this.config.rootClaudeHome;
         try {
             fs.mkdirSync(stateDir, { recursive: true });
-            // Only create workspace dir when using the default isolated path —
-            // user-specified workspace_path should already exist.
-            if (!attached.daemon_config?.workspace_path) {
-                fs.mkdirSync(workspaceDir, { recursive: true });
-            }
             if (isK8s) {
                 fs.mkdirSync(claudeHome, { recursive: true });
                 this.ensureSharedCredentialLink(claudeHome, agentId);
@@ -351,12 +484,31 @@ export class DaemonSupervisor {
             this.log.warn(`mkdir agent dirs (${agentId}) failed: ${String(err)}`);
         }
         const runtimeType = attached.profile.runtime_type ?? "claude-code";
+        let workspaceDir;
+        try {
+            workspaceDir = await prepareWorkspace({
+                client: this.client,
+                attached,
+                agentId,
+                defaultWorkspaceDir,
+                log: this.log,
+            });
+        }
+        catch (err) {
+            this.log.error(`agent ${agentId}: workspace setup failed: ${String(err)}`);
+            return;
+        }
+        if (this.cancelledSpawns.delete(agentId)) {
+            this.log.info(`agent ${agentId}: spawn cancelled after detach during workspace setup`);
+            return;
+        }
         const state = {
             agentId,
             orgId,
             runtimeType,
             workspacePath: workspaceDir,
             claudeHome,
+            providerConfig: attached.provider_config ?? { llm_source: this.machineLlmSource },
             child: null,
             credential,
             restartAttempts: 0,
@@ -380,7 +532,7 @@ export class DaemonSupervisor {
             workspaceDir: state.workspacePath,
             claudeHome: state.claudeHome,
         };
-        const env = adapter.buildEnv({ ...process.env, PRLL_API_URL: this.config.apiUrl }, state.agentId, state.orgId, state.credential.api_key, dirs);
+        const env = adapter.buildEnv({ ...process.env, PRLL_API_URL: this.config.apiUrl }, state.agentId, state.orgId, state.credential.api_key, dirs, state.providerConfig);
         this.log.info(`spawning agent ${state.agentId} runtime=${state.runtimeType} bin=${adapter.bin} (attempt ${state.restartAttempts + 1})`);
         const child = spawn(adapter.bin, [], {
             env,
@@ -421,11 +573,12 @@ export class DaemonSupervisor {
             settleChild("error", null, null, err);
         });
         child.once("close", (code, signal) => settleChild("close", code, signal));
-        setTimeout(() => {
+        const stableTimer = setTimeout(() => {
             if (state.child === child) {
                 state.restartAttempts = 0;
             }
         }, Math.max(this.config.restartBackoffMs, 30_000));
+        stableTimer.unref?.();
     }
     async terminateChild(state) {
         const child = state.child;

package/dist/workspace.d.ts

@@ -0,0 +1,11 @@
+import type { GatewayLogger } from "@parall/agent-core";
+import type { AttachedAgent, ParallClient } from "@parall/sdk";
+export interface PrepareWorkspaceOpts {
+    client: ParallClient;
+    attached: AttachedAgent;
+    agentId: string;
+    defaultWorkspaceDir: string;
+    log: GatewayLogger;
+}
+export declare function prepareWorkspace(opts: PrepareWorkspaceOpts): Promise<string>;
+//# sourceMappingURL=workspace.d.ts.map

package/dist/workspace.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workspace.d.ts","sourceRoot":"","sources":["../src/workspace.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACxD,OAAO,KAAK,EAAE,aAAa,EAA4C,YAAY,EAAE,MAAM,aAAa,CAAC;AAiBzG,MAAM,WAAW,oBAAoB;IACnC,MAAM,EAAE,YAAY,CAAC;IACrB,QAAQ,EAAE,aAAa,CAAC;IACxB,OAAO,EAAE,MAAM,CAAC;IAChB,mBAAmB,EAAE,MAAM,CAAC;IAC5B,GAAG,EAAE,aAAa,CAAC;CACpB;AAED,wBAAsB,gBAAgB,CAAC,IAAI,EAAE,oBAAoB,GAAG,OAAO,CAAC,MAAM,CAAC,CAwClF"}