@ivotoby/postgram-cli 1.38.3 → 1.40.0

package/dist/tracking/where.js

@@ -0,0 +1,306 @@
+// cli/src/tracking/where.ts: pgm where — features and workspaces grouped by stage.
+import { existsSync } from 'node:fs';
+import { shortId } from '../shared.js';
+import { runTrackingCommand } from './api.js';
+import { usageExit } from './config.js';
+import { formatAge, isTranscriptGone, renderResume } from './resume.js';
+export function collectWorkspaces(response) {
+    const workspaces = [];
+    for (const group of response.groups) {
+        if ('features' in group) {
+            for (const feature of group.features) {
+                workspaces.push(...feature.workspaces);
+            }
+        }
+        else {
+            workspaces.push(...group.workspaces);
+        }
+    }
+    return workspaces;
+}
+export async function syncMissing(workspaces, deps) {
+    let changed = false;
+    const failedIds = new Set();
+    for (const workspace of workspaces) {
+        if (workspace.machine !== deps.localAlias) {
+            continue;
+        }
+        const present = deps.exists(workspace.path);
+        if (!present && workspace.missing_since === null) {
+            try {
+                await deps.patch(workspace.id, true);
+                changed = true;
+            }
+            catch {
+                failedIds.add(workspace.id);
+            }
+        }
+        else if (present && workspace.missing_since !== null) {
+            try {
+                await deps.patch(workspace.id, false);
+                changed = true;
+            }
+            catch {
+                // the workspace is present; nothing to mark locally
+            }
+        }
+    }
+    return { changed, failedIds };
+}
+function displayRisks(workspace, input) {
+    const risks = [...workspace.risks];
+    if (input.failedIds.has(workspace.id) &&
+        !input.exists(workspace.path) &&
+        !risks.includes('missing')) {
+        risks.push('missing');
+    }
+    return risks;
+}
+function riskText(risk, workspace) {
+    if (risk === 'dirty') {
+        const count = workspace.git?.dirty_count ?? null;
+        return count !== null ? `dirty:${count}` : risk;
+    }
+    if (risk === 'unpushed') {
+        const count = workspace.git?.unpushed_count ?? null;
+        return count !== null ? `unpushed:${count}` : risk;
+    }
+    return risk;
+}
+function transcriptGone(workspace, input) {
+    return isTranscriptGone(workspace, input.localAlias, input.exists);
+}
+function augmentedWorkspace(workspace, input) {
+    const gone = transcriptGone(workspace, input);
+    return {
+        ...workspace,
+        risks: displayRisks(workspace, input),
+        git: workspace.git !== null ? { ...workspace.git } : null,
+        resume_session: workspace.resume_session !== null ? { ...workspace.resume_session } : null,
+        sessions: workspace.sessions.map((session) => ({ ...session })),
+        resume: renderResume(workspace, {
+            localAlias: input.localAlias,
+            templates: input.templates,
+            transcriptGone: gone
+        }),
+        transcript_gone: gone
+    };
+}
+export function augmentWhere(response, input) {
+    const groups = response.groups.map((group) => {
+        if ('features' in group) {
+            const features = group.features.map((feature) => ({
+                ...feature,
+                pull_requests: feature.pull_requests.map((pullRequest) => ({
+                    ...pullRequest
+                })),
+                workspaces: feature.workspaces.map((workspace) => augmentedWorkspace(workspace, input))
+            }));
+            return { ...group, features };
+        }
+        return {
+            ...group,
+            workspaces: group.workspaces.map((workspace) => augmentedWorkspace(workspace, input))
+        };
+    });
+    return { ...response, groups };
+}
+const PATH_WIDTH = 70;
+/**
+ * Home-relative for local workspaces. A path that is still too long loses its
+ * leading segments, never its end: the end is what tells worktrees apart.
+ */
+function displayPath(workspace, input) {
+    let shown = workspace.path;
+    const home = input.homeDir;
+    if (home !== undefined &&
+        workspace.machine === input.localAlias &&
+        (shown === home || shown.startsWith(`${home}/`))) {
+        shown = `~${shown.slice(home.length)}`;
+    }
+    if (shown.length <= PATH_WIDTH) {
+        return shown;
+    }
+    const segments = shown.split('/');
+    let tail = segments.pop() ?? '';
+    while (segments.length > 1) {
+        const next = segments[segments.length - 1] ?? '';
+        if (`…/${next}/${tail}`.length > PATH_WIDTH) {
+            break;
+        }
+        tail = `${next}/${tail}`;
+        segments.pop();
+    }
+    return `…/${tail}`;
+}
+function workspaceLines(workspace, input) {
+    const risks = displayRisks(workspace, input).map((risk) => riskText(risk, workspace));
+    let line1 = `  ${workspace.machine}  ${workspace.branch ?? '-'}`;
+    if (risks.length > 0) {
+        line1 = `${line1}  ${risks.join(' ')}`;
+    }
+    const gitAge = workspace.git_state_at !== null
+        ? formatAge(workspace.git_state_at, input.now)
+        : '?';
+    let sessions;
+    if (workspace.sessions.length === 0) {
+        sessions = 'no sessions';
+    }
+    else {
+        const gone = transcriptGone(workspace, input);
+        const resumeId = workspace.resume_session?.id ?? null;
+        sessions = workspace.sessions
+            .map((session) => {
+            let text = `${session.agent_kind}/${session.status} ${formatAge(session.last_activity_at, input.now)}`;
+            if (session.dormant) {
+                text = `${text} dormant`;
+            }
+            if (gone && resumeId !== null && session.id === resumeId) {
+                text = `${text} transcript gone`;
+            }
+            return text;
+        })
+            .join(', ');
+    }
+    const line2 = `  ${displayPath(workspace, input)}  git ${gitAge}  ${sessions}`;
+    const resume = renderResume(workspace, {
+        localAlias: input.localAlias,
+        templates: input.templates,
+        transcriptGone: transcriptGone(workspace, input)
+    });
+    return [line1, line2, `  resume: ${resume}`];
+}
+function riskLabels(workspace, input) {
+    return displayRisks(workspace, input).map((risk) => riskText(risk, workspace));
+}
+function latestWorkspace(workspaces) {
+    let latest = null;
+    for (const workspace of workspaces) {
+        if (latest === null ||
+            Date.parse(workspace.last_activity_at) > Date.parse(latest.last_activity_at)) {
+            latest = workspace;
+        }
+    }
+    return latest;
+}
+function compactFeatureLines(workspaces, input) {
+    const withRisks = workspaces.filter((workspace) => displayRisks(workspace, input).length > 0).length;
+    const latest = latestWorkspace(workspaces);
+    const lines = [
+        `  ${workspaces.length} workspaces, ${withRisks} with risks (--expand lists them)`
+    ];
+    if (latest !== null) {
+        lines.push(`  latest: ${latest.machine}  ${latest.branch ?? '-'}  ${displayPath(latest, input)}  ${formatAge(latest.last_activity_at, input.now)}`, `  resume: ${renderResume(latest, {
+            localAlias: input.localAlias,
+            templates: input.templates,
+            transcriptGone: transcriptGone(latest, input)
+        })}`);
+    }
+    return lines;
+}
+function compactWorkspaceLine(workspace, input) {
+    const parts = [displayPath(workspace, input), workspace.machine, workspace.branch ?? '-'];
+    const risks = riskLabels(workspace, input);
+    if (risks.length > 0) {
+        parts.push(risks.join(' '));
+    }
+    return `  ${parts.join('  ')}`;
+}
+export function renderWhere(response, input) {
+    const lines = [];
+    for (const group of response.groups) {
+        if ('features' in group) {
+            if (group.features.length === 0) {
+                continue;
+            }
+            lines.push(`== ${group.label} (${group.features.length}) ==`);
+            for (const feature of group.features) {
+                const pullRequests = feature.pull_requests
+                    .map((pullRequest) => ` PR:${pullRequest.state}`)
+                    .join('');
+                lines.push(`${shortId(feature.id)} ${feature.title}  [${feature.stage}]${pullRequests}`);
+                if (input.expand === true || feature.workspaces.length <= 1) {
+                    for (const workspace of feature.workspaces) {
+                        lines.push(...workspaceLines(workspace, input));
+                    }
+                }
+                else {
+                    lines.push(...compactFeatureLines(feature.workspaces, input));
+                }
+            }
+        }
+        else {
+            if (group.workspaces.length === 0) {
+                continue;
+            }
+            lines.push(`== ${group.label} (${group.workspaces.length}) ==`);
+            for (const workspace of group.workspaces) {
+                if (input.expand === true || group.workspaces.length <= 1) {
+                    lines.push(...workspaceLines(workspace, input));
+                }
+                else {
+                    lines.push(compactWorkspaceLine(workspace, input));
+                }
+            }
+        }
+    }
+    return lines;
+}
+export async function runWhere(options, deps) {
+    const query = {
+        view: options.actions ? 'actions' : 'stage',
+        ...(options.machine !== undefined ? { machine: options.machine } : {}),
+        ...(options.repo !== undefined ? { repo: options.repo } : {}),
+        includeReleased: options.all,
+        includeDone: options.all,
+        includeEnded: options.includeEnded
+    };
+    let response = await deps.client.where(query);
+    const { changed, failedIds } = await syncMissing(collectWorkspaces(response), {
+        localAlias: deps.localAlias,
+        exists: deps.exists,
+        patch: (id, missing) => deps.client.patchWorkspace(id, { missing })
+    });
+    if (changed) {
+        response = await deps.client.where(query);
+    }
+    const input = {
+        localAlias: deps.localAlias,
+        templates: deps.templates,
+        now: deps.now,
+        exists: deps.exists,
+        failedIds,
+        ...(deps.homeDir !== undefined ? { homeDir: deps.homeDir } : {}),
+        ...(options.expand === true ? { expand: true } : {})
+    };
+    return deps.json ? augmentWhere(response, input) : renderWhere(response, input);
+}
+export function registerWhereCommand(program) {
+    const command = usageExit(program
+        .command('where')
+        .description('Show features and workspaces grouped by stage')
+        .option('--actions', 'group by the next action instead of stage')
+        .option('--machine <alias>', 'only workspaces on this machine')
+        .option('--repo <remote>', 'only workspaces of this repo')
+        .option('--all', 'include released and done features')
+        .option('--include-ended', 'include ended sessions')
+        .option('--expand', 'list every workspace instead of a summary per feature')).action(async () => {
+        const opts = command.opts();
+        await runTrackingCommand(command, (context) => runWhere({
+            actions: opts.actions === true,
+            ...(opts.machine !== undefined ? { machine: opts.machine } : {}),
+            ...(opts.repo !== undefined ? { repo: opts.repo } : {}),
+            all: opts.all === true,
+            includeEnded: opts.includeEnded === true,
+            expand: opts.expand === true
+        }, {
+            client: context.client,
+            json: context.json,
+            localAlias: context.config.alias,
+            templates: context.config.resume,
+            now: new Date(),
+            exists: existsSync,
+            homeDir: context.homeDir
+        }));
+    });
+}

