@parall/daemon 1.29.0 → 1.29.2

package/dist/workspace.js

@@ -0,0 +1,439 @@
+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) {
+    const prior = opts.attached.workspace_state;
+    const plan = buildWorkspacePlan(opts.attached.daemon_config, opts.defaultWorkspaceDir, prior?.config_hash);
+    if (!opts.attached.daemon_config && !prior) {
+        return plan.workspaceDir;
+    }
+    let forceSetup = false;
+    if (prior?.status === "ready" && prior.config_hash === plan.configHash) {
+        if (await verifyExistingWorkspace(plan, opts.log)) {
+            return plan.workspaceDir;
+        }
+        forceSetup = true;
+    }
+    await opts.client.reportAgentWorkspaceState(opts.agentId, {
+        config_hash: plan.configHash,
+        status: "preparing",
+    });
+    let outputTail = "";
+    try {
+        await ensureWorkspace(plan, opts.log);
+        if (shouldRunSetup(plan.workspace.setup, prior, plan.configHash, forceSetup)) {
+            outputTail = await runSetup(plan.workspaceDir, plan.workspace.setup.command, plan.workspace.setup?.timeout_sec);
+        }
+        await opts.client.reportAgentWorkspaceState(opts.agentId, {
+            config_hash: plan.configHash,
+            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, {
+            config_hash: plan.configHash,
+            status: "failed",
+            last_error: message,
+            output_tail: outputTail || null,
+        }).catch((reportErr) => {
+            opts.log.warn(`workspace state report failed after setup error: ${String(reportErr)}`);
+        });
+        throw err;
+    }
+}
+function buildWorkspacePlan(input, defaultWorkspaceDir, serverConfigHash) {
+    const config = normalizeConfig(input, defaultWorkspaceDir);
+    const workspace = config.workspace;
+    const { workspaceDir, customWorkspaceField } = resolveWorkspaceDir(workspace, defaultWorkspaceDir);
+    // 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");
+    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 };
+    }
+    if (!cfg.workspace) {
+        cfg.workspace = { mode: "default" };
+    }
+    const ws = cfg.workspace;
+    ws.mode = (ws.mode?.trim() || undefined);
+    ws.path = ws.path?.trim() || undefined;
+    if (ws.git) {
+        ws.git.remote = ws.git.remote?.trim() || undefined;
+        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";
+    }
+    if (ws.mode === "git") {
+        ws.git ||= {};
+        if (!ws.git.target_path && ws.path) {
+            ws.git.target_path = ws.path;
+        }
+    }
+    if (ws.mode === "default") {
+        ws.path = undefined;
+        ws.git = undefined;
+    }
+    if (ws.mode === "local_path") {
+        ws.git = undefined;
+    }
+    if (ws.setup) {
+        ws.setup.command = ws.setup.command?.trim();
+        ws.setup.run_on ||= "first_attach";
+        if (!ws.setup.command) {
+            ws.setup = undefined;
+        }
+    }
+    // Keep hash stable when the default dir changes by not materializing it
+    // into config. It is still used as the execution directory below.
+    void defaultWorkspaceDir;
+    return cfg;
+}
+function resolveWorkspaceDir(workspace, defaultWorkspaceDir) {
+    if (workspace.mode === "local_path") {
+        if (!workspace.path)
+            return { workspaceDir: defaultWorkspaceDir };
+        return {
+            workspaceDir: requireAbsolute(workspace.path, "workspace.path"),
+            customWorkspaceField: "workspace.path",
+        };
+    }
+    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: defaultWorkspaceDir };
+    }
+    return { workspaceDir: defaultWorkspaceDir };
+}
+async function ensureWorkspace(plan, log) {
+    const ws = plan.workspace;
+    if (ws.mode === "default") {
+        fs.mkdirSync(plan.workspaceDir, { recursive: true });
+        assertWritableWorkspaceDir(plan.workspaceDir);
+        return;
+    }
+    if (ws.mode === "local_path") {
+        assertSafeCustomWorkspacePath(plan);
+        let st;
+        try {
+            st = fs.statSync(plan.workspaceDir);
+        }
+        catch (err) {
+            if (isNodeError(err) && err.code === "ENOENT") {
+                throw new Error(`workspace path does not exist: ${plan.workspaceDir}`);
+            }
+            throw err;
+        }
+        if (!st.isDirectory()) {
+            throw new Error(`workspace path is not a directory: ${plan.workspaceDir}`);
+        }
+        assertSafeCustomWorkspacePath(plan, fs.realpathSync(plan.workspaceDir));
+        assertWritableWorkspaceDir(plan.workspaceDir);
+        return;
+    }
+    if (ws.mode === "git") {
+        const remote = ws.git?.remote?.trim();
+        if (!remote)
+            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());
+        }
+        else {
+            const st = fs.statSync(plan.workspaceDir);
+            if (!st.isDirectory()) {
+                throw new Error(`workspace path is not a directory: ${plan.workspaceDir}`);
+            }
+            if (plan.customWorkspaceField) {
+                assertSafeCustomWorkspacePath(plan, fs.realpathSync(plan.workspaceDir));
+            }
+            assertWritableWorkspaceDir(plan.workspaceDir);
+            await ensureGitWorktree(plan.workspaceDir);
+            await ensureGitRemote(plan.workspaceDir, remote);
+        }
+        if (ws.git?.ref) {
+            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 checkoutGitRef(plan.workspaceDir, ws.git.ref);
+        }
+        log.info(`workspace ready: git ${remote} -> ${plan.workspaceDir}`);
+        return;
+    }
+    throw new Error(`unsupported workspace mode: ${ws.mode ?? "(empty)"}`);
+}
+async function verifyExistingWorkspace(plan, log) {
+    try {
+        if (plan.customWorkspaceField) {
+            assertSafeCustomWorkspacePath(plan);
+        }
+        const st = fs.statSync(plan.workspaceDir);
+        if (!st.isDirectory()) {
+            log.warn(`workspace ready state ignored: path is not a directory: ${plan.workspaceDir}`);
+            return false;
+        }
+        if (plan.customWorkspaceField) {
+            assertSafeCustomWorkspacePath(plan, fs.realpathSync(plan.workspaceDir));
+        }
+        assertWritableWorkspaceDir(plan.workspaceDir);
+        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 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})`);
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+    catch (err) {
+        log.warn(`workspace ready state ignored: ${String(err)}`);
+        return false;
+    }
+}
+async function ensureGitWorktree(cwd) {
+    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();
+    if (actualRemote !== expectedRemote) {
+        throw new Error(`workspace git remote mismatch: expected ${expectedRemote}, got ${actualRemote}`);
+    }
+}
+async function checkoutGitRef(cwd, ref) {
+    const remoteCommit = await resolveRemoteGitRef(cwd, ref);
+    if (remoteCommit) {
+        await runCommand("git", ["checkout", "-B", ref, remoteCommit], cwd);
+        return;
+    }
+    const targetCommit = await resolveGitCommit(cwd, ref);
+    await runCommand("git", ["checkout", "--detach", targetCommit], cwd);
+}
+async function resolveConfiguredGitRef(cwd, ref) {
+    const remote = await resolveRemoteGitRef(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();
+}
+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);
+        if (commit.trim()) {
+            return commit.trim();
+        }
+    }
+    throw new Error(`workspace git ref not found: ${ref}`);
+}
+function shouldRunSetup(setup, prior, configHash, forceSetup = false) {
+    if (!setup?.command)
+        return false;
+    if (forceSetup)
+        return true;
+    if (setup.run_on === "config_change") {
+        return prior?.config_hash !== configHash || prior.status === "pending" || prior.status === "failed";
+    }
+    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());
+}
+function scrubSetupEnv() {
+    const env = { ...process.env };
+    clearAllProviderCreds(env);
+    delete env.PRLL_API_KEY;
+    return env;
+}
+async function commandOutput(cmd, args, cwd) {
+    return runCommand(cmd, args, cwd);
+}
+async function tryGitOutput(cmd, args, cwd) {
+    try {
+        return await runCommand(cmd, args, cwd);
+    }
+    catch {
+        return "";
+    }
+}
+function runCommand(cmd, args, cwd, timeoutMs = 120_000, env = process.env) {
+    return new Promise((resolve, reject) => {
+        let tail = "";
+        let timedOut = false;
+        let settled = false;
+        let timeoutTimer = null;
+        let killTimer = null;
+        const append = (chunk) => {
+            tail += chunk.toString();
+            if (tail.length > OUTPUT_TAIL_LIMIT) {
+                tail = tail.slice(-OUTPUT_TAIL_LIMIT);
+            }
+        };
+        const settle = (fn) => {
+            if (settled)
+                return;
+            settled = true;
+            if (timeoutTimer)
+                clearTimeout(timeoutTimer);
+            if (killTimer)
+                clearTimeout(killTimer);
+            fn();
+        };
+        const child = spawn(cmd, args, { cwd, env, stdio: ["ignore", "pipe", "pipe"] });
+        timeoutTimer = setTimeout(() => {
+            timedOut = true;
+            child.kill("SIGTERM");
+            killTimer = setTimeout(() => {
+                child.kill("SIGKILL");
+            }, 5_000);
+        }, timeoutMs);
+        child.stdout?.on("data", append);
+        child.stderr?.on("data", append);
+        child.once("error", (err) => {
+            settle(() => reject(err));
+        });
+        child.once("close", (code, signal) => {
+            if (timedOut) {
+                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}`)));
+            }
+        });
+    });
+}
+function requireAbsolute(value, field) {
+    if (!value || !path.isAbsolute(value)) {
+        throw new Error(`${field} must be an absolute path`);
+    }
+    return path.resolve(value);
+}
+function assertSafeCustomWorkspacePath(plan, candidate = plan.workspaceDir) {
+    if (!plan.customWorkspaceField)
+        return;
+    const normalized = requireAbsolute(candidate, plan.customWorkspaceField);
+    const reason = workspacePathDenyReason(toPolicyPath(normalized));
+    if (reason) {
+        throw new Error(`${plan.customWorkspaceField} must point to a project folder, not ${reason}: ${normalized}`);
+    }
+    const defaultWorkspace = path.resolve(plan.defaultWorkspaceDir);
+    if (isAncestorPath(normalized, defaultWorkspace) || normalized === defaultWorkspace) {
+        throw new Error(`${plan.customWorkspaceField} must not point at daemon state directories: ${normalized}`);
+    }
+}
+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);
+    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";
+    }
+    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",
+    ]) {
+        if (value === root || value.startsWith(`${root}/`)) {
+            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";
+    }
+    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",
+        ].includes(homeChild)) {
+            return "a credential or application state directory";
+        }
+    }
+    return "";
+}
+function isAncestorPath(parent, child) {
+    const relative = path.relative(parent, child);
+    return relative !== "" && !relative.startsWith("..") && !path.isAbsolute(relative);
+}
+function toPolicyPath(value) {
+    return path.resolve(value).split(path.sep).join("/");
+}
+function isNodeError(err) {
+    return err instanceof Error && "code" in err;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@parall/daemon",
-  "version": "1.29.0",
+  "version": "1.29.2",
   "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.29.0",
-    "@parall/sdk": "1.29.0",
-    "@parall/claude-agent": "1.29.0",
-    "@parall/codex-agent": "1.29.0",
-    "@parall/openclaw-agent": "1.29.0"
+    "@parall/sdk": "1.29.2",
+    "@parall/codex-agent": "1.29.2",
+    "@parall/claude-agent": "1.29.2",
+    "@parall/agent-core": "1.29.2",
+    "@parall/openclaw-agent": "1.29.2"
   },
   "devDependencies": {
     "@types/node": "^22.0.0",