@fitlab-ai/agent-infra 0.5.9 → 0.6.0

package/dist/lib/sandbox/runtimes/ai-tools.dockerfile

@@ -0,0 +1,39 @@
+USER devuser
+ENV NPM_CONFIG_PREFIX=/home/devuser/.npm-global
+ENV PATH="/home/devuser/.npm-global/bin:${PATH}"
+
+ARG AI_TOOL_PACKAGES
+RUN if [ -z "${AI_TOOL_PACKAGES}" ]; then \
+      echo "AI_TOOL_PACKAGES build arg is required"; \
+      exit 1; \
+    fi && \
+    set -e && \
+    for pkg in ${AI_TOOL_PACKAGES}; do \
+      npm install -g "$pkg"; \
+    done
+
+RUN npm install -g pyright
+
+RUN mkdir -p /home/devuser/.local/share /home/devuser/.local/state
+
+RUN git config --global --add safe.directory /workspace
+
+# Host shell-config is bind-mounted as a directory at this path; the four files
+# inside (.gitconfig, .gitignore_global, .stCommitMsg, .bash_aliases) are exposed
+# via symlinks in $HOME. Directory binds avoid the //deleted invalidation that
+# single-file binds suffer when their source is rewritten on macOS/virtiofs.
+RUN mkdir -p /home/devuser/.host-shell-config && \
+    ln -sf .host-shell-config/.gitconfig        /home/devuser/.gitconfig && \
+    ln -sf .host-shell-config/.gitignore_global /home/devuser/.gitignore_global && \
+    ln -sf .host-shell-config/.stCommitMsg      /home/devuser/.stCommitMsg && \
+    ln -sf .host-shell-config/.bash_aliases     /home/devuser/.bash_aliases
+
+RUN echo 'export NPM_CONFIG_PREFIX=/home/devuser/.npm-global' >> /home/devuser/.bashrc && \
+    echo 'export PATH="/home/devuser/.npm-global/bin:${PATH}"' >> /home/devuser/.bashrc && \
+    echo 'export GIT_CONFIG_GLOBAL=/home/devuser/.gitconfig' >> /home/devuser/.bashrc && \
+    echo 'export GPG_TTY=$(tty)' >> /home/devuser/.bashrc && \
+    echo '[ -f ~/.bash_aliases ] && . ~/.bash_aliases' >> /home/devuser/.bashrc
+
+WORKDIR /workspace
+
+CMD ["tail", "-f", "/dev/null"]

package/dist/lib/sandbox/runtimes/base.dockerfile

