@fitchmultz/pi-subagents 0.49.1 → 0.51.0

package/dist/runs/shared/worktree-process.js

@@ -1,107 +0,0 @@
-import { hasErrorCode } from "../../shared/unknown.js";
-import { spawn, spawnSync } from "node:child_process";
-import { addAbortListener } from "node:events";
-import { trySignalChildTree } from "../../shared/post-exit-stdio-guard.js";
-function normalizeGitStream(value) {
-    return typeof value === "string" ? value : "";
-}
-export function runGit(cwd, args) {
-    const result = spawnSync("git", ["-C", cwd, ...args], { encoding: "utf-8" });
-    return {
-        stdout: normalizeGitStream(result.stdout),
-        stderr: normalizeGitStream(result.stderr),
-        status: result.status,
-        error: result.error,
-    };
-}
-export function runGitChecked(cwd, args) {
-    const result = runGit(cwd, args);
-    if (result.status !== 0) {
-        const message = [result.stderr.trim(), result.stdout.trim()].find((text) => text.length > 0) ??
-            result.error?.message ??
-            `git -C ${cwd} ${args.join(" ")} failed`;
-        throw new Error(message, { cause: result.error });
-    }
-    return result.stdout;
-}
-/** Owns the child, its bounded output, abort listener, and timeout until stdio closes. */
-export function runSetupCommand(options) {
-    const { command, args, cwd, signal, input, timeoutMs } = options;
-    signal?.throwIfAborted();
-    return new Promise((resolve, reject) => {
-        let stdout = "";
-        let stderr = "";
-        let outputBytes = 0;
-        let failure;
-        const child = spawn(command, [...args], { cwd, detached: true, stdio: "pipe" });
-        const terminate = () => {
-            trySignalChildTree(child, "SIGKILL");
-        };
-        const abortListener = signal && addAbortListener(signal, terminate);
-        const timer = timeoutMs === undefined
-            ? undefined
-            : setTimeout(() => {
-                failure = new Error(`worktree setup hook timed out after ${timeoutMs}ms`);
-                terminate();
-            }, timeoutMs);
-        timer?.unref();
-        for (const stream of [child.stdout, child.stderr]) {
-            stream.setEncoding("utf8");
-            stream.on("data", (chunk) => {
-                outputBytes += Buffer.byteLength(chunk);
-                if (outputBytes > 1024 * 1024) {
-                    failure ??= new Error(`${command} output exceeded 1048576 bytes`);
-                    terminate();
-                }
-                else if (stream === child.stdout) {
-                    stdout += chunk;
-                }
-                else {
-                    stderr += chunk;
-                }
-            });
-        }
-        child.on("error", (error) => {
-            failure = error;
-            terminate();
-        });
-        child.on("exit", (status) => {
-            if (status !== 0) {
-                terminate();
-            }
-        });
-        child.on("close", (status) => {
-            clearTimeout(timer);
-            abortListener?.[Symbol.dispose]();
-            if (signal?.aborted === true) {
-                resolve({ stdout, stderr, status });
-            }
-            else if (failure) {
-                reject(failure);
-            }
-            else {
-                resolve({ stdout, stderr, status });
-            }
-        });
-        child.stdin.on("error", (error) => {
-            if (hasErrorCode(error, "EPIPE")) {
-                return;
-            } // The hook may exit without reading its payload.
-            failure = error;
-            terminate();
-        });
-        child.stdin.end(input);
-    }).then((result) => {
-        // AbortSignal.throwIfAborted preserves arbitrary native cancellation reasons.
-        signal?.throwIfAborted();
-        return result;
-    });
-}
-export async function runSetupGit(cwd, args, signal) {
-    const result = await runSetupCommand({ command: "git", args: ["-C", cwd, ...args], cwd, signal });
-    if (result.status !== 0) {
-        throw new Error([result.stderr.trim(), result.stdout.trim()].find((text) => text.length > 0) ??
-            `git -C ${cwd} ${args.join(" ")} failed`);
-    }
-    return result.stdout;
-}

package/dist/runs/shared/worktree.js