package/dist/tracking/workspace-commands.js

@@ -0,0 +1,94 @@
+// cli/src/tracking/workspace-commands.ts: pgm workspace prune.
+import { existsSync } from 'node:fs';
+import { shortId } from '../shared.js';
+import { runTrackingCommand } from './api.js';
+import { isIgnoredPath, usageExit } from './config.js';
+/**
+ * Removes workspace registrations of this machine whose directory is gone
+ * (and, with `ignored`, those under ignore_paths). Features are never touched.
+ */
+export async function runWorkspacePrune(options, deps) {
+    const { workspaces } = await deps.client.listWorkspaces({
+        machine: deps.config.alias
+    });
+    const result = {
+        removed: [],
+        failed: [],
+        dry_run: options.dryRun
+    };
+    for (const workspace of workspaces) {
+        if (workspace.machine !== deps.config.alias) {
+            continue;
+        }
+        let reason = null;
+        if (!deps.exists(workspace.path)) {
+            reason = 'missing';
+        }
+        else if (options.ignored === true &&
+            isIgnoredPath(workspace.path, deps.config.ignorePaths)) {
+            reason = 'ignored';
+        }
+        if (reason === null) {
+            continue;
+        }
+        if (!options.dryRun) {
+            try {
+                await deps.client.deleteWorkspace(workspace.id);
+            }
+            catch (error) {
+                result.failed.push({
+                    id: workspace.id,
+                    path: workspace.path,
+                    error: error instanceof Error ? error.message : 'delete failed'
+                });
+                continue;
+            }
+        }
+        result.removed.push({
+            id: workspace.id,
+            path: workspace.path,
+            feature_id: workspace.feature_id,
+            reason
+        });
+    }
+    return result;
+}
+export function formatPrune(result) {
+    const verb = result.dry_run ? 'would remove' : 'removed';
+    const lines = result.removed.map((entry) => {
+        const feature = entry.feature_id !== null ? ` (feature ${shortId(entry.feature_id)})` : '';
+        return `${verb} ${entry.path} [${entry.reason}]${feature}`;
+    });
+    for (const entry of result.failed) {
+        lines.push(`failed ${entry.path}: ${entry.error}`);
+    }
+    if (lines.length === 0) {
+        lines.push('nothing to prune');
+    }
+    return lines;
+}
+export function registerWorkspaceCommands(program) {
+    const workspace = usageExit(program.command('workspace').description('Manage workspace registrations'));
+    const prune = usageExit(workspace
+        .command('prune')
+        .description('Remove registrations of this machine whose directory is gone (features are kept)')
+        .option('--dry-run', 'show what would be removed without deleting')
+        .option('--ignored', 'also remove registrations that match ignore_paths in ~/.pgmrc'));
+    prune.action(async () => {
+        const opts = prune.opts();
+        await runTrackingCommand(prune, async (context) => {
+            const result = await runWorkspacePrune({
+                dryRun: opts.dryRun === true,
+                ...(opts.ignored === true ? { ignored: true } : {})
+            }, {
+                client: context.client,
+                config: context.config,
+                exists: existsSync
+            });
+            if (result.failed.length > 0) {
+                process.exitCode = 1;
+            }
+            return context.json ? result : formatPrune(result);
+        });
+    });
+}

