@parall/daemon 1.30.0 → 1.32.0

package/dist/workspace.js

@@ -1,8 +1,8 @@
-import { spawn } from "node:child_process";
-import { createHash } from "node:crypto";
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { clearAllProviderCreds } from "./runtimes.js";
+import { spawn } from 'node:child_process';
+import { createHash } from 'node:crypto';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { clearAllProviderCreds } from './runtimes.js';
 const OUTPUT_TAIL_LIMIT = 32 * 1024;
 const DEFAULT_SETUP_TIMEOUT_SEC = 600;
 export async function prepareWorkspace(opts) {
@@ -13,7 +13,7 @@ export async function prepareWorkspace(opts) {
         return plan.workspaceDir;
     }
     let forceSetup = false;
-    if (prior?.status === "ready" && prior.config_hash === plan.configHash) {
+    if (prior?.status === 'ready' && prior.config_hash === plan.configHash) {
         if (await verifyExistingWorkspace(plan, opts.log)) {
             return plan.workspaceDir;
         }
@@ -21,9 +21,9 @@ export async function prepareWorkspace(opts) {
     }
     await opts.client.reportAgentWorkspaceState(opts.agentId, {
         config_hash: plan.configHash,
-        status: "preparing",
+        status: 'preparing',
     });
-    let outputTail = "";
+    let outputTail = '';
     try {
         await ensureWorkspace(plan, opts.log);
         if (shouldRunSetup(plan.workspace.setup, prior, plan.configHash, forceSetup)) {
@@ -31,19 +31,21 @@ export async function prepareWorkspace(opts) {
         }
         await opts.client.reportAgentWorkspaceState(opts.agentId, {
             config_hash: plan.configHash,
-            status: "ready",
+            status: 'ready',
             output_tail: outputTail || null,
         });
         return plan.workspaceDir;
     }
     catch (err) {
         const message = err instanceof Error ? err.message : String(err);
-        await opts.client.reportAgentWorkspaceState(opts.agentId, {
+        await opts.client
+            .reportAgentWorkspaceState(opts.agentId, {
             config_hash: plan.configHash,
-            status: "failed",
+            status: 'failed',
             last_error: message,
             output_tail: outputTail || null,
-        }).catch((reportErr) => {
+        })
+            .catch((reportErr) => {
             opts.log.warn(`workspace state report failed after setup error: ${String(reportErr)}`);
         });
         throw err;
@@ -56,19 +58,17 @@ function buildWorkspacePlan(input, defaultWorkspaceDir, serverConfigHash) {
     // The server is the source of truth for config_hash. Go and TypeScript JSON
     // normalization can differ in harmless ways (field order, omitted defaults),
     // so use the server-computed pending/ready row hash whenever it is present.
-    const configHash = serverConfigHash || createHash("sha256")
-        .update(JSON.stringify(config))
-        .digest("hex");
+    const configHash = serverConfigHash || createHash('sha256').update(JSON.stringify(config)).digest('hex');
     return { config, workspace, workspaceDir, defaultWorkspaceDir, customWorkspaceField, configHash };
 }
 function normalizeConfig(input, defaultWorkspaceDir) {
     const cfg = input ? JSON.parse(JSON.stringify(input)) : {};
     cfg.workspace_path = cfg.workspace_path?.trim() || undefined;
     if (!cfg.workspace && cfg.workspace_path) {
-        cfg.workspace = { mode: "local_path", path: cfg.workspace_path };
+        cfg.workspace = { mode: 'local_path', path: cfg.workspace_path };
     }
     if (!cfg.workspace) {
-        cfg.workspace = { mode: "default" };
+        cfg.workspace = { mode: 'default' };
     }
     const ws = cfg.workspace;
     ws.mode = (ws.mode?.trim() || undefined);
@@ -78,26 +78,26 @@ function normalizeConfig(input, defaultWorkspaceDir) {
         ws.git.ref = ws.git.ref?.trim() || undefined;
         ws.git.target_path = ws.git.target_path?.trim() || undefined;
     }
-    ws.mode ||= ws.git ? "git" : ws.path ? "local_path" : "default";
-    if (ws.mode === "local_path" && !ws.path) {
-        ws.mode = "default";
+    ws.mode ||= ws.git ? 'git' : ws.path ? 'local_path' : 'default';
+    if (ws.mode === 'local_path' && !ws.path) {
+        ws.mode = 'default';
     }
-    if (ws.mode === "git") {
+    if (ws.mode === 'git') {
         ws.git ||= {};
         if (!ws.git.target_path && ws.path) {
             ws.git.target_path = ws.path;
         }
     }
-    if (ws.mode === "default") {
+    if (ws.mode === 'default') {
         ws.path = undefined;
         ws.git = undefined;
     }
-    if (ws.mode === "local_path") {
+    if (ws.mode === 'local_path') {
         ws.git = undefined;
     }
     if (ws.setup) {
         ws.setup.command = ws.setup.command?.trim();
-        ws.setup.run_on ||= "first_attach";
+        ws.setup.run_on ||= 'first_attach';
         if (!ws.setup.command) {
             ws.setup = undefined;
         }
@@ -108,19 +108,19 @@ function normalizeConfig(input, defaultWorkspaceDir) {
     return cfg;
 }
 function resolveWorkspaceDir(workspace, defaultWorkspaceDir) {
-    if (workspace.mode === "local_path") {
+    if (workspace.mode === 'local_path') {
         if (!workspace.path)
             return { workspaceDir: defaultWorkspaceDir };
         return {
-            workspaceDir: requireAbsolute(workspace.path, "workspace.path"),
-            customWorkspaceField: "workspace.path",
+            workspaceDir: requireAbsolute(workspace.path, 'workspace.path'),
+            customWorkspaceField: 'workspace.path',
         };
     }
-    if (workspace.mode === "git") {
+    if (workspace.mode === 'git') {
         return workspace.git?.target_path
             ? {
-                workspaceDir: requireAbsolute(workspace.git.target_path, "workspace.git.target_path"),
-                customWorkspaceField: "workspace.git.target_path",
+                workspaceDir: requireAbsolute(workspace.git.target_path, 'workspace.git.target_path'),
+                customWorkspaceField: 'workspace.git.target_path',
             }
             : { workspaceDir: defaultWorkspaceDir };
     }
@@ -128,19 +128,19 @@ function resolveWorkspaceDir(workspace, defaultWorkspaceDir) {
 }
 async function ensureWorkspace(plan, log) {
     const ws = plan.workspace;
-    if (ws.mode === "default") {
+    if (ws.mode === 'default') {
         fs.mkdirSync(plan.workspaceDir, { recursive: true });
         assertWritableWorkspaceDir(plan.workspaceDir);
         return;
     }
-    if (ws.mode === "local_path") {
+    if (ws.mode === 'local_path') {
         assertSafeCustomWorkspacePath(plan);
         let st;
         try {
             st = fs.statSync(plan.workspaceDir);
         }
         catch (err) {
-            if (isNodeError(err) && err.code === "ENOENT") {
+            if (isNodeError(err) && err.code === 'ENOENT') {
                 throw new Error(`workspace path does not exist: ${plan.workspaceDir}`);
             }
             throw err;
@@ -152,17 +152,17 @@ async function ensureWorkspace(plan, log) {
         assertWritableWorkspaceDir(plan.workspaceDir);
         return;
     }
-    if (ws.mode === "git") {
+    if (ws.mode === 'git') {
         const remote = ws.git?.remote?.trim();
         if (!remote)
-            throw new Error("workspace git remote is required");
+            throw new Error('workspace git remote is required');
         if (plan.customWorkspaceField) {
             assertSafeCustomWorkspacePath(plan);
         }
         if (!fs.existsSync(plan.workspaceDir)) {
             fs.mkdirSync(path.dirname(plan.workspaceDir), { recursive: true });
             assertWritableWorkspaceDir(path.dirname(plan.workspaceDir));
-            await runCommand("git", ["clone", remote, plan.workspaceDir], process.cwd());
+            await runCommand('git', ['clone', remote, plan.workspaceDir], process.cwd());
         }
         else {
             const st = fs.statSync(plan.workspaceDir);
@@ -177,17 +177,17 @@ async function ensureWorkspace(plan, log) {
             await ensureGitRemote(plan.workspaceDir, remote);
         }
         if (ws.git?.ref) {
-            const dirty = await commandOutput("git", ["status", "--porcelain"], plan.workspaceDir);
+            const dirty = await commandOutput('git', ['status', '--porcelain'], plan.workspaceDir);
             if (dirty.trim()) {
                 throw new Error(`workspace git tree has local changes; refusing checkout: ${plan.workspaceDir}`);
             }
-            await runCommand("git", ["fetch", "origin", "--prune"], plan.workspaceDir);
+            await runCommand('git', ['fetch', 'origin', '--prune'], plan.workspaceDir);
             await checkoutGitRef(plan.workspaceDir, ws.git.ref);
         }
         log.info(`workspace ready: git ${remote} -> ${plan.workspaceDir}`);
         return;
     }
-    throw new Error(`unsupported workspace mode: ${ws.mode ?? "(empty)"}`);
+    throw new Error(`unsupported workspace mode: ${ws.mode ?? '(empty)'}`);
 }
 async function verifyExistingWorkspace(plan, log) {
     try {
@@ -203,14 +203,14 @@ async function verifyExistingWorkspace(plan, log) {
             assertSafeCustomWorkspacePath(plan, fs.realpathSync(plan.workspaceDir));
         }
         assertWritableWorkspaceDir(plan.workspaceDir);
-        if (plan.workspace.mode === "git") {
+        if (plan.workspace.mode === 'git') {
             await ensureGitWorktree(plan.workspaceDir);
             const remote = plan.workspace.git?.remote?.trim();
             if (remote) {
                 await ensureGitRemote(plan.workspaceDir, remote);
             }
             if (plan.workspace.git?.ref) {
-                const head = (await commandOutput("git", ["rev-parse", "HEAD"], plan.workspaceDir)).trim();
+                const head = (await commandOutput('git', ['rev-parse', 'HEAD'], plan.workspaceDir)).trim();
                 const expected = await resolveConfiguredGitRef(plan.workspaceDir, plan.workspace.git.ref);
                 if (head !== expected) {
                     log.warn(`workspace ready state ignored: git HEAD ${head} does not match ${plan.workspace.git.ref} (${expected})`);
@@ -226,13 +226,13 @@ async function verifyExistingWorkspace(plan, log) {
     }
 }
 async function ensureGitWorktree(cwd) {
-    const result = await commandOutput("git", ["rev-parse", "--is-inside-work-tree"], cwd);
-    if (result.trim() !== "true") {
+    const result = await commandOutput('git', ['rev-parse', '--is-inside-work-tree'], cwd);
+    if (result.trim() !== 'true') {
         throw new Error(`workspace path exists but is not a git worktree: ${cwd}`);
     }
 }
 async function ensureGitRemote(cwd, expectedRemote) {
-    const actualRemote = (await commandOutput("git", ["remote", "get-url", "origin"], cwd)).trim();
+    const actualRemote = (await commandOutput('git', ['remote', 'get-url', 'origin'], cwd)).trim();
     if (actualRemote !== expectedRemote) {
         throw new Error(`workspace git remote mismatch: expected ${expectedRemote}, got ${actualRemote}`);
     }
@@ -240,23 +240,23 @@ async function ensureGitRemote(cwd, expectedRemote) {
 async function checkoutGitRef(cwd, ref) {
     const remoteCommit = await resolveRemoteGitRef(cwd, ref);
     if (remoteCommit) {
-        await runCommand("git", ["checkout", "-B", ref, remoteCommit], cwd);
+        await runCommand('git', ['checkout', '-B', ref, remoteCommit], cwd);
         return;
     }
     const targetCommit = await resolveGitCommit(cwd, ref);
-    await runCommand("git", ["checkout", "--detach", targetCommit], cwd);
+    await runCommand('git', ['checkout', '--detach', targetCommit], cwd);
 }
 async function resolveConfiguredGitRef(cwd, ref) {
     const remote = await resolveRemoteGitRef(cwd, ref);
-    return remote || await resolveGitCommit(cwd, ref);
+    return remote || (await resolveGitCommit(cwd, ref));
 }
 async function resolveRemoteGitRef(cwd, ref) {
-    return (await tryGitOutput("git", ["rev-parse", "--verify", `refs/remotes/origin/${ref}^{commit}`], cwd)).trim();
+    return (await tryGitOutput('git', ['rev-parse', '--verify', `refs/remotes/origin/${ref}^{commit}`], cwd)).trim();
 }
 async function resolveGitCommit(cwd, ref) {
     const candidates = [`refs/tags/${ref}^{commit}`, `${ref}^{commit}`];
     for (const candidate of candidates) {
-        const commit = await tryGitOutput("git", ["rev-parse", "--verify", candidate], cwd);
+        const commit = await tryGitOutput('git', ['rev-parse', '--verify', candidate], cwd);
         if (commit.trim()) {
             return commit.trim();
         }
@@ -268,14 +268,14 @@ function shouldRunSetup(setup, prior, configHash, forceSetup = false) {
         return false;
     if (forceSetup)
         return true;
-    if (setup.run_on === "config_change") {
-        return prior?.config_hash !== configHash || prior.status === "pending" || prior.status === "failed";
+    if (setup.run_on === 'config_change') {
+        return (prior?.config_hash !== configHash || prior.status === 'pending' || prior.status === 'failed');
     }
-    return prior?.status !== "ready" || !prior.prepared_at;
+    return prior?.status !== 'ready' || !prior.prepared_at;
 }
 async function runSetup(cwd, command, timeoutSec) {
     const effectiveTimeoutSec = timeoutSec && timeoutSec > 0 ? timeoutSec : DEFAULT_SETUP_TIMEOUT_SEC;
-    return runCommand(process.env.SHELL || "/bin/sh", ["-lc", command], cwd, effectiveTimeoutSec * 1000, scrubSetupEnv());
+    return runCommand(process.env.SHELL || '/bin/sh', ['-lc', command], cwd, effectiveTimeoutSec * 1000, scrubSetupEnv());
 }
 function scrubSetupEnv() {
     const env = { ...process.env };
@@ -291,12 +291,12 @@ async function tryGitOutput(cmd, args, cwd) {
         return await runCommand(cmd, args, cwd);
     }
     catch {
-        return "";
+        return '';
     }
 }
 function runCommand(cmd, args, cwd, timeoutMs = 120_000, env = process.env) {
     return new Promise((resolve, reject) => {
-        let tail = "";
+        let tail = '';
         let timedOut = false;
         let settled = false;
         let timeoutTimer = null;
@@ -317,29 +317,29 @@ function runCommand(cmd, args, cwd, timeoutMs = 120_000, env = process.env) {
                 clearTimeout(killTimer);
             fn();
         };
-        const child = spawn(cmd, args, { cwd, env, stdio: ["ignore", "pipe", "pipe"] });
+        const child = spawn(cmd, args, { cwd, env, stdio: ['ignore', 'pipe', 'pipe'] });
         timeoutTimer = setTimeout(() => {
             timedOut = true;
-            child.kill("SIGTERM");
+            child.kill('SIGTERM');
             killTimer = setTimeout(() => {
-                child.kill("SIGKILL");
+                child.kill('SIGKILL');
             }, 5_000);
         }, timeoutMs);
-        child.stdout?.on("data", append);
-        child.stderr?.on("data", append);
-        child.once("error", (err) => {
+        child.stdout?.on('data', append);
+        child.stderr?.on('data', append);
+        child.once('error', (err) => {
             settle(() => reject(err));
         });
-        child.once("close", (code, signal) => {
+        child.once('close', (code, signal) => {
             if (timedOut) {
-                settle(() => reject(new Error(`command timed out after ${timeoutMs}ms: ${cmd} ${args.join(" ")}\n${tail}`)));
+                settle(() => reject(new Error(`command timed out after ${timeoutMs}ms: ${cmd} ${args.join(' ')}\n${tail}`)));
                 return;
             }
             if (code === 0) {
                 settle(() => resolve(tail));
             }
             else {
-                settle(() => reject(new Error(`command failed (${code ?? signal}): ${cmd} ${args.join(" ")}\n${tail}`)));
+                settle(() => reject(new Error(`command failed (${code ?? signal}): ${cmd} ${args.join(' ')}\n${tail}`)));
             }
         });
     });
@@ -366,75 +366,75 @@ function assertSafeCustomWorkspacePath(plan, candidate = plan.workspaceDir) {
 function assertWritableWorkspaceDir(dir) {
     fs.accessSync(dir, fs.constants.R_OK | fs.constants.W_OK | fs.constants.X_OK);
     const probe = path.join(dir, `.parall-workspace-check-${process.pid}-${Date.now()}`);
-    const fd = fs.openSync(probe, "wx", 0o600);
+    const fd = fs.openSync(probe, 'wx', 0o600);
     fs.closeSync(fd);
     fs.unlinkSync(probe);
 }
 function workspacePathDenyReason(value) {
-    if (value === "/")
-        return "the filesystem root";
-    if (["/tmp", "/private/tmp", "/var/tmp", "/Users", "/home"].includes(value)) {
-        return "a shared or home root directory";
+    if (value === '/')
+        return 'the filesystem root';
+    if (['/tmp', '/private/tmp', '/var/tmp', '/Users', '/home'].includes(value)) {
+        return 'a shared or home root directory';
     }
     for (const root of [
-        "/Applications",
-        "/bin",
-        "/boot",
-        "/dev",
-        "/etc",
-        "/Library",
-        "/private/etc",
-        "/private/var/db",
-        "/proc",
-        "/root",
-        "/run",
-        "/sbin",
-        "/System",
-        "/sys",
-        "/usr",
-        "/var/db",
-        "/var/root",
+        '/Applications',
+        '/bin',
+        '/boot',
+        '/dev',
+        '/etc',
+        '/Library',
+        '/private/etc',
+        '/private/var/db',
+        '/proc',
+        '/root',
+        '/run',
+        '/sbin',
+        '/System',
+        '/sys',
+        '/usr',
+        '/var/db',
+        '/var/root',
     ]) {
         if (value === root || value.startsWith(`${root}/`)) {
-            return "a system directory";
+            return 'a system directory';
         }
     }
-    const parts = value.split("/").filter(Boolean);
-    if (parts.includes(".git"))
-        return "a git metadata directory";
-    if (parts.length === 2 && (parts[0] === "Users" || parts[0] === "home")) {
-        return "a home directory";
+    const parts = value.split('/').filter(Boolean);
+    if (parts.includes('.git'))
+        return 'a git metadata directory';
+    if (parts.length === 2 && (parts[0] === 'Users' || parts[0] === 'home')) {
+        return 'a home directory';
     }
-    if (parts.length >= 3 && (parts[0] === "Users" || parts[0] === "home")) {
+    if (parts.length >= 3 && (parts[0] === 'Users' || parts[0] === 'home')) {
         const homeChild = parts[2];
         if ([
-            ".aws",
-            ".azure",
-            ".claude",
-            ".codex",
-            ".config",
-            ".docker",
-            ".gnupg",
-            ".kube",
-            ".local",
-            ".npm",
-            ".ssh",
-            ".parall-agent",
-            ".parall-daemon",
-            "Library",
+            '.aws',
+            '.azure',
+            '.claude',
+            '.codex',
+            '.config',
+            '.docker',
+            '.gnupg',
+            '.kube',
+            '.local',
+            '.npm',
+            '.ssh',
+            '.parall-agent',
+            '.parall-daemon',
+            'Library',
         ].includes(homeChild)) {
-            return "a credential or application state directory";
+            return 'a credential or application state directory';
         }
     }
-    return "";
+    return '';
 }
 function isAncestorPath(parent, child) {
     const relative = path.relative(parent, child);
-    return relative !== "" && !relative.startsWith("..") && !path.isAbsolute(relative);
+    return relative !== '' && !relative.startsWith('..') && !path.isAbsolute(relative);
 }
 function toPolicyPath(value) {
-    return path.resolve(value).split(path.sep).join("/");
+    return path.resolve(value).split(path.sep).join('/');
 }
 function isNodeError(err) {
-    return err instanceof Error && "code" in err;
+    return err instanceof Error && 'code' in err;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@parall/daemon",
-  "version": "1.30.0",
+  "version": "1.32.0",
   "description": "Parall local agent runtime — daemon supervisor + bridge runtimes, bundled as standalone JS files",
   "license": "MIT",
   "repository": {
@@ -29,11 +29,11 @@
     "dist"
   ],
   "dependencies": {
-    "@parall/agent-core": "1.30.0",
-    "@parall/sdk": "1.30.0",
-    "@parall/claude-agent": "1.30.0",
-    "@parall/codex-agent": "1.30.0",
-    "@parall/openclaw-agent": "1.30.0"
+    "@parall/agent-core": "1.32.0",
+    "@parall/claude-agent": "1.32.0",
+    "@parall/codex-agent": "1.32.0",
+    "@parall/openclaw-agent": "1.32.0",
+    "@parall/sdk": "1.32.0"
   },
   "devDependencies": {
     "@types/node": "^22.0.0",