@@ -1,386 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { errorMessage as getErrorMessage, hasErrorCode } from "../../shared/unknown.js";
-import { markWorktreesForPreservation } from "./worktree-preservation.js";
-import { buildWorktreeBranch, buildWorktreePath } from "./worktree-location.js";
-export { findWorktreeTaskCwdConflict, formatWorktreeTaskCwdConflict, resolveExpectedWorktreeAgentCwd, } from "./worktree-location.js";
-import { ensureTempRoot } from "../../shared/temp-root.js";
-import { runGitChecked, runSetupCommand, runSetupGit } from "./worktree-process.js";
-import { DEFAULT_WORKTREE_SETUP_HOOK_TIMEOUT_MS, resolveWorktreeSetupHook, runWorktreeSetupHook, } from "./worktree-hook.js";
-export class WorktreeCleanupError extends Error {
-}
-async function resolveRepoState(cwd, signal) {
-    const repoCheck = await runSetupCommand({
-        command: "git",
-        args: ["-C", cwd, "rev-parse", "--is-inside-work-tree"],
-        cwd,
-        signal,
-    });
-    if (repoCheck.status !== 0 || repoCheck.stdout.trim() !== "true") {
-        throw new Error("worktree isolation requires a git repository");
-    }
-    const cwdRelative = (await runSetupGit(cwd, ["rev-parse", "--show-prefix"], signal))
-        .trim()
-        .replace(/[\\/]+$/, "");
-    const toplevel = (await runSetupGit(cwd, ["rev-parse", "--show-toplevel"], signal)).trim();
-    const status = await runSetupGit(toplevel, ["status", "--porcelain"], signal);
-    if (status.trim().length > 0) {
-        throw new Error("worktree isolation requires a clean git working tree. Commit or stash changes first, or rerun without worktree isolation if shared-checkout edits are intentional.");
-    }
-    const baseCommit = (await runSetupGit(toplevel, ["rev-parse", "HEAD"], signal)).trim();
-    return { toplevel, cwdRelative, baseCommit };
-}
-function safePatchAgentName(agent) {
-    return agent.replace(/[^\w.-]/g, "_");
-}
-function escapesRoot(relative) {
-    return relative === ".." || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative);
-}
-function readSyntheticStat(resolved) {
-    try {
-        return fs.lstatSync(resolved);
-    }
-    catch (error) {
-        if (hasErrorCode(error, "ENOENT")) {
-            return undefined;
-        }
-        throw error;
-    }
-}
-function removeSyntheticPath(worktree, syntheticPath) {
-    const resolved = path.resolve(worktree.path, syntheticPath);
-    const relative = path.relative(worktree.path, resolved);
-    if (relative.length === 0 || relative === "." || escapesRoot(relative)) {
-        return;
-    }
-    const stat = readSyntheticStat(resolved);
-    if (!stat) {
-        return;
-    }
-    const realRoot = fs.realpathSync(worktree.path);
-    const realParent = fs.realpathSync(path.dirname(resolved));
-    const parentRelative = path.relative(realRoot, realParent);
-    if (escapesRoot(parentRelative)) {
-        throw new Error(`synthetic path resolves outside the worktree: ${syntheticPath}`);
-    }
-    if (stat.isSymbolicLink()) {
-        fs.unlinkSync(resolved);
-        return;
-    }
-    if (stat.isDirectory()) {
-        fs.rmSync(resolved, { recursive: true, force: true });
-        return;
-    }
-    fs.rmSync(resolved, { force: true });
-}
-function removeSyntheticPathsBeforeDiff(worktree) {
-    if (worktree.syntheticPaths.length === 0) {
-        return;
-    }
-    const seen = new Set();
-    for (const syntheticPath of worktree.syntheticPaths) {
-        if (seen.has(syntheticPath)) {
-            continue;
-        }
-        seen.add(syntheticPath);
-        removeSyntheticPath(worktree, syntheticPath);
-    }
-}
-function emptyDiff(input) {
-    return {
-        ...input,
-        diffStat: "",
-        filesChanged: 0,
-        insertions: 0,
-        deletions: 0,
-    };
-}
-function parseNumstat(numstat) {
-    const lines = numstat
-        .split("\n")
-        .map((line) => line.trim())
-        .filter(Boolean);
-    let filesChanged = 0;
-    let insertions = 0;
-    let deletions = 0;
-    for (const line of lines) {
-        const columns = line.split("\t");
-        if (columns.length < 2) {
-            continue;
-        }
-        const [rawInsertions, rawDeletions] = columns;
-        filesChanged++;
-        if (/^\d+$/.test(rawInsertions)) {
-            insertions += parseInt(rawInsertions, 10);
-        }
-        if (/^\d+$/.test(rawDeletions)) {
-            deletions += parseInt(rawDeletions, 10);
-        }
-    }
-    return { filesChanged, insertions, deletions };
-}
-function captureWorktreeDiff(setup, worktree, agent, patchPath) {
-    removeSyntheticPathsBeforeDiff(worktree);
-    runGitChecked(worktree.path, ["add", "-A"]);
-    const diffStat = runGitChecked(worktree.path, [
-        "diff",
-        "--cached",
-        "--stat",
-        setup.baseCommit,
-    ]).trim();
-    const patch = runGitChecked(worktree.path, [
-        "diff",
-        "--cached",
-        "--binary",
-        "--no-textconv",
-        "--no-ext-diff",
-        setup.baseCommit,
-    ]);
-    const numstat = runGitChecked(worktree.path, ["diff", "--cached", "--numstat", setup.baseCommit]);
-    fs.writeFileSync(patchPath, patch, "utf-8");
-    if (patch.trim().length === 0) {
-        return emptyDiff({
-            index: worktree.index,
-            agent,
-            branch: worktree.branch,
-            patchPath,
-            worktreePath: worktree.path,
-        });
-    }
-    const parsed = parseNumstat(numstat);
-    return {
-        index: worktree.index,
-        agent,
-        branch: worktree.branch,
-        diffStat,
-        filesChanged: parsed.filesChanged,
-        insertions: parsed.insertions,
-        deletions: parsed.deletions,
-        patchPath,
-        worktreePath: worktree.path,
-    };
-}
-function writeEmptyPatch(patchPath) {
-    try {
-        fs.writeFileSync(patchPath, "", "utf-8");
-    }
-    catch {
-        // Diff artifact writing is best-effort in error paths.
-    }
-}
-function cleanupSingleWorktree(repoCwd, worktree) {
-    try {
-        runGitChecked(repoCwd, ["worktree", "remove", "--force", worktree.path]);
-    }
-    catch (error) {
-        console.error(`Failed to remove worktree '${worktree.path}': ${getErrorMessage(error)}`);
-    }
-    try {
-        runGitChecked(repoCwd, ["branch", "-D", worktree.branch]);
-    }
-    catch (error) {
-        console.error(`Failed to delete worktree branch '${worktree.branch}': ${getErrorMessage(error)}`);
-    }
-}
-function hasWorktreeChanges(diff) {
-    return (Boolean(diff.captureError) ||
-        diff.filesChanged > 0 ||
-        diff.insertions > 0 ||
-        diff.deletions > 0 ||
-        diff.diffStat.trim().length > 0);
-}
-async function reserveWorktree(plan, index) {
-    const { repo, signal } = plan;
-    const branch = buildWorktreeBranch(plan.runId, index);
-    const worktreePath = buildWorktreePath(plan.runId, index);
-    ensureTempRoot();
-    const pathExisted = fs.existsSync(worktreePath);
-    const branchExisted = (await runSetupGit(repo.toplevel, ["branch", "--list", branch], signal)).trim().length > 0;
-    // Reserve only resources this attempt can create, before Git can partially initialize them.
-    const agentCwd = repo.cwdRelative.length > 0 ? path.join(worktreePath, repo.cwdRelative) : worktreePath;
-    return {
-        worktree: { path: worktreePath, agentCwd, branch, index, syntheticPaths: [] },
-        reservation: {
-            path: pathExisted ? undefined : worktreePath,
-            branch: branchExisted ? undefined : branch,
-        },
-    };
-}
-async function initializeWorktree(plan, worktree) {
-    const { repo, signal } = plan;
-    const { path: worktreePath, agentCwd, branch, index } = worktree;
-    await runSetupGit(repo.toplevel, ["worktree", "add", worktreePath, "-b", branch, "HEAD"], signal);
-    const syntheticPaths = plan.hook
-        ? await runWorktreeSetupHook(plan.hook, {
-            version: 1,
-            repoRoot: repo.toplevel,
-            worktreePath,
-            agentCwd,
-            branch,
-            index,
-            runId: plan.runId,
-            baseCommit: repo.baseCommit,
-            agent: plan.agents?.[index],
-        }, signal)
-        : [];
-    return { path: worktreePath, agentCwd, branch, index, syntheticPaths };
-}
-async function rollbackWorktree(repoCwd, entry, signal) {
-    const failures = [];
-    if (entry.path !== undefined && fs.existsSync(entry.path)) {
-        try {
-            // An interrupted checkout can leave Git's initializing lock on this newly owned path.
-            await runSetupGit(repoCwd, ["worktree", "remove", "--force", "--force", entry.path], signal);
-        }
-        catch (error) {
-            failures.push(`Could not remove worktree '${entry.path}': ${getErrorMessage(error)}`);
-        }
-    }
-    if (entry.branch !== undefined) {
-        try {
-            const exists = (await runSetupGit(repoCwd, ["branch", "--list", entry.branch], signal)).trim();
-            if (exists.length > 0) {
-                await runSetupGit(repoCwd, ["branch", "-D", entry.branch], signal);
-            }
-        }
-        catch (error) {
-            failures.push(`Could not delete worktree branch '${entry.branch}': ${getErrorMessage(error)}`);
-        }
-    }
-    return failures;
-}
-export async function createWorktrees(cwd, runId, count, options) {
-    const signal = options?.signal;
-    const repo = await resolveRepoState(cwd, signal);
-    const hook = resolveWorktreeSetupHook(repo.toplevel, options?.setupHook);
-    const plan = { repo, runId, hook, signal, agents: options?.agents };
-    const worktrees = [];
-    const reservations = [];
-    try {
-        for (let index = 0; index < count; index++) {
-            // Git modifies a shared repository; finish setup before reserving the next worktree.
-            // oxlint-disable-next-line no-await-in-loop
-            const { worktree, reservation } = await reserveWorktree(plan, index);
-            reservations.push(reservation);
-            // Register rollback authority before Git can partially initialize this worktree.
-            // oxlint-disable-next-line no-await-in-loop
-            worktrees.push(await initializeWorktree(plan, worktree));
-        }
-    }
-    catch (error) {
-        // Rollback remains owned after cancellation and has its own bounded lifetime.
-        const cleanupSignal = AbortSignal.timeout(hook?.timeoutMs ?? DEFAULT_WORKTREE_SETUP_HOOK_TIMEOUT_MS);
-        const failures = [];
-        for (const entry of reservations.reverse()) {
-            // Reverse-order resource release must finish before removing the preceding reservation.
-            // oxlint-disable-next-line no-await-in-loop
-            failures.push(...(await rollbackWorktree(repo.toplevel, entry, cleanupSignal)));
-        }
-        if (failures.length > 0) {
-            throw new WorktreeCleanupError(`${getErrorMessage(error)}\n\nWorktree rollback incomplete:\n${failures.join("\n")}`, { cause: error });
-        }
-        throw error;
-    }
-    return { cwd: repo.toplevel, worktrees, baseCommit: repo.baseCommit };
-}
-export function diffWorktrees(setup, agents, diffsDir) {
-    try {
-        fs.mkdirSync(diffsDir, { recursive: true });
-    }
-    catch (error) {
-        const message = `failed to create worktree diff artifact directory '${diffsDir}': ${getErrorMessage(error)}`;
-        markWorktreesForPreservation(setup, message);
-        return setup.worktrees.map((worktree, index) => {
-            const agent = agents[index] ?? `task-${index + 1}`;
-            const patchPath = path.join(diffsDir, `task-${index}-${safePatchAgentName(agent)}.patch`);
-            return emptyDiff({
-                index,
-                agent,
-                branch: worktree.branch,
-                patchPath,
-                worktreePath: worktree.path,
-                captureError: message,
-            });
-        });
-    }
-    const diffs = [];
-    for (let index = 0; index < setup.worktrees.length; index++) {
-        const worktree = setup.worktrees[index];
-        const agent = agents[index] ?? `task-${index + 1}`;
-        const patchPath = path.join(diffsDir, `task-${index}-${safePatchAgentName(agent)}.patch`);
-        try {
-            diffs.push(captureWorktreeDiff(setup, worktree, agent, patchPath));
-        }
-        catch (error) {
-            const message = `failed to capture worktree diff for task ${index + 1} (${agent}) at '${worktree.path}': ${getErrorMessage(error)}`;
-            markWorktreesForPreservation(setup, message);
-            writeEmptyPatch(patchPath);
-            diffs.push(emptyDiff({
-                index,
-                agent,
-                branch: worktree.branch,
-                patchPath,
-                worktreePath: worktree.path,
-                captureError: message,
-            }));
-        }
-    }
-    return diffs;
-}
-export function cleanupWorktrees(setup) {
-    if (setup.preserveOnCleanup === true) {
-        return;
-    }
-    for (let index = setup.worktrees.length - 1; index >= 0; index--) {
-        cleanupSingleWorktree(setup.cwd, setup.worktrees[index]);
-    }
-    try {
-        runGitChecked(setup.cwd, ["worktree", "prune"]);
-    }
-    catch (error) {
-        console.error(`Failed to prune worktrees in '${setup.cwd}': ${getErrorMessage(error)}`);
-    }
-}
-function worktreeRecoveryLines(diff) {
-    if (diff.captureError === undefined || diff.captureError.length === 0) {
-        return [];
-    }
-    const lines = [`Diff capture failed: ${diff.captureError}`];
-    if (diff.worktreePath !== undefined && diff.worktreePath.length > 0) {
-        lines.push(`Preserved worktree: ${diff.worktreePath}`);
-    }
-    lines.push(`Preserved branch: ${diff.branch}`);
-    return lines;
-}
-export function formatWorktreeDiffSummary(diffs) {
-    const changed = diffs.filter(hasWorktreeChanges);
-    if (changed.length === 0) {
-        return "";
-    }
-    const lines = ["=== Worktree Changes ===", ""];
-    for (const diff of changed) {
-        lines.push(`--- Task ${diff.index + 1} (${diff.agent}): ${diff.filesChanged} files changed, +${diff.insertions} -${diff.deletions} ---`);
-        lines.push(...worktreeRecoveryLines(diff));
-        if (diff.diffStat.trim().length > 0) {
-            lines.push(diff.diffStat);
-        }
-        lines.push("");
-    }
-    const patchesDir = path.dirname(changed[0]?.patchPath ?? "");
-    if (changed.some((diff) => (diff.captureError ?? "").length === 0)) {
-        lines.push(`Full patches: ${patchesDir}`);
-    }
-    else {
-        lines.push("Patch artifacts unavailable; preserved worktrees contain the recoverable changes.");
-    }
-    return lines.join("\n").trimEnd();
-}
-export function formatParallelWorktreeSummary(worktreeSetup, diffsDir, agents) {
-    if (!worktreeSetup) {
-        return "";
-    }
-    return formatWorktreeDiffSummary(diffWorktrees(worktreeSetup, agents, diffsDir));
-}
-export function appendWorktreeSummary(output, worktreeSummary) {
-    return worktreeSummary.length > 0 ? `${output}\n\n${worktreeSummary}` : output;
-}

