@parall/daemon 1.28.1 → 1.29.0

package/bundle/parall-daemon.js

@@ -1,5 +1,14 @@
 #!/usr/bin/env node
 
+// ts/agent-core/dist/logger.js
+function createLogger(prefix) {
+  return {
+    info: (msg) => console.log(`${(/* @__PURE__ */ new Date()).toISOString()} [${prefix}] ${msg}`),
+    warn: (msg) => console.warn(`${(/* @__PURE__ */ new Date()).toISOString()} [${prefix}] ${msg}`),
+    error: (msg) => console.error(`${(/* @__PURE__ */ new Date()).toISOString()} [${prefix}] ${msg}`)
+  };
+}
+
 // ts/sdk/dist/constants.js
 var API_BASE = "/api/v1";
 var WIKI_BASE = "/wiki/v1";
@@ -46,7 +55,6 @@ var ENDPOINTS = {
   CHAT_MESSAGES: (orgId, chatId) => `${API_BASE}/orgs/${orgId}/chats/${chatId}/messages`,
   // Messages (global, by message ID)
   MESSAGE: (id) => `${API_BASE}/messages/${id}`,
-  MESSAGE_PATCHES: (id) => `${API_BASE}/messages/${id}/patches`,
   MESSAGE_REPLIES: (id) => `${API_BASE}/messages/${id}/replies`,
   // Upload (org-scoped)
   UPLOAD_PRESIGN: (orgId) => `${API_BASE}/orgs/${orgId}/upload/presign`,
@@ -73,6 +81,7 @@ var ENDPOINTS = {
   AGENT_SESSION: (orgId, agentId, sessionId) => `${API_BASE}/orgs/${orgId}/agents/${agentId}/sessions/${sessionId}`,
   AGENT_SESSION_STEPS: (orgId, agentId, sessionId) => `${API_BASE}/orgs/${orgId}/agents/${agentId}/sessions/${sessionId}/steps`,
   AGENT_SESSION_STEP: (orgId, agentId, sessionId, stepId) => `${API_BASE}/orgs/${orgId}/agents/${agentId}/sessions/${sessionId}/steps/${stepId}`,
+  AGENT_STEP_BY_ID: (orgId, stepId) => `${API_BASE}/orgs/${orgId}/agent-steps/${stepId}`,
   AGENT_TASKS: (orgId, agentId) => `${API_BASE}/orgs/${orgId}/agents/${agentId}/tasks`,
   AGENT_RUNTIME_AUTH: (orgId, agentId) => `${API_BASE}/orgs/${orgId}/agents/${agentId}/runtime-auth`,
   AGENT_RUNTIME_AUTH_SESSIONS: (orgId, agentId) => `${API_BASE}/orgs/${orgId}/agents/${agentId}/runtime-auth-sessions`,
@@ -97,9 +106,12 @@ var ENDPOINTS = {
   // Attach/Detach bind an agent to/from a daemon Machine.
   MACHINE_ATTACH_AGENT: (orgId, machineId, agentId) => `${API_BASE}/orgs/${orgId}/machines/${machineId}/agents/${agentId}`,
   MACHINE_DETACH_AGENT: (orgId, machineId, agentId) => `${API_BASE}/orgs/${orgId}/machines/${machineId}/agents/${agentId}`,
+  MACHINE_LLM_SOURCE: (orgId, machineId) => `${API_BASE}/orgs/${orgId}/machines/${machineId}/llm-source`,
   MACHINE_RUNTIME_AUTH: (orgId, machineId) => `${API_BASE}/orgs/${orgId}/machines/${machineId}/runtime-auth`,
   MACHINE_KEYS: (orgId, machineId) => `${API_BASE}/orgs/${orgId}/machines/${machineId}/keys`,
   MACHINE_KEY: (orgId, machineId, keyId) => `${API_BASE}/orgs/${orgId}/machines/${machineId}/keys/${keyId}`,
+  MACHINE_RUNTIME_AUTH_SESSIONS: (orgId, machineId) => `${API_BASE}/orgs/${orgId}/machines/${machineId}/runtime-auth-sessions`,
+  MACHINE_RUNTIME_AUTH_SESSION_COMPLETE: (orgId, machineId, sessionId) => `${API_BASE}/orgs/${orgId}/machines/${machineId}/runtime-auth-sessions/${sessionId}/complete`,
   // Machine self-control-plane (mck_-scoped). The bearer token implicitly
   // identifies the Machine, so there is no `:mid` URL parameter — these are
   // "self" routes called by the daemon for its own host.
@@ -367,10 +379,10 @@ var ParallClient = class _ParallClient {
    * REFRESH_THRESHOLD_S, refresh it **before** sending the request.
    * No-op when the token is still fresh, missing, or un-parseable.
    */
-  async ensureFreshToken(path4) {
+  async ensureFreshToken(path5) {
     if (!this.token || !this.getRefreshToken)
       return;
-    const pathSuffix = path4.replace(/^\/api\/v1/, "");
+    const pathSuffix = path5.replace(/^\/api\/v1/, "");
     if (_ParallClient.AUTH_PATHS.has(pathSuffix))
       return;
     const exp = _ParallClient.decodeJwtExp(this.token);
@@ -402,11 +414,11 @@ var ParallClient = class _ParallClient {
       this.refreshPromise = null;
     }
   }
-  async request(method, path4, body, query, retried = false, opts) {
+  async request(method, path5, body, query, retried = false, opts) {
     if (!retried) {
-      await this.ensureFreshToken(path4);
+      await this.ensureFreshToken(path5);
     }
-    let url = `${this.baseUrl}${path4}`;
+    let url = `${this.baseUrl}${path5}`;
     if (query) {
       const params = new URLSearchParams();
       for (const [key, value] of Object.entries(query)) {
@@ -431,12 +443,12 @@ var ParallClient = class _ParallClient {
       throw _ParallClient.normalizeFetchError(err);
     }
     if (res.status === 401) {
-      const pathSuffix = path4.replace(/^\/api\/v1/, "");
+      const pathSuffix = path5.replace(/^\/api\/v1/, "");
       const isAuthPath = _ParallClient.AUTH_PATHS.has(pathSuffix);
       if (!retried && !isAuthPath && this.getRefreshToken) {
         const refreshed = await this.tryRefresh();
         if (refreshed) {
-          return this.request(method, path4, body, query, true, opts);
+          return this.request(method, path5, body, query, true, opts);
         }
       }
       if (this.onTokenExpired && !isAuthPath) {
@@ -473,15 +485,15 @@ var ParallClient = class _ParallClient {
    * hit the 100 MiB cap, so a longer 5-minute timeout is used so a
    * 50 MiB blob on a slow connection doesn't get chopped at 15 s.
    */
-  async multipartRequest(method, path4, body, retried = false) {
+  async multipartRequest(method, path5, body, retried = false) {
     if (!retried) {
-      await this.ensureFreshToken(path4);
+      await this.ensureFreshToken(path5);
     }
     const { "Content-Type": _drop, ...headers } = this.buildHeaders();
     void _drop;
     let res;
     try {
-      res = await fetch(`${this.baseUrl}${path4}`, {
+      res = await fetch(`${this.baseUrl}${path5}`, {
         method,
         headers,
         body,
@@ -491,12 +503,12 @@ var ParallClient = class _ParallClient {
       throw _ParallClient.normalizeFetchError(err);
     }
     if (res.status === 401) {
-      const pathSuffix = path4.replace(/^\/api\/v1/, "");
+      const pathSuffix = path5.replace(/^\/api\/v1/, "");
       const isAuthPath = _ParallClient.AUTH_PATHS.has(pathSuffix);
       if (!retried && !isAuthPath && this.getRefreshToken) {
         const refreshed = await this.tryRefresh();
         if (refreshed) {
-          return this.multipartRequest(method, path4, body, true);
+          return this.multipartRequest(method, path5, body, true);
         }
       }
       if (this.onTokenExpired && !isAuthPath) {
@@ -740,9 +752,6 @@ var ParallClient = class _ParallClient {
   async deleteMessage(id) {
     return this.request("DELETE", ENDPOINTS.MESSAGE(id));
   }
-  async patchMessage(id, req) {
-    return this.request("POST", ENDPOINTS.MESSAGE_PATCHES(id), req);
-  }
   async getMessageReplies(id, params) {
     return this.request("GET", ENDPOINTS.MESSAGE_REPLIES(id), void 0, params);
   }
@@ -835,8 +844,7 @@ var ParallClient = class _ParallClient {
    * @param params.status - Comma-separated status filter (e.g., `'open'`).
    */
   async getAgentSessions(orgId, agentId, params) {
-    const res = await this.request("GET", ENDPOINTS.AGENT_SESSIONS(orgId, agentId), void 0, params);
-    return res.data;
+    return this.request("GET", ENDPOINTS.AGENT_SESSIONS(orgId, agentId), void 0, params);
   }
   async getAgentSession(orgId, agentId, sessionId) {
     return this.request("GET", ENDPOINTS.AGENT_SESSION(orgId, agentId, sessionId));
@@ -848,12 +856,14 @@ var ParallClient = class _ParallClient {
     return this.request("POST", ENDPOINTS.AGENT_SESSION_STEPS(orgId, agentId, sessionId), req);
   }
   async getAgentSessionSteps(orgId, agentId, sessionId, params) {
-    const res = await this.request("GET", ENDPOINTS.AGENT_SESSION_STEPS(orgId, agentId, sessionId), void 0, params);
-    return res.data;
+    return this.request("GET", ENDPOINTS.AGENT_SESSION_STEPS(orgId, agentId, sessionId), void 0, params);
   }
   async getAgentSessionStep(orgId, agentId, sessionId, stepId) {
     return this.request("GET", ENDPOINTS.AGENT_SESSION_STEP(orgId, agentId, sessionId, stepId));
   }
+  async getAgentStepById(orgId, stepId) {
+    return this.request("GET", ENDPOINTS.AGENT_STEP_BY_ID(orgId, stepId));
+  }
   // ---- Agent runtime auth (hosted Claude OAuth) ----
   async getAgentRuntimeAuth(orgId, agentId) {
     return this.request("GET", ENDPOINTS.AGENT_RUNTIME_AUTH(orgId, agentId));
@@ -950,10 +960,22 @@ var ParallClient = class _ParallClient {
   async detachAgent(orgId, machineId, agentId) {
     return this.request("DELETE", ENDPOINTS.MACHINE_DETACH_AGENT(orgId, machineId, agentId));
   }
+  async patchMachineLLMSource(orgId, machineId, llmSource2) {
+    return this.request("PATCH", ENDPOINTS.MACHINE_LLM_SOURCE(orgId, machineId), { llm_source: llmSource2 });
+  }
   /** Get machine-level runtime auth state. */
   async getMachineRuntimeAuth(orgId, machineId) {
     return this.request("GET", ENDPOINTS.MACHINE_RUNTIME_AUTH(orgId, machineId));
   }
+  async startMachineRuntimeAuthSession(orgId, machineId, req = {}) {
+    return this.request("POST", ENDPOINTS.MACHINE_RUNTIME_AUTH_SESSIONS(orgId, machineId), req);
+  }
+  async completeMachineRuntimeAuthSession(orgId, machineId, sessionId, req) {
+    return this.request("POST", ENDPOINTS.MACHINE_RUNTIME_AUTH_SESSION_COMPLETE(orgId, machineId, sessionId), req);
+  }
+  async disconnectMachineRuntimeAuth(orgId, machineId) {
+    return this.request("DELETE", ENDPOINTS.MACHINE_RUNTIME_AUTH(orgId, machineId));
+  }
   // ---- Machine self-control-plane (mck_-scoped) ----
   //
   // The four methods below are intended to be called from a daemon-mode
@@ -1334,8 +1356,8 @@ var ParallClient = class _ParallClient {
   async deleteWikiPathScope(orgId, wikiId, scopeId) {
     await this.request("DELETE", ENDPOINTS.WIKI_PATH_SCOPE(orgId, wikiId, scopeId));
   }
-  async getWikiAccessStatus(orgId, wikiId, path4) {
-    return this.request("GET", ENDPOINTS.WIKI_ACCESS_STATUS(orgId, wikiId), void 0, path4 ? { path: path4 } : void 0);
+  async getWikiAccessStatus(orgId, wikiId, path5) {
+    return this.request("GET", ENDPOINTS.WIKI_ACCESS_STATUS(orgId, wikiId), void 0, path5 ? { path: path5 } : void 0);
   }
   async createWikiAccessRequest(orgId, wikiId, data) {
     await this.request("POST", ENDPOINTS.WIKI_ACCESS_REQUESTS(orgId, wikiId), data);
@@ -1344,11 +1366,11 @@ var ParallClient = class _ParallClient {
   async getWikiCommits(orgId, wikiId, params) {
     return this.request("GET", ENDPOINTS.WIKI_COMMITS(orgId, wikiId), void 0, params);
   }
-  async getWikiFileCommits(orgId, wikiId, path4, params) {
-    return this.request("GET", ENDPOINTS.WIKI_FILE_COMMITS(orgId, wikiId), void 0, { path: path4, ...params });
+  async getWikiFileCommits(orgId, wikiId, path5, params) {
+    return this.request("GET", ENDPOINTS.WIKI_FILE_COMMITS(orgId, wikiId), void 0, { path: path5, ...params });
   }
-  async getWikiBlame(orgId, wikiId, path4, ref) {
-    return this.request("GET", ENDPOINTS.WIKI_BLAME(orgId, wikiId), void 0, { path: path4, ref });
+  async getWikiBlame(orgId, wikiId, path5, ref) {
+    return this.request("GET", ENDPOINTS.WIKI_BLAME(orgId, wikiId), void 0, { path: path5, ref });
   }
   // ---- Wiki Operations (audit log) ----
   async getWikiOperations(orgId, wikiId, params) {
@@ -1917,13 +1939,31 @@ function resolveWsUrl(apiUrl, explicitWsUrl) {
 // ts/daemon/dist/supervisor.js
 import { spawn } from "node:child_process";
 import * as fs2 from "node:fs";
-import * as path2 from "node:path";
+import * as path3 from "node:path";
 
 // ts/daemon/dist/runtimes.js
+import * as path2 from "node:path";
+function llmSource(pc) {
+  if (pc?.llm_source)
+    return pc.llm_source;
+  if (pc?.openai_api_key || pc?.openai_base_url || pc?.anthropic_auth_token || pc?.anthropic_base_url) {
+    return "custom";
+  }
+  return "parall";
+}
+function clearAllProviderCreds(env) {
+  delete env.ANTHROPIC_AUTH_TOKEN;
+  delete env.ANTHROPIC_BASE_URL;
+  delete env.ANTHROPIC_API_KEY;
+  delete env.OPENAI_API_KEY;
+  delete env.OPENAI_BASE_URL;
+  delete env.PRLL_CLAUDE_ALLOW_API_KEY;
+}
 var claudeCodeAdapter = {
   bin: "parall-claude-agent",
-  buildEnv(baseEnv, agentId, orgId, apiKey, dirs) {
+  buildEnv(baseEnv, agentId, orgId, apiKey, dirs, pc) {
     const env = { ...baseEnv };
+    clearAllProviderCreds(env);
     env.PRLL_API_KEY = apiKey;
     env.PRLL_ORG_ID = orgId;
     env.AGENT_ID = agentId;
@@ -1931,8 +1971,18 @@ var claudeCodeAdapter = {
     env.PRLL_CLAUDE_HOME = dirs.claudeHome;
     env.PRLL_CLAUDE_STATE_DIR = dirs.stateDir;
     env.PRLL_CLAUDE_WORKSPACE_DIR = dirs.workspaceDir;
-    if ("ANTHROPIC_AUTH_TOKEN" in env) {
+    const source = llmSource(pc);
+    if (source === "parall") {
       env.ANTHROPIC_AUTH_TOKEN = apiKey;
+      env.ANTHROPIC_BASE_URL = `${baseEnv.PRLL_API_URL}/api/llm`;
+      env.PRLL_CLAUDE_ALLOW_API_KEY = "1";
+    } else if (source === "custom") {
+      if (pc?.anthropic_auth_token) {
+        env.ANTHROPIC_AUTH_TOKEN = pc.anthropic_auth_token;
+        env.PRLL_CLAUDE_ALLOW_API_KEY = "1";
+      }
+      if (pc?.anthropic_base_url)
+        env.ANTHROPIC_BASE_URL = pc.anthropic_base_url;
     }
     delete env.PRLL_DAEMON_MODE;
     return env;
@@ -1940,14 +1990,26 @@ var claudeCodeAdapter = {
 };
 var codexAdapter = {
   bin: "parall-codex-agent",
-  buildEnv(baseEnv, agentId, orgId, apiKey, dirs) {
+  buildEnv(baseEnv, agentId, orgId, apiKey, dirs, pc) {
     const env = { ...baseEnv };
+    clearAllProviderCreds(env);
     env.PRLL_API_KEY = apiKey;
     env.PRLL_ORG_ID = orgId;
     env.AGENT_ID = agentId;
     env.PRLL_AGENT_ID = agentId;
     env.PRLL_CODEX_STATE_DIR = dirs.stateDir;
     env.PRLL_CODEX_WORKSPACE_DIR = dirs.workspaceDir;
+    env.PRLL_CODEX_HOME = path2.join(dirs.stateDir, ".codex");
+    const source = llmSource(pc);
+    if (source === "parall") {
+      env.OPENAI_API_KEY = apiKey;
+      env.OPENAI_BASE_URL = `${baseEnv.PRLL_API_URL}/api/llm/v1`;
+    } else if (source === "custom") {
+      if (pc?.openai_api_key)
+        env.OPENAI_API_KEY = pc.openai_api_key;
+      if (pc?.openai_base_url)
+        env.OPENAI_BASE_URL = pc.openai_base_url;
+    }
     delete env.PRLL_DAEMON_MODE;
     return env;
   }
@@ -1970,6 +2032,7 @@ var openclawAdapter = {
   bin: "parall-openclaw-agent",
   buildEnv(baseEnv, agentId, orgId, apiKey, dirs) {
     const env = { ...baseEnv };
+    clearAllProviderCreds(env);
     env.PRLL_API_KEY = apiKey;
     env.PRLL_ORG_ID = orgId;
     env.AGENT_ID = agentId;
@@ -2024,11 +2087,12 @@ var DaemonSupervisor = class {
   ws = null;
   running = false;
   machineOrgId = null;
+  machineLlmSource = "parall";
   stopResolve = null;
-  constructor(config, client, log) {
+  constructor(config, client, log2) {
     this.config = config;
     this.client = client;
-    this.log = log;
+    this.log = log2;
   }
   /** Start the supervisor. Returns a promise that resolves on `stop()`. */
   async run(signal) {
@@ -2059,7 +2123,10 @@ var DaemonSupervisor = class {
     });
     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`);
@@ -2069,6 +2136,14 @@ var DaemonSupervisor = class {
       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} \u2192 ${newSource}, respawning all agents`);
+        this.machineLlmSource = newSource;
+        void this.respawnAllChildren();
+      }
+    });
     this.ws.on("machine.stop", (data) => {
       this.log.info(`WS: machine.stop received (reason=${data.reason ?? "none"})`);
       void this.stop();
@@ -2117,6 +2192,7 @@ var DaemonSupervisor = class {
       try {
         const machine = await this.client.getMachineSelf();
         this.machineOrgId = machine.org_id;
+        this.machineLlmSource = machine.llm_source ?? "parall";
         this.log.info(`daemon online \u2014 machine_id=${machine.id} org=${machine.org_id} label=${machine.label}`);
         return true;
       } catch (err) {
@@ -2194,12 +2270,12 @@ var DaemonSupervisor = class {
    */
   migrateFlatLayout() {
     const root = this.config.rootStateDir;
-    const agentsDir = path2.join(root, "agents");
-    const flatWorkspace = path2.join(root, "workspace");
+    const agentsDir = path3.join(root, "agents");
+    const flatWorkspace = path3.join(root, "workspace");
     if (!fs2.existsSync(flatWorkspace) || fs2.existsSync(agentsDir))
       return;
     let ownerAgentId;
-    const sessionsDir = path2.join(root, "sessions");
+    const sessionsDir = path3.join(root, "sessions");
     if (fs2.existsSync(sessionsDir)) {
       try {
         for (const file of fs2.readdirSync(sessionsDir)) {
@@ -2216,13 +2292,13 @@ var DaemonSupervisor = class {
       }
     }
     const targetId = ownerAgentId ?? "_orphan";
-    const targetDir = path2.join(agentsDir, targetId);
+    const targetDir = path3.join(agentsDir, targetId);
     try {
       fs2.mkdirSync(targetDir, { recursive: true });
       for (const sub of ["workspace", "sessions", "dispatch-context"]) {
-        const src = path2.join(root, sub);
+        const src = path3.join(root, sub);
         if (fs2.existsSync(src)) {
-          fs2.renameSync(src, path2.join(targetDir, sub));
+          fs2.renameSync(src, path3.join(targetDir, sub));
         }
       }
       this.log.info(`migrated legacy flat state \u2192 agents/${targetId}/`);
@@ -2271,6 +2347,30 @@ var DaemonSupervisor = class {
     this.children.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} \u2192 ${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;
@@ -2315,6 +2415,7 @@ var DaemonSupervisor = class {
       runtimeType,
       workspacePath: workspaceDir,
       claudeHome,
+      providerConfig: attached.provider_config ?? { llm_source: this.machineLlmSource },
       child: null,
       credential,
       restartAttempts: 0,
@@ -2338,7 +2439,7 @@ var DaemonSupervisor = class {
       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,
@@ -2409,16 +2510,16 @@ var DaemonSupervisor = class {
     });
   }
   ensureSharedCredentialLink(agentClaudeHome, agentId) {
-    const sharedCredentials = path2.resolve(sharedClaudeCredentialsFileFor(this.config.rootClaudeHome));
+    const sharedCredentials = path3.resolve(sharedClaudeCredentialsFileFor(this.config.rootClaudeHome));
     const agentCredentials = agentClaudeCredentialsFileFor(agentClaudeHome);
-    const agentCredentialsDir = path2.dirname(agentCredentials);
-    fs2.mkdirSync(path2.dirname(sharedCredentials), { recursive: true });
+    const agentCredentialsDir = path3.dirname(agentCredentials);
+    fs2.mkdirSync(path3.dirname(sharedCredentials), { recursive: true });
     fs2.mkdirSync(agentCredentialsDir, { recursive: true });
     try {
       const existing = fs2.lstatSync(agentCredentials);
       if (existing.isSymbolicLink()) {
         const currentTarget = fs2.readlinkSync(agentCredentials);
-        if (path2.resolve(agentCredentialsDir, currentTarget) === sharedCredentials) {
+        if (path3.resolve(agentCredentialsDir, currentTarget) === sharedCredentials) {
           return;
         }
         fs2.unlinkSync(agentCredentials);
@@ -2439,7 +2540,7 @@ var DaemonSupervisor = class {
 
 // ts/daemon/dist/cli.js
 import * as fs3 from "node:fs";
-import * as path3 from "node:path";
+import * as path4 from "node:path";
 import * as os2 from "node:os";
 import * as readline from "node:readline";
 import { spawn as spawn2, execSync } from "node:child_process";
@@ -2474,10 +2575,10 @@ function isLinux() {
 }
 var PLIST_LABEL = "com.parall.daemon";
 function plistPath() {
-  return path3.join(os2.homedir(), "Library", "LaunchAgents", `${PLIST_LABEL}.plist`);
+  return path4.join(os2.homedir(), "Library", "LaunchAgents", `${PLIST_LABEL}.plist`);
 }
 function systemdUnitPath() {
-  return path3.join(os2.homedir(), ".config", "systemd", "user", "parall-daemon.service");
+  return path4.join(os2.homedir(), ".config", "systemd", "user", "parall-daemon.service");
 }
 function getDaemonBin() {
   try {
@@ -2487,7 +2588,7 @@ function getDaemonBin() {
   }
 }
 function generatePlist(daemonBin) {
-  const logPath = path3.join(os2.homedir(), "Library", "Logs", "parall-daemon.log");
+  const logPath = path4.join(os2.homedir(), "Library", "Logs", "parall-daemon.log");
   return `<?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
 <plist version="1.0">
@@ -2534,14 +2635,14 @@ function installService() {
   }
   const bin = getDaemonBin();
   if (isMacOS()) {
-    const dir = path3.dirname(plistPath());
+    const dir = path4.dirname(plistPath());
     fs3.mkdirSync(dir, { recursive: true });
     fs3.writeFileSync(plistPath(), generatePlist(bin));
     execSync(`launchctl bootout gui/$(id -u) ${plistPath()} 2>/dev/null || true`);
     execSync(`launchctl bootstrap gui/$(id -u) ${plistPath()}`);
     console.log(`launchd agent installed: ${plistPath()}`);
   } else if (isLinux()) {
-    const dir = path3.dirname(systemdUnitPath());
+    const dir = path4.dirname(systemdUnitPath());
     fs3.mkdirSync(dir, { recursive: true });
     fs3.writeFileSync(systemdUnitPath(), generateSystemdUnit(bin));
     execSync("systemctl --user daemon-reload");
@@ -2610,7 +2711,7 @@ function cmdLogs(lines) {
     child2.on("exit", (code) => process.exit(code ?? 0));
     return;
   }
-  const logPath = path3.join(os2.homedir(), "Library", "Logs", "parall-daemon.log");
+  const logPath = path4.join(os2.homedir(), "Library", "Logs", "parall-daemon.log");
   if (!fs3.existsSync(logPath)) {
     console.log("No log file found at", logPath);
     return;
@@ -2704,41 +2805,35 @@ async function runCLI(args) {
 }
 
 // ts/daemon/dist/index.js
-function createLogger(prefix) {
-  return {
-    info: (msg) => console.log(`[${prefix}] ${msg}`),
-    warn: (msg) => console.warn(`[${prefix}] ${msg}`),
-    error: (msg) => console.error(`[${prefix}] ${msg}`)
-  };
-}
+var log = createLogger("daemon");
 function formatError(reason) {
   if (reason instanceof Error) {
     return reason.stack ?? reason.message;
   }
   return String(reason);
 }
-async function runForever(config, client, log, signal) {
+async function runForever(config, client, log2, signal) {
   let attempt = 0;
   while (!signal.aborted) {
-    const supervisor = new DaemonSupervisor(config, client, log);
+    const supervisor = new DaemonSupervisor(config, client, log2);
     try {
       await supervisor.run(signal);
       await supervisor.stop();
       return;
     } catch (err) {
-      log.error(`supervisor crashed: ${String(err)}`);
+      log2.error(`supervisor crashed: ${String(err)}`);
       try {
         await supervisor.stop();
       } catch (stopErr) {
-        log.warn(`supervisor.stop() after crash threw: ${String(stopErr)}`);
+        log2.warn(`supervisor.stop() after crash threw: ${String(stopErr)}`);
       }
       if (config.supervisorRestartBackoffMs === 0) {
-        log.error("supervisor keepalive disabled (PRLL_DAEMON_SUPERVISOR_RESTART_BACKOFF_MS=0) \u2014 exiting");
+        log2.error("supervisor keepalive disabled (PRLL_DAEMON_SUPERVISOR_RESTART_BACKOFF_MS=0) \u2014 exiting");
         throw err;
       }
       const delay = Math.min(config.supervisorRestartBackoffMs * Math.pow(2, attempt), config.supervisorRestartBackoffMaxMs);
       attempt += 1;
-      log.warn(`restarting supervisor in ${delay}ms (attempt ${attempt})`);
+      log2.warn(`restarting supervisor in ${delay}ms (attempt ${attempt})`);
       const slept = await sleepCancellable(delay, signal);
       if (!slept)
         return;
@@ -2747,7 +2842,6 @@ async function runForever(config, client, log, signal) {
 }
 async function main() {
   const config = resolveClaudeDaemonConfig(process.env);
-  const log = createLogger("daemon");
   log.info(`boot: api=${config.apiUrl} pollMs=${config.pollIntervalMs} heartbeatMs=${config.heartbeatIntervalMs} agentBin=${config.agentBin}`);
   log.info(`keepalive: bootstrapBackoffMs=${config.bootstrapBackoffMs} supervisorRestartBackoffMs=${config.supervisorRestartBackoffMs}`);
   const client = new ParallClient({
@@ -2777,10 +2871,10 @@ runCLI(cliArgs).then((result) => {
   if (result === "handled")
     return;
   main().catch((err) => {
-    console.error(`[daemon] fatal: ${formatError(err)}`);
+    log.error(`fatal: ${formatError(err)}`);
     process.exitCode = 1;
   });
 }).catch((err) => {
-  console.error(`[daemon] fatal: ${formatError(err)}`);
+  log.error(`fatal: ${formatError(err)}`);
   process.exitCode = 1;
 });

package/bundle/parall-openclaw-agent.js

@@ -4,6 +4,22 @@
 import { execFileSync, spawn } from "node:child_process";
 import * as fs from "node:fs";
 import * as path from "node:path";
+function ts() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+var log = {
+  info: (msg) => console.log(`${ts()} [openclaw-agent] ${msg}`),
+  warn: (msg) => console.warn(`${ts()} [openclaw-agent] ${msg}`),
+  error: (msg) => console.error(`${ts()} [openclaw-agent] ${msg}`)
+};
+function env(name) {
+  const v = process.env[name]?.trim();
+  if (!v) {
+    log.error(`Missing required environment variable: ${name}`);
+    process.exit(1);
+  }
+  return v;
+}
 var PRLL_API_URL = env("PRLL_API_URL");
 var PRLL_API_KEY = env("PRLL_API_KEY");
 var PRLL_ORG_ID = env("PRLL_ORG_ID");
@@ -12,14 +28,6 @@ var PRLL_WS_URL = process.env.PRLL_WS_URL?.trim() || "";
 var PRLL_SWIMLANE_NAME = process.env.PRLL_SWIMLANE_NAME?.trim() || "";
 var gatewayPort = process.env.OPENCLAW_GATEWAY_PORT?.trim() || "0";
 var pluginArchive = process.env.PRLL_OPENCLAW_PLUGIN_ARCHIVE?.trim() || "/opt/parall-plugin/parall-plugin.tgz";
-function env(name) {
-  const v = process.env[name]?.trim();
-  if (!v) {
-    console.error(`ERROR: Missing required environment variable: ${name}`);
-    process.exit(1);
-  }
-  return v;
-}
 var openclawStateDir = path.join(stateDir, ".openclaw");
 var configPath = path.join(openclawStateDir, "openclaw.json");
 fs.mkdirSync(path.join(openclawStateDir, "sessions"), { recursive: true });
@@ -27,7 +35,7 @@ fs.mkdirSync(path.join(openclawStateDir, "workspace"), { recursive: true });
 if (fs.existsSync(pluginArchive)) {
   const legacyExtDir = path.join(openclawStateDir, "extensions", "parall");
   fs.rmSync(legacyExtDir, { recursive: true, force: true });
-  console.log(`Installing Parall plugin from ${pluginArchive}...`);
+  log.info(`Installing Parall plugin from ${pluginArchive}...`);
   try {
     execFileSync("openclaw", [
       "plugins",
@@ -41,11 +49,11 @@ if (fs.existsSync(pluginArchive)) {
       timeout: 6e4
     });
   } catch (err) {
-    console.error(`ERROR: Failed to install Parall plugin: ${String(err)}`);
+    log.error(`Failed to install Parall plugin: ${String(err)}`);
     process.exit(1);
   }
 } else {
-  console.warn(`Plugin archive not found at ${pluginArchive} \u2014 assuming plugin is already installed.`);
+  log.warn(`Plugin archive not found at ${pluginArchive} \u2014 assuming plugin is already installed.`);
 }
 writeOpenclawConfig();
 function writeOpenclawConfig() {
@@ -165,9 +173,9 @@ async function preseedPlatformConfig() {
     fs.writeFileSync(tmp, JSON.stringify(cfg, null, 2));
     fs.renameSync(tmp, configPath);
     const model = cfg.agents?.defaults?.model ?? "none";
-    console.log(`Platform config pre-seeded (model: ${String(model)}).`);
+    log.info(`Platform config pre-seeded (model: ${String(model)}).`);
   } catch (err) {
-    console.warn(`Platform config pre-seed skipped: ${String(err)}`);
+    log.warn(`Platform config pre-seed skipped: ${String(err)}`);
   }
 }
 try {
@@ -178,7 +186,7 @@ try {
   });
 } catch {
 }
-console.log("Starting OpenClaw gateway...");
+log.info("Starting OpenClaw gateway...");
 var workspaceDir = process.env.PRLL_OPENCLAW_WORKSPACE_DIR?.trim() || "";
 var gatewayEnv = {
   ...process.env,