@@ -0,0 +1,178 @@
+FROM ubuntu:22.04
+
+LABEL description="AI coding sandbox"
+
+ENV DEBIAN_FRONTEND=noninteractive
+ENV TZ=Asia/Shanghai
+
+ARG HOST_UID=1000
+ARG HOST_GID=1000
+# Root host uid 0 collides with container root; -o lets devuser share uid 0
+# while keeping a real passwd entry that USER devuser can resolve.
+RUN if [ "${HOST_UID}" = "0" ]; then \
+        (groupadd -o -g ${HOST_GID} devuser || true) && \
+        useradd -o -u ${HOST_UID} -g ${HOST_GID} -m -s /bin/bash devuser; \
+    else \
+        (groupadd -g ${HOST_GID} devuser || true) && \
+        useradd -u ${HOST_UID} -g ${HOST_GID} -m -s /bin/bash devuser; \
+    fi
+
+RUN apt-get update && apt-get install -y \
+    curl wget git vim file jq \
+    build-essential ca-certificates gnupg lsb-release \
+    libevent-core-2.1-7 libncursesw6 libtinfo6 \
+    pkg-config bison libevent-dev libncurses-dev \
+    locales \
+    && locale-gen en_US.UTF-8 \
+    && (curl -fsSL https://cli.github.com/packages/githubcli-archive-keyring.gpg \
+        | dd of=/usr/share/keyrings/githubcli-archive-keyring.gpg) \
+    && echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/githubcli-archive-keyring.gpg] https://cli.github.com/packages stable main" \
+        > /etc/apt/sources.list.d/github-cli.list \
+    && apt-get update && apt-get install -y gh \
+    && TMUX_VERSION=3.6a \
+    && wget -qO /tmp/tmux.tar.gz \
+        "https://github.com/tmux/tmux/releases/download/${TMUX_VERSION}/tmux-${TMUX_VERSION}.tar.gz" \
+    && tar xzf /tmp/tmux.tar.gz -C /tmp \
+    && cd /tmp/tmux-${TMUX_VERSION} \
+    && ./configure --prefix=/usr/local \
+    && make -j"$(nproc)" \
+    && make install \
+    && cd / \
+    && rm -rf /tmp/tmux.tar.gz /tmp/tmux-${TMUX_VERSION} \
+    && apt-get purge -y pkg-config bison libevent-dev libncurses-dev \
+    && apt-get autoremove -y \
+    && apt-get clean \
+    && rm -rf /var/lib/apt/lists/*
+
+# Enable extended keys in CSI u format so Shift+Enter and other modified
+# keys are forwarded through tmux. Preserve terminal-detection variables
+# injected at `docker exec` time when new tmux sessions are created.
+RUN printf '%s\n' \
+      'set -g extended-keys always' \
+      'set -g extended-keys-format csi-u' \
+      "set -as terminal-features 'xterm*:extkeys'" \
+      "set -ga update-environment 'TERM_PROGRAM TERM_PROGRAM_VERSION LC_TERMINAL LC_TERMINAL_VERSION'" \
+      'set -g mouse on' \
+      'set -g status-interval 1' \
+      'set -g status-right-length 80' \
+      "set -g status-right '#(/usr/local/bin/cc-token-status) | %H:%M'" \
+    > /etc/tmux.conf
+
+RUN cat > /usr/local/bin/cc-token-status <<'SCRIPT' && chmod +x /usr/local/bin/cc-token-status
+#!/bin/sh
+set -eu
+
+CRED_FILE="/home/devuser/.claude/.credentials.json"
+[ -r "$CRED_FILE" ] || exit 0
+
+EXPIRES_MS=$(jq -r '(.claudeAiOauth.expiresAt // .expiresAt) // empty' "$CRED_FILE" 2>/dev/null || true)
+case "$EXPIRES_MS" in
+  ''|*[!0-9]*) exit 0 ;;
+esac
+
+NOW_MS=$(($(date +%s) * 1000))
+DIFF_MS=$((EXPIRES_MS - NOW_MS))
+DIFF_S=$((DIFF_MS / 1000))
+
+DIM='#[fg=colour245]'
+YELLOW='#[fg=yellow]'
+YELLOW_BOLD='#[fg=yellow,bold]'
+RED_BOLD='#[fg=red,bold]'
+RED_REV='#[fg=red,reverse]'
+RESET='#[default]'
+
+if [ "$DIFF_S" -le 0 ]; then
+  ELAPSED=$(( -DIFF_S ))
+  M=$((ELAPSED / 60))
+  printf '%sClaude Code auth EXPIRED %dm ago%s' "$RED_REV" "$M" "$RESET"
+elif [ "$DIFF_S" -lt 60 ]; then
+  printf '%sClaude Code auth expires in %ds%s' "$RED_BOLD" "$DIFF_S" "$RESET"
+elif [ "$DIFF_S" -lt 300 ]; then
+  M=$((DIFF_S / 60))
+  S=$((DIFF_S % 60))
+  printf '%sClaude Code auth expires in %dm %ds%s' "$RED_BOLD" "$M" "$S" "$RESET"
+elif [ "$DIFF_S" -lt 1800 ]; then
+  M=$((DIFF_S / 60))
+  printf '%sClaude Code auth expires in %dm%s' "$YELLOW_BOLD" "$M" "$RESET"
+elif [ "$DIFF_S" -lt 3600 ]; then
+  M=$((DIFF_S / 60))
+  printf '%sClaude Code auth expires in %dm%s' "$YELLOW" "$M" "$RESET"
+else
+  TOTAL_M=$((DIFF_S / 60))
+  H=$((TOTAL_M / 60))
+  M=$((TOTAL_M % 60))
+  printf '%sClaude Code auth expires in %dh %dm%s' "$DIM" "$H" "$M" "$RESET"
+fi
+SCRIPT
+
+RUN cat > /usr/local/bin/sandbox-dotfiles-link <<'SCRIPT' && chmod +x /usr/local/bin/sandbox-dotfiles-link
+#!/bin/sh
+# Mirror /dotfiles/ tree as symlinks under $HOME/, overwriting any image-baked
+# defaults. Future preferences only need to land in the host directory.
+set -eu
+
+DOTFILES_SRC=/dotfiles
+[ -d "$DOTFILES_SRC" ] || exit 0
+
+cd "$DOTFILES_SRC"
+find . -type f -print | while IFS= read -r rel; do
+  rel=${rel#./}
+  target="$HOME/$rel"
+  case "$rel" in
+    .ssh|.ssh/*|\
+    .gnupg|.gnupg/*|\
+    .claude|.claude/*|\
+    .codex|.codex/*|\
+    .gemini|.gemini/*|\
+    .config/opencode|.config/opencode/*|\
+    .local/share/opencode|.local/share/opencode/*|\
+    .host-shell-config|.host-shell-config/*|\
+    .gitconfig|.gitignore_global|.stCommitMsg|.bash_aliases)
+      continue ;;
+  esac
+
+  mkdir -p "$(dirname "$target")"
+  if [ -d "$target" ] && [ ! -L "$target" ]; then
+    printf 'sandbox-dotfiles-link: skipping %s (existing directory; use nested path like %s/<file> instead)\n' "$target" "$rel" >&2
+    continue
+  fi
+
+  ln -sfn "$DOTFILES_SRC/$rel" "$target" 2>/dev/null \
+    || printf 'sandbox-dotfiles-link: failed to link %s\n' "$target" >&2
+done
+SCRIPT
+
+RUN cat > /usr/local/bin/sandbox-tmux-entry <<'SCRIPT' && chmod +x /usr/local/bin/sandbox-tmux-entry
+#!/bin/sh
+set -eu
+
+sandbox-dotfiles-link >/dev/null || true
+
+SESSION=work
+
+if ! command -v tmux >/dev/null 2>&1; then
+  exec bash
+fi
+
+if ! tmux has-session -t "$SESSION" 2>/dev/null; then
+  exec tmux new-session -s "$SESSION"
+fi
+
+tmux list-sessions -F '#{session_name} #{session_attached}' 2>/dev/null | \
+  while read -r name attached; do
+    [ "$name" = "$SESSION" ] && continue
+    case "$name" in
+      ''|*[!0-9]*) continue ;;
+    esac
+    [ "$attached" = "0" ] && tmux kill-session -t "$name" 2>/dev/null || true
+  done
+
+exec tmux new-session -t "$SESSION"
+SCRIPT
+
+ENV LANG=en_US.UTF-8
+ENV LC_ALL=en_US.UTF-8
+ENV TERM=xterm-256color
+ENV COLORTERM=truecolor
+
+RUN ln -s /workspace /home/devuser/workspace

package/dist/lib/sandbox/runtimes/java17.dockerfile

@@ -0,0 +1,3 @@
+RUN apt-get update && apt-get install -y \
+    openjdk-17-jdk maven \
+    && rm -rf /var/lib/apt/lists/*

package/dist/lib/sandbox/runtimes/java21.dockerfile

@@ -0,0 +1,3 @@
+RUN apt-get update && apt-get install -y \
+    openjdk-21-jdk maven \
+    && rm -rf /var/lib/apt/lists/*

package/dist/lib/sandbox/runtimes/node20.dockerfile

@@ -0,0 +1,3 @@
+RUN curl -fsSL https://deb.nodesource.com/setup_20.x | bash - && \
+    apt-get install -y nodejs && \
+    rm -rf /var/lib/apt/lists/*

package/dist/lib/sandbox/runtimes/node22.dockerfile

@@ -0,0 +1,3 @@
+RUN curl -fsSL https://deb.nodesource.com/setup_22.x | bash - && \
+    apt-get install -y nodejs && \
+    rm -rf /var/lib/apt/lists/*

package/dist/lib/sandbox/runtimes/python3.dockerfile

@@ -0,0 +1,3 @@
+RUN apt-get update && apt-get install -y \
+    python3 python3-pip python3-venv \
+    && rm -rf /var/lib/apt/lists/*

package/dist/lib/sandbox/shell.js

@@ -0,0 +1,148 @@
+import { execFileSync, spawnSync } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+const DEFAULT_TIMEOUT_MS = 60 * 60 * 1000;
+function normalizeOptions(opts = {}, stdio) {
+    return {
+        cwd: opts.cwd,
+        encoding: opts.encoding,
+        stdio,
+        timeout: opts.timeout ?? DEFAULT_TIMEOUT_MS
+    };
+}
+function resolveCommand(cmd) {
+    if (process.platform !== 'win32' || path.extname(cmd)) {
+        return cmd;
+    }
+    const pathValue = process.env.Path || process.env.PATH || '';
+    const extensions = (process.env.PATHEXT || '.COM;.EXE;.BAT;.CMD')
+        .split(';')
+        .filter(Boolean);
+    for (const dir of pathValue.split(path.delimiter).filter(Boolean)) {
+        for (const extension of extensions) {
+            const candidate = path.join(dir, `${cmd}${extension.toLowerCase()}`);
+            if (fs.existsSync(candidate)) {
+                return candidate;
+            }
+            const upperCandidate = path.join(dir, `${cmd}${extension.toUpperCase()}`);
+            if (fs.existsSync(upperCandidate)) {
+                return upperCandidate;
+            }
+        }
+    }
+    return cmd;
+}
+function commandOptions(cmd, opts) {
+    if (process.platform === 'win32' && /\.(?:bat|cmd)$/i.test(cmd)) {
+        return { ...opts, shell: true };
+    }
+    return opts;
+}
+export function run(cmd, args, opts = {}) {
+    const resolved = resolveCommand(cmd);
+    return execFileSync(resolved, args, commandOptions(resolved, {
+        ...normalizeOptions(opts, ['pipe', 'pipe', 'pipe']),
+        encoding: 'utf8'
+    })).trim();
+}
+export function runOk(cmd, args, opts = {}) {
+    const resolved = resolveCommand(cmd);
+    const result = spawnSync(resolved, args, commandOptions(resolved, normalizeOptions(opts, 'pipe')));
+    return result.status === 0;
+}
+export function restoreTerminal() {
+    if (!process.stdout.isTTY) {
+        return;
+    }
+    try {
+        process.stdout.write([
+            '\x1b[?1049l',
+            '\x1b[?25h',
+            '\x1b>',
+            '\x1b[?1000l',
+            '\x1b[?1002l',
+            '\x1b[?1003l',
+            '\x1b[?1006l'
+        ].join(''));
+    }
+    catch {
+        // Best-effort cleanup only; preserve the original command result.
+    }
+    if (process.platform === 'win32') {
+        return;
+    }
+    try {
+        execFileSync('stty', ['sane'], { stdio: 'inherit' });
+    }
+    catch {
+        // Some environments do not provide stty or reject sane; ANSI reset still helps.
+    }
+}
+export function runInteractive(cmd, args, opts = {}) {
+    const resolved = resolveCommand(cmd);
+    try {
+        const result = spawnSync(resolved, args, commandOptions(resolved, normalizeOptions(opts, 'inherit')));
+        return result.status ?? 1;
+    }
+    finally {
+        restoreTerminal();
+    }
+}
+export function runVerbose(cmd, args, opts = {}) {
+    const resolved = resolveCommand(cmd);
+    const result = spawnSync(resolved, args, commandOptions(resolved, normalizeOptions(opts, 'inherit')));
+    if (result.status !== 0) {
+        if (result.signal === 'SIGTERM') {
+            throw new Error(`Command timed out after ${opts.timeout ?? DEFAULT_TIMEOUT_MS}ms: ${cmd}`);
+        }
+        throw new Error(`Command failed with exit code ${result.status}: ${cmd}`);
+    }
+}
+export function runSafe(cmd, args, opts = {}) {
+    const resolved = resolveCommand(cmd);
+    const result = spawnSync(resolved, args, commandOptions(resolved, {
+        ...normalizeOptions(opts, ['pipe', 'pipe', 'pipe']),
+        encoding: 'utf8',
+    }));
+    if (result.status !== 0 && result.stderr) {
+        process.stderr.write(result.stderr);
+    }
+    return (result.stdout ?? '').trim();
+}
+export function commandForEngine(engine, cmd, args = []) {
+    if (engine === 'wsl2') {
+        const resolvedWrapper = resolveCommand('wsl.exe');
+        return { cmd: resolvedWrapper, args: ['--', cmd, ...args] };
+    }
+    return { cmd, args };
+}
+export function runEngine(engine, cmd, args, opts = {}) {
+    const command = commandForEngine(engine, cmd, args);
+    return run(command.cmd, command.args, opts);
+}
+export function execEngine(engine, cmd, args, opts = {}) {
+    const command = commandForEngine(engine, cmd, args);
+    return execFileSync(command.cmd, command.args, opts);
+}
+export function runOkEngine(engine, cmd, args, opts = {}) {
+    const command = commandForEngine(engine, cmd, args);
+    return runOk(command.cmd, command.args, opts);
+}
+export function runSafeEngine(engine, cmd, args, opts = {}) {
+    const command = commandForEngine(engine, cmd, args);
+    return runSafe(command.cmd, command.args, opts);
+}
+export function runVerboseEngine(engine, cmd, args, opts = {}) {
+    const command = commandForEngine(engine, cmd, args);
+    return runVerbose(command.cmd, command.args, opts);
+}
+export function runInteractiveEngine(engine, cmd, args, opts = {}) {
+    const command = commandForEngine(engine, cmd, args);
+    return runInteractive(command.cmd, command.args, opts);
+}
+export function runProbe(cmd, args, opts = {}) {
+    const { spawnFn = spawnSync, ...commandOpts } = opts;
+    const resolved = resolveCommand(cmd);
+    return spawnFn(resolved, args, commandOptions(resolved, normalizeOptions({ encoding: 'utf8', ...commandOpts }, commandOpts.stdio ?? ['pipe', 'pipe', 'pipe'])));
+}
+//# sourceMappingURL=shell.js.map

package/dist/lib/sandbox/task-resolver.js

@@ -0,0 +1,35 @@
+import fs from 'node:fs';
+import path from 'node:path';
+const TASK_ID_RE = /^TASK-\d{8}-\d{6}$/;
+const WORKSPACE_DIRS = ['active', 'completed', 'blocked', 'archive'];
+function stripQuotes(value) {
+    return value.replace(/^(["'])(.*)\1$/, '$2');
+}
+function readTaskContent(repoRoot, taskId) {
+    for (const dir of WORKSPACE_DIRS) {
+        const taskPath = path.join(repoRoot, '.agents', 'workspace', dir, taskId, 'task.md');
+        if (fs.existsSync(taskPath)) {
+            return fs.readFileSync(taskPath, 'utf8');
+        }
+    }
+    throw new Error(`Task not found: ${taskId}`);
+}
+function resolveBranchFromTaskContent(content, taskId) {
+    const frontmatterBranch = content.match(/^branch:\s*(.+)$/m);
+    if (frontmatterBranch?.[1]?.trim()) {
+        return stripQuotes(frontmatterBranch[1].trim());
+    }
+    const contextBranch = content.match(/^- \*\*(?:分支|Branch)\*\*：[ \t]*`?([^`\n]+)`?$/m);
+    if (contextBranch?.[1]?.trim()) {
+        return stripQuotes(contextBranch[1].trim());
+    }
+    throw new Error(`Task ${taskId} has no branch field in task.md`);
+}
+export function resolveTaskBranch(arg, repoRoot) {
+    if (!TASK_ID_RE.test(arg)) {
+        return arg;
+    }
+    const content = readTaskContent(repoRoot, arg);
+    return resolveBranchFromTaskContent(content, arg);
+}
+//# sourceMappingURL=task-resolver.js.map

package/dist/lib/sandbox/tools.js

@@ -0,0 +1,115 @@
+import { safeNameCandidates, sanitizeBranchName } from "./constants.js";
+import { hostJoin } from "./engines/wsl2-paths.js";
+function createBuiltinTools(home, project) {
+    return {
+        'claude-code': {
+            id: 'claude-code',
+            name: 'Claude Code',
+            npmPackage: '@anthropic-ai/claude-code',
+            sandboxBase: hostJoin(home, '.agent-infra', 'sandboxes', 'claude-code'),
+            containerMount: '/home/devuser/.claude',
+            versionCmd: 'claude --version',
+            setupHint: 'Authenticates via host credentials live-mounted at ~/.claude/.credentials.json',
+            // Claude Code stores user data (.claude.json — onboarding state, theme,
+            // workspace trust) at $HOME/.claude.json by default, which sits OUTSIDE
+            // the bind-mounted /home/devuser/.claude tree, so our preseeded
+            // .claude.json never gets read and the theme picker re-runs on every
+            // container start. Pinning CLAUDE_CONFIG_DIR to the tool mount relocates
+            // .claude.json into the same directory as .credentials.json/settings.json,
+            // letting ensureClaudeOnboarding actually take effect.
+            envVars: { CLAUDE_CONFIG_DIR: '/home/devuser/.claude' },
+            hostPreSeedDirs: [
+                { hostDir: hostJoin(home, '.claude', 'plugins'), sandboxSubdir: 'plugins' }
+            ],
+            pathRewriteFiles: [
+                'plugins/installed_plugins.json',
+                'plugins/known_marketplaces.json'
+            ],
+            hostLiveMounts: [
+                {
+                    hostPath: hostJoin(home, '.agent-infra', 'credentials', project, 'claude-code', '.credentials.json'),
+                    containerSubpath: '.credentials.json'
+                }
+            ]
+        },
+        codex: {
+            id: 'codex',
+            name: 'Codex',
+            npmPackage: '@openai/codex',
+            sandboxBase: hostJoin(home, '.agent-infra', 'sandboxes', 'codex'),
+            containerMount: '/home/devuser/.codex',
+            versionCmd: 'codex --version',
+            setupHint: 'Run codex once inside the container and choose Device Code login if needed.',
+            hostLiveMounts: [
+                { hostPath: hostJoin(home, '.codex', 'auth.json'), containerSubpath: 'auth.json' }
+            ],
+            postSetupCmds: [
+                'test -d /workspace/.codex/commands && ln -sfn /workspace/.codex/commands /home/devuser/.codex/prompts || true'
+            ]
+        },
+        opencode: {
+            id: 'opencode',
+            name: 'OpenCode',
+            npmPackage: 'opencode-ai',
+            sandboxBase: hostJoin(home, '.agent-infra', 'sandboxes', 'opencode'),
+            containerMount: '/home/devuser/.local/share/opencode',
+            versionCmd: 'opencode version',
+            setupHint: 'Configure OpenCode credentials inside the container before first use.',
+            // OpenCode reads opencode.json from $XDG_CONFIG_HOME/opencode by default,
+            // outside this tool mount. Pin the config file path so the inherited
+            // sandbox opencode.json is the one the TUI actually reads.
+            envVars: { OPENCODE_CONFIG: '/home/devuser/.local/share/opencode/opencode.json' },
+            hostLiveMounts: [
+                {
+                    hostPath: hostJoin(home, '.local', 'share', 'opencode', 'auth.json'),
+                    containerSubpath: 'auth.json'
+                }
+            ]
+        },
+        'gemini-cli': {
+            id: 'gemini-cli',
+            name: 'Gemini CLI',
+            npmPackage: '@google/gemini-cli',
+            sandboxBase: hostJoin(home, '.agent-infra', 'sandboxes', 'gemini-cli'),
+            containerMount: '/home/devuser/.gemini',
+            versionCmd: 'gemini --version',
+            setupHint: 'Run gemini inside the container to finish authentication.',
+            hostLiveMounts: [
+                { hostPath: hostJoin(home, '.gemini', 'oauth_creds.json'), containerSubpath: 'oauth_creds.json' }
+            ],
+            hostPreSeedFiles: [
+                { hostPath: hostJoin(home, '.gemini', 'settings.json'), sandboxName: 'settings.json' },
+                { hostPath: hostJoin(home, '.gemini', 'google_accounts.json'), sandboxName: 'google_accounts.json' }
+            ]
+        }
+    };
+}
+function validateTool(tool) {
+    if (!tool.npmPackage || !tool.containerMount.startsWith('/')) {
+        throw new Error(`Invalid sandbox tool descriptor: ${tool.id}`);
+    }
+}
+export function resolveTools(config) {
+    const builtins = createBuiltinTools(config.home, config.project);
+    return config.tools.map((id) => {
+        const tool = builtins[id];
+        if (!tool) {
+            throw new Error(`Unknown sandbox tool: ${id}`);
+        }
+        validateTool(tool);
+        return tool;
+    });
+}
+export function toolConfigDir(tool, project, branch) {
+    return hostJoin(tool.sandboxBase, project, sanitizeBranchName(branch));
+}
+export function toolConfigDirCandidates(tool, project, branch) {
+    return safeNameCandidates(branch).map((name) => hostJoin(tool.sandboxBase, project, name));
+}
+export function toolProjectDirCandidates(tool, project) {
+    return [hostJoin(tool.sandboxBase, project)];
+}
+export function toolNpmPackagesArg(tools) {
+    return tools.map((tool) => tool.npmPackage).join(' ');
+}
+//# sourceMappingURL=tools.js.map