package/dist/shared/agent-context-policy.js

@@ -1,116 +0,0 @@
-import { getStepAgents, isDynamicParallelStep, isParallelStep, } from "./settings.js";
-import { createForkContextResolver, resolveSubagentContext } from "./fork-context.js";
-import { wrapForkTask } from "./types.js";
-export function resolveAgentContext(explicitContext, agentName, agents) {
-    if (explicitContext !== undefined) {
-        return resolveSubagentContext(explicitContext);
-    }
-    if (agentName === undefined || agentName === "") {
-        return "fresh";
-    }
-    const agent = agents.find((entry) => entry.name === agentName);
-    return agent?.defaultContext === "fork" ? "fork" : "fresh";
-}
-function chainAgentTargets(step) {
-    if (isParallelStep(step)) {
-        return step.parallel.map((task) => ({ agent: task.agent, model: task.model }));
-    }
-    const task = isDynamicParallelStep(step) ? step.parallel : step;
-    return [{ agent: task.agent, model: task.model }];
-}
-function collectInvocationAgentTargets(params) {
-    if (params.tasks !== undefined && params.tasks.length > 0) {
-        return params.tasks.map((task) => ({ agent: task.agent, model: task.model }));
-    }
-    if (params.chain !== undefined && params.chain.length > 0) {
-        return params.chain.flatMap(chainAgentTargets);
-    }
-    return params.agent !== undefined && params.agent !== ""
-        ? [{ agent: params.agent, model: params.model }]
-        : [];
-}
-export function validateForkContextModelPolicy(params, agents, resolveModel) {
-    for (const target of collectInvocationAgentTargets(params)) {
-        const agent = agents.find((entry) => entry.name === target.agent);
-        if (!agent || resolveAgentContext(params.context, target.agent, agents) !== "fork") {
-            continue;
-        }
-        const anthropicModel = (target.model !== undefined && target.model !== ""
-            ? [target.model]
-            : [agent.model, ...(agent.fallbackModels ?? [])])
-            .filter((model) => Boolean(model?.trim()))
-            .map((model) => resolveModel?.(model) ?? model)
-            .find((model) => model.trim().toLowerCase().startsWith("anthropic/"));
-        if (anthropicModel !== undefined && anthropicModel !== "") {
-            return `Fork context cannot be used with anthropic/* models. Agent '${target.agent}' has effective model candidate '${anthropicModel}'. Use context: "fresh" or a non-Anthropic model; this restriction cannot be overridden.`;
-        }
-    }
-    return undefined;
-}
-export function invocationUsesForkContext(explicitContext, agentNames, agents) {
-    if (explicitContext !== undefined) {
-        return resolveSubagentContext(explicitContext) === "fork";
-    }
-    return agentNames.some((name) => resolveAgentContext(undefined, name, agents) === "fork");
-}
-export function buildFlatAgentNameResolver(params) {
-    if ((params.tasks?.length ?? 0) > 0 || (params.chain?.length ?? 0) > 0) {
-        const names = collectInvocationAgentTargets(params).map((target) => target.agent);
-        return (index) => names[index];
-    }
-    return () => (params.agent === "" ? undefined : params.agent);
-}
-export function wrapTaskForAgentContext(task, explicitContext, agentName, agents) {
-    return resolveAgentContext(explicitContext, agentName, agents) === "fork"
-        ? wrapForkTask(task)
-        : task;
-}
-export function wrapChainTasksForAgentContext(chain, explicitContext, agents) {
-    return chain.map((step, stepIndex) => {
-        if (isParallelStep(step)) {
-            return {
-                ...step,
-                parallel: step.parallel.map((task) => ({
-                    ...task,
-                    task: wrapTaskForAgentContext(task.task ?? "{previous}", explicitContext, task.agent, agents),
-                })),
-            };
-        }
-        if (isDynamicParallelStep(step)) {
-            return {
-                ...step,
-                parallel: {
-                    ...step.parallel,
-                    task: wrapTaskForAgentContext(step.parallel.task ?? "{previous}", explicitContext, step.parallel.agent, agents),
-                },
-            };
-        }
-        const sequential = step;
-        const agentName = getStepAgents(step)[0];
-        return {
-            ...sequential,
-            task: wrapTaskForAgentContext(sequential.task ?? (stepIndex === 0 ? "{task}" : "{previous}"), explicitContext, agentName, agents),
-        };
-    });
-}
-export function createPerAgentForkContextResolver(sessionManager, resolveContextForIndex, options = {}) {
-    let forkResolver;
-    const sessionFileForContext = (context, index = 0) => {
-        if (context !== "fork") {
-            return undefined;
-        }
-        if (!forkResolver) {
-            forkResolver = createForkContextResolver(sessionManager);
-        }
-        return forkResolver.sessionFileForIndex(index);
-    };
-    return {
-        sessionFileForIndex(index = 0) {
-            return sessionFileForContext(resolveContextForIndex(index), index);
-        },
-        sessionFileForAgentIndex(agentName, index = 0) {
-            const context = options.resolveContextForAgentIndex?.(agentName, index) ?? resolveContextForIndex(index);
-            return sessionFileForContext(context, index);
-        },
-    };
-}

package/dist/shared/agent-dir.js

@@ -1,14 +0,0 @@
-import * as os from "node:os";
-import * as path from "node:path";
-export function getAgentDir() {
-    const configured = process.env.PI_CODING_AGENT_DIR;
-    if (configured === "~") {
-        return os.homedir();
-    }
-    if (configured?.startsWith("~/") === true) {
-        return path.join(os.homedir(), configured.slice(2));
-    }
-    return configured !== undefined && configured !== ""
-        ? configured
-        : path.join(os.homedir(), ".pi", "agent");
-}