package/dist/tracking/worktree.js

@@ -0,0 +1,273 @@
+// cli/src/tracking/worktree.ts: pgm worktree new — create a feature worktree.
+import { existsSync } from 'node:fs';
+import { realpath } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { AppError, ErrorCode } from '../errors.js';
+import { readStdinText, shortId } from '../shared.js';
+import { runTrackingCommand } from './api.js';
+import { UsageError, slug, usageExit } from './config.js';
+import { readBootId, resolveLocalWorkspace, runGit, writeMarker } from './local.js';
+const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+const SHORT_ID_RE = /^[0-9a-f]{8}$/;
+const GIT_TIMEOUT_MS = 10_000;
+export function taskTitle(content) {
+    const first = (content ?? '').split('\n')[0] ?? '';
+    return first.trim().slice(0, 80);
+}
+export function matchFeature(arg, tasks) {
+    if (UUID_RE.test(arg)) {
+        return tasks.filter((task) => task.id === arg);
+    }
+    if (SHORT_ID_RE.test(arg)) {
+        return tasks.filter((task) => task.id.startsWith(arg));
+    }
+    const title = arg.trim().toLowerCase();
+    return tasks.filter((task) => task.isFeature && task.title.toLowerCase() === title);
+}
+export async function listTaskSummaries(listTasks) {
+    const summaries = [];
+    for (let offset = 0;; offset += 100) {
+        const page = await listTasks({ limit: 100, offset });
+        for (const item of page.items) {
+            summaries.push({
+                id: item.id,
+                title: taskTitle(item.content),
+                isFeature: item.metadata.kind === 'feature'
+            });
+        }
+        if (offset + 100 >= page.total) {
+            break;
+        }
+    }
+    return summaries;
+}
+export async function runWorktreeNew(feature, options, deps) {
+    const git = (args) => deps.run(args, { cwd: deps.cwd, timeoutMs: GIT_TIMEOUT_MS });
+    const toplevel = await git(['rev-parse', '--show-toplevel']);
+    if (toplevel.ok === false) {
+        throw new AppError(ErrorCode.VALIDATION, 'not in a git repository');
+    }
+    const commonDir = await git([
+        'rev-parse',
+        '--path-format=absolute',
+        '--git-common-dir'
+    ]);
+    if (commonDir.ok === false) {
+        throw new AppError(ErrorCode.INTERNAL, 'could not determine the git common dir');
+    }
+    const repoRoot = path.dirname(commonDir.stdout);
+    const tasks = await listTaskSummaries(deps.listTasks);
+    const matches = matchFeature(feature, tasks);
+    if (matches.length > 1) {
+        for (const task of matches) {
+            deps.warn(`${shortId(task.id)} ${task.title}`);
+        }
+        throw new AppError(ErrorCode.CONFLICT, `multiple features match '${feature}'`);
+    }
+    let featureId;
+    let title;
+    if (matches.length === 1) {
+        const match = matches[0];
+        if (match === undefined) {
+            throw new AppError(ErrorCode.INTERNAL, 'no matching feature');
+        }
+        featureId = match.id;
+        title = match.title;
+    }
+    else {
+        if (!options.create) {
+            const confirmed = await deps.confirm(`Create feature "${feature}"?`);
+            if (!confirmed) {
+                throw new AppError(ErrorCode.NOT_FOUND, `no feature matches '${feature}'`);
+            }
+        }
+        const created = await deps.client.createFeature({ content: feature });
+        featureId = created.entity.id;
+        title = taskTitle(feature);
+    }
+    const short = shortId(featureId);
+    const name = slug(title);
+    const branch = `feat/${short}-${name}`;
+    const worktreePath = options.path !== undefined
+        ? path.resolve(deps.cwd, options.path)
+        : path.join(deps.config.worktreeRoot ?? `${repoRoot}.worktrees`, `${short}-${name}`);
+    if (deps.exists(worktreePath)) {
+        throw new UsageError(`worktree path already exists: ${worktreePath}`);
+    }
+    const branchExists = await git([
+        'rev-parse',
+        '--verify',
+        '--quiet',
+        `refs/heads/${branch}`
+    ]);
+    if (branchExists.ok) {
+        throw new UsageError(`branch already exists: ${branch}`);
+    }
+    const originHead = await git([
+        'rev-parse',
+        '--verify',
+        '--quiet',
+        'refs/remotes/origin/HEAD'
+    ]);
+    const base = options.base ?? (originHead.ok ? 'origin/HEAD' : 'HEAD');
+    const add = await git([
+        'worktree',
+        'add',
+        '-b',
+        branch,
+        worktreePath,
+        base
+    ]);
+    if (add.ok === false) {
+        throw new AppError(ErrorCode.INTERNAL, `git worktree add failed${add.timedOut ? ' (timed out)' : ''} (branch: ${branch}, base: ${base})`);
+    }
+    await deps.writeMarker(worktreePath, featureId);
+    const local = await deps.resolveWorkspace(worktreePath);
+    if (local.kind === 'timeout') {
+        deps.warn('git timed out; skipping the workspace report');
+    }
+    else {
+        try {
+            await deps.client.report({
+                source: 'hook',
+                machine: {
+                    alias: deps.config.alias,
+                    hostname: deps.hostname,
+                    boot_id: await deps.bootId()
+                },
+                workspace: local.workspace,
+                feature_id: featureId
+            });
+        }
+        catch (error) {
+            deps.warn(`report failed: ${error instanceof Error ? error.message : 'unknown error'}`);
+        }
+    }
+    return [worktreePath];
+}
+function plural(count, noun) {
+    return `${count} ${noun}${count === 1 ? '' : 's'}`;
+}
+/**
+ * Removes a linked worktree only when nothing would be lost: no changed files
+ * and no commits that no remote has. There is no force flag and `git worktree
+ * remove` runs without --force. The workspace registration goes afterwards.
+ */
+export async function runWorktreeRemove(target, deps) {
+    const abs = path.resolve(deps.cwd, target);
+    if (!deps.exists(abs)) {
+        throw new UsageError(`no such directory: ${abs}`);
+    }
+    const local = await deps.resolveWorkspace(abs);
+    if (local.kind === 'timeout') {
+        throw new AppError(ErrorCode.INTERNAL, 'git timed out reading the worktree state; nothing was removed');
+    }
+    if (local.repoRoot === null) {
+        throw new UsageError(`not a git worktree: ${abs}`);
+    }
+    if (local.path !== (await deps.realpath(abs))) {
+        throw new UsageError(`not the root of a worktree: pass ${local.path} instead of ${abs}`);
+    }
+    if (local.repoRoot === local.path) {
+        throw new UsageError(`refusing to remove the main working tree: ${local.path}`);
+    }
+    const git = local.workspace.git ?? null;
+    const reasons = [];
+    if (git === null) {
+        reasons.push('git state is unknown');
+    }
+    else {
+        if (git.dirty_count > 0) {
+            reasons.push(plural(git.dirty_count, 'changed file'));
+        }
+        if (git.unpushed_count > 0) {
+            reasons.push(`${plural(git.unpushed_count, 'unpushed commit')}${git.has_upstream ? '' : ' (no upstream; no remote has them)'}`);
+        }
+    }
+    if (reasons.length > 0) {
+        throw new AppError(ErrorCode.CONFLICT, `refusing to remove ${local.path}: ${reasons.join(', ')}`);
+    }
+    const commonDir = await deps.run(['rev-parse', '--path-format=absolute', '--git-common-dir'], { cwd: local.path, timeoutMs: GIT_TIMEOUT_MS });
+    if (commonDir.ok === false) {
+        throw new AppError(ErrorCode.INTERNAL, 'could not determine the git common dir');
+    }
+    const removed = await deps.run(['--git-dir', commonDir.stdout, 'worktree', 'remove', local.path], { cwd: local.repoRoot, timeoutMs: GIT_TIMEOUT_MS });
+    if (removed.ok === false) {
+        throw new AppError(ErrorCode.INTERNAL, `git worktree remove failed${removed.timedOut ? ' (timed out)' : ''}; nothing was unregistered`);
+    }
+    let unregistered = false;
+    try {
+        const looked = await deps.client.lookup(deps.config.alias, local.path);
+        if (looked.workspace !== null && looked.workspace.path === local.path) {
+            await deps.client.deleteWorkspace(looked.workspace.id);
+            unregistered = true;
+        }
+    }
+    catch (error) {
+        deps.warn(`worktree removed, but unregistering failed: ${error instanceof Error ? error.message : 'unknown error'}; run \`pgm workspace prune\` later`);
+    }
+    return { path: local.path, removed: true, unregistered };
+}
+async function promptConfirm(question) {
+    process.stderr.write(`${question} [y/N] `);
+    const answer = (await readStdinText()).trim().toLowerCase();
+    return answer === 'y' || answer === 'yes';
+}
+export function registerWorktreeCommand(program) {
+    const worktree = usageExit(program
+        .command('worktree')
+        .description('Manage feature worktrees'));
+    const newCommand = usageExit(worktree
+        .command('new <feature>')
+        .description('Create a worktree for a feature (creating it with --create or when confirmed)')
+        .option('--base <ref>', 'base ref for the new branch (default: origin/HEAD or HEAD)')
+        .option('--path <dir>', 'worktree path (default: <worktree_root>/<8-hex>-<slug>)')
+        .option('--create', 'create the feature when it does not exist'));
+    const removeCommand = usageExit(worktree
+        .command('rm <path>')
+        .description('Remove a clean worktree and unregister it. Refuses when there are changed files or unpushed commits; there is no force flag'));
+    removeCommand.action(async (target) => {
+        await runTrackingCommand(removeCommand, async (context) => {
+            const result = await runWorktreeRemove(target, {
+                client: context.client,
+                config: context.config,
+                cwd: process.cwd(),
+                run: runGit,
+                exists: existsSync,
+                realpath: (p) => realpath(p),
+                resolveWorkspace: (cwd) => resolveLocalWorkspace(cwd, { budgetMs: 5000 }),
+                warn: (line) => process.stderr.write(`${line}\n`)
+            });
+            return context.json
+                ? result
+                : [
+                    `removed ${result.path}${result.unregistered ? ' and unregistered the workspace' : ''}`
+                ];
+        });
+    });
+    newCommand.action(async (feature) => {
+        const opts = newCommand.opts();
+        await runTrackingCommand(newCommand, async (context) => {
+            const paths = await runWorktreeNew(feature, {
+                create: opts.create === true,
+                ...(opts.base !== undefined ? { base: opts.base } : {}),
+                ...(opts.path !== undefined ? { path: opts.path } : {})
+            }, {
+                client: context.client,
+                config: context.config,
+                cwd: process.cwd(),
+                hostname: os.hostname(),
+                listTasks: (input) => context.pgm.listTasks(input),
+                run: runGit,
+                exists: existsSync,
+                confirm: promptConfirm,
+                bootId: readBootId,
+                resolveWorkspace: (cwd) => resolveLocalWorkspace(cwd),
+                writeMarker,
+                warn: (line) => process.stderr.write(`${line}\n`)
+            });
+            return context.json ? { path: paths[0] ?? '' } : paths;
+        });
+    });
+}