@phnx-labs/agents-cli 1.20.57 → 1.20.59

package/dist/lib/git.d.ts

@@ -107,6 +107,15 @@ export declare function isGitRepo(dir: string): boolean;
  * {@link isGitRepo} above). Throws if `dir` is not inside a git repository.
  */
 export declare function getGitRoot(dir: string): Promise<string>;
+/**
+ * Return the absolute path to the **main** working-tree root for `dir`.
+ *
+ * Unlike {@link getGitRoot}, this stays correct when `dir` is inside a *linked*
+ * worktree: `--show-toplevel` there returns the worktree's own path, but the
+ * common git dir (`--git-common-dir`) always points at the primary repo's
+ * `.git`, whose parent is the main checkout. Throws if `dir` is not in a repo.
+ */
+export declare function getMainRepoRoot(dir: string): Promise<string>;
 /**
  * Initialize a git repo in an existing directory.
  */

package/dist/lib/git.js

@@ -427,6 +427,18 @@ export async function getGitRoot(dir) {
     const root = await simpleGit(dir).revparse(['--show-toplevel']);
     return root.trim();
 }
+/**
+ * Return the absolute path to the **main** working-tree root for `dir`.
+ *
+ * Unlike {@link getGitRoot}, this stays correct when `dir` is inside a *linked*
+ * worktree: `--show-toplevel` there returns the worktree's own path, but the
+ * common git dir (`--git-common-dir`) always points at the primary repo's
+ * `.git`, whose parent is the main checkout. Throws if `dir` is not in a repo.
+ */
+export async function getMainRepoRoot(dir) {
+    const common = await simpleGit(dir).raw(['rev-parse', '--path-format=absolute', '--git-common-dir']);
+    return path.dirname(common.trim());
+}
 /**
  * Initialize a git repo in an existing directory.
  */

package/dist/lib/hosts/dispatch.d.ts

@@ -10,11 +10,32 @@
  */
 import type { Host } from './types.js';
 import { type HostTask } from './tasks.js';
+/**
+ * Build a `cd <dir> && ` prefix that resolves on the REMOTE host.
+ *
+ * A `~`/`$HOME`-anchored path must resolve against the REMOTE user's home, not
+ * the local one (`/home/<me>` vs `/Users/<me>`). We emit an unquoted `"$HOME"`
+ * for that segment — the remote login shell expands it — and shell-quote the
+ * remainder. Any other path (absolute or relative) is quoted verbatim.
+ */
+export declare function remoteCdPrefix(remoteCwd?: string): string;
+/**
+ * Launch a detached login-shell command in its own Unix session/process group.
+ *
+ * Node is already a hard requirement for a host that can run `agents`. Its
+ * `detached: true` contract calls setsid(2) on Unix, unlike `nohup ... &` under
+ * a non-interactive shell where the background wrapper can remain in the SSH
+ * shell's process group. Returning the group leader PID makes `kill(-pid)` a
+ * reliable whole-tree operation for both normal stops and rollback cleanup.
+ */
+export declare function buildDetachedLaunchCommand(inner: string): string;
 export interface DispatchResult {
     task: HostTask;
     /** Exit code when followed; undefined when detached (--no-follow). */
     exitCode?: number;
 }
+/** Terminate a detached dispatch that its caller could not persist locally. */
+export declare function terminateDispatchedTask(task: HostTask): void;
 export interface DispatchOptions {
     agent: string;
     prompt: string;

package/dist/lib/hosts/dispatch.js

@@ -20,6 +20,77 @@ import { followHostTask } from './progress.js';
 // regardless of the run's cwd. Task ids are 8 hex chars, so these paths are
 // injection-safe to interpolate unquoted into remote commands.
 const REMOTE_DIR = '$HOME/.agents/.cache/hosts';
+/**
+ * If `p` is anchored at the home dir — a leading `~` or `$HOME` — return the
+ * remainder (no leading slash), else null. Callers that want a local-home
+ * absolute (`/Users/<me>/x`, from a shell-expanded `--cwd ~/x`) re-rooted at the
+ * remote home normalize it to `~/x` first (`toRemotePortable`); explicit
+ * `--remote-cwd` is left literal and so is never re-rooted here.
+ */
+function homeRemainder(p) {
+    if (p === '~' || p === '$HOME')
+        return '';
+    if (p.startsWith('~/'))
+        return p.slice(2);
+    if (p.startsWith('$HOME/'))
+        return p.slice(6);
+    return null;
+}
+/**
+ * Build a `cd <dir> && ` prefix that resolves on the REMOTE host.
+ *
+ * A `~`/`$HOME`-anchored path must resolve against the REMOTE user's home, not
+ * the local one (`/home/<me>` vs `/Users/<me>`). We emit an unquoted `"$HOME"`
+ * for that segment — the remote login shell expands it — and shell-quote the
+ * remainder. Any other path (absolute or relative) is quoted verbatim.
+ */
+export function remoteCdPrefix(remoteCwd) {
+    if (!remoteCwd)
+        return '';
+    const rest = homeRemainder(remoteCwd);
+    if (rest === '')
+        return 'cd "$HOME" && ';
+    if (rest !== null)
+        return `cd "$HOME"/${shellQuote(rest)} && `;
+    return `cd ${shellQuote(remoteCwd)} && `;
+}
+/**
+ * Launch a detached login-shell command in its own Unix session/process group.
+ *
+ * Node is already a hard requirement for a host that can run `agents`. Its
+ * `detached: true` contract calls setsid(2) on Unix, unlike `nohup ... &` under
+ * a non-interactive shell where the background wrapper can remain in the SSH
+ * shell's process group. Returning the group leader PID makes `kill(-pid)` a
+ * reliable whole-tree operation for both normal stops and rollback cleanup.
+ */
+export function buildDetachedLaunchCommand(inner) {
+    const nodeScript = [
+        "const { spawn } = require('node:child_process');",
+        `const child = spawn('/bin/bash', ['-lc', ${JSON.stringify(inner)}], { detached: true, stdio: 'ignore' });`,
+        "child.once('error', error => { console.error(error.message); process.exitCode = 1; });",
+        "child.once('spawn', () => { console.log(child.pid); child.unref(); });",
+    ].join(' ');
+    return `bash -lc ${shellQuote(`node -e ${shellQuote(nodeScript)}`)}`;
+}
+function terminateRemoteLaunch(task) {
+    if (!task.pid)
+        throw new Error(`Cannot terminate remote task ${task.id}: launch returned no PID.`);
+    const pid = task.pid;
+    const command = `if kill -TERM -- -${pid} 2>/dev/null; then ` +
+        `sleep 1; kill -KILL -- -${pid} 2>/dev/null || true; ` +
+        `elif kill -0 -- -${pid} 2>/dev/null; then exit 1; fi; ` +
+        `rm -f ${task.remoteLog} ${task.remoteExit}`;
+    const result = sshExec(task.target, command, { timeoutMs: 10000, multiplex: true });
+    if (result.code !== 0) {
+        throw new Error(`Failed to terminate remote task ${task.id} on ${task.host}: ` +
+            `${(result.stderr || result.stdout).trim() || 'ssh error'}`);
+    }
+}
+/** Terminate a detached dispatch that its caller could not persist locally. */
+export function terminateDispatchedTask(task) {
+    terminateRemoteLaunch(task);
+    updateTask(task.id, terminalPatch(143));
+}
 /**
  * The launch + task-record + optional follow core. Both `dispatchToHost` (run)
  * and `dispatchAgentsCommand` (teams) build their `forwardedArgs` and call here,
@@ -45,10 +116,11 @@ async function launchDetached(host, target, opts) {
     const remoteExit = `${REMOTE_DIR}/${id}.exit`;
     // Inner command run under a login shell so PATH resolves `agents`.
     const invocation = ['agents', ...opts.forwardedArgs].map(shellQuote).join(' ');
-    const cwd = opts.remoteCwd ? `cd ${shellQuote(opts.remoteCwd)} && ` : '';
+    const cwd = remoteCdPrefix(opts.remoteCwd);
     const inner = `${cwd}${invocation} > ${remoteLog} 2>&1; echo $? > ${remoteExit}`;
-    // Outer: ensure dir, launch detached under bash -lc, print the PID.
-    const launch = `mkdir -p ${REMOTE_DIR}; nohup bash -lc ${shellQuote(inner)} >/dev/null 2>&1 & echo $!`;
+    // Outer: ensure dir, launch the login-shell wrapper as a new process-group
+    // leader, and print that leader PID.
+    const launch = `mkdir -p ${REMOTE_DIR}; ${buildDetachedLaunchCommand(inner)}`;
     const res = sshExec(target, launch, { timeoutMs: 30000, multiplex: true });
     if (res.code !== 0) {
         throw new Error(`Failed to launch on "${host.name}": ${(res.stderr || res.stdout).trim() || 'ssh error'}`);
@@ -68,7 +140,18 @@ async function launchDetached(host, target, opts) {
         status: 'running',
         createdAt: new Date().toISOString(),
     };
-    saveTask(task);
+    try {
+        saveTask(task);
+    }
+    catch (err) {
+        try {
+            terminateRemoteLaunch(task);
+        }
+        catch (cleanupErr) {
+            throw new Error(`Failed to persist remote task ${task.id}; cleanup also failed: ${cleanupErr.message}`, { cause: err });
+        }
+        throw err;
+    }
     if (opts.follow === false) {
         return { task };
     }
@@ -146,7 +229,7 @@ export async function runInteractiveOnHost(host, opts) {
     for (const w of warnings)
         process.stderr.write(`[hosts] warning: ${w}\n`);
     const invocation = ['agents', ...buildInteractiveRunForwardedArgs(opts)].map(shellQuote).join(' ');
-    const cwd = opts.remoteCwd ? `cd ${shellQuote(opts.remoteCwd)} && ` : '';
+    const cwd = remoteCdPrefix(opts.remoteCwd);
     const remoteCmd = `${cwd}${invocation}`;
     return sshStream(target, remoteCmd, { tty: process.stdin.isTTY, multiplex: true });
 }

package/dist/lib/hosts/passthrough.js

@@ -28,6 +28,7 @@ const REMOTE_PASSTHROUGH = {
     view: {},
     usage: {},
     cost: {},
+    output: {},
     doctor: {},
     inspect: {},
     list: {},

package/dist/lib/mcp.js

@@ -485,7 +485,7 @@ function installMcpToForgeConfig(server, versionHome) {
     fs.writeFileSync(configPath, JSON.stringify(config, null, 2), 'utf-8');
 }
 function installMcpToOpenCodeConfig(server, versionHome) {
-    const configPath = path.join(versionHome, '.opencode', 'opencode.jsonc');
+    const configPath = path.join(versionHome, '.config', 'opencode', 'opencode.jsonc');
     let config = {};
     if (fs.existsSync(configPath)) {
         const content = fs.readFileSync(configPath, 'utf-8');

package/dist/lib/output/git-output.d.ts

@@ -0,0 +1,74 @@
+/** Commit tally for one author email. */
+export interface AuthorCommits {
+    author: string;
+    commits: number;
+}
+/** The shipped-work rollup for a window. */
+export interface GitOutputSummary {
+    reposScanned: number;
+    commits: number;
+    byAuthor: AuthorCommits[];
+    prsOpened: number;
+    prsMerged: number;
+    /**
+     * Deduped commit SHAs authored by us in the window. Carried so `--all-hosts`
+     * can UNION across machines — a repo cloned on several boxes exposes the same
+     * commits to `git log` on each, so summing counts would multi-count.
+     */
+    commitShas: string[];
+    /** false when `gh` is missing/unauthed — PR counts are then 0 and not trustworthy. */
+    ghAvailable: boolean;
+    /** Author emails counted as "ours". */
+    authors: string[];
+    /** gh logins queried for PRs. */
+    logins: string[];
+    sinceIso: string;
+}
+export interface GitOutputOptions {
+    /** Root scanned for git repos (e.g. ~/src). */
+    reposDir: string;
+    /** Window start, epoch ms. */
+    sinceMs: number;
+    /** Restrict commit authorship to these emails; default: identities discovered from git config. */
+    authors?: string[];
+    /** gh logins to search PRs for; default: the current `gh api user` login. */
+    logins?: string[];
+    /** Repo discovery depth below reposDir (default 4 — covers ~/src/host/org/repo). */
+    maxDepth?: number;
+    /** Query PRs via gh (default true). */
+    includePrs?: boolean;
+}
+/**
+ * Find git repositories under `root` up to `maxDepth` levels deep. A directory
+ * with a `.git` entry is a repo and is NOT descended into (so nested worktrees
+ * / submodules don't double-count).
+ */
+export declare function findGitRepos(root: string, maxDepth?: number): string[];
+/**
+ * Count commits by our authors across all repos, deduped by SHA (so the same
+ * commit reachable via multiple repo clones/worktrees on this machine — or, at
+ * the fleet layer, across machines — is counted once), tallied per email.
+ */
+export declare function collectCommits(repos: string[], sinceIso: string, authors: string[]): Promise<{
+    total: number;
+    byAuthor: AuthorCommits[];
+    shas: string[];
+}>;
+/**
+ * Count PRs opened and merged in the window across the given logins. `gh search
+ * prs` searches all of GitHub, so one authed gh can cover multiple accounts'
+ * logins. Returns ghAvailable=false if gh can't be reached at all.
+ */
+export declare function collectPrs(logins: string[], sinceDate: string): Promise<{
+    opened: number;
+    merged: number;
+    logins: string[];
+    ghAvailable: boolean;
+}>;
+/** Format an epoch-ms as a YYYY-MM-DD date (UTC), for gh's date-range search. */
+export declare function toSearchDate(ms: number): string;
+/**
+ * Collect the full shipped-work summary for a window: commits (across accounts)
+ * plus PRs opened/merged.
+ */
+export declare function collectGitOutput(options: GitOutputOptions): Promise<GitOutputSummary>;

package/dist/lib/output/git-output.js

@@ -0,0 +1,213 @@
+/**
+ * Git / GitHub "output" collector — the shipped-work half of `agents output`.
+ *
+ * `agents cost` answers "what did we burn?"; this answers "what did we ship?".
+ * It counts commits (across every author identity, so multi-account totals stay
+ * correct regardless of which `gh` login is active) and PRs opened / merged in a
+ * time window. Pure `git`/`gh` over child_process — no server, no telemetry,
+ * mirroring the offline spirit of the cost rollup.
+ */
+import { execFile } from 'child_process';
+import { promisify } from 'util';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+const execFileAsync = promisify(execFile);
+/** Directory names never descended into during repo discovery. */
+const SKIP_DIRS = new Set(['node_modules', '.git', '.agents', '.worktrees', 'dist', 'build', '.next', '.cache']);
+/**
+ * Find git repositories under `root` up to `maxDepth` levels deep. A directory
+ * with a `.git` entry is a repo and is NOT descended into (so nested worktrees
+ * / submodules don't double-count).
+ */
+export function findGitRepos(root, maxDepth = 4) {
+    const repos = [];
+    const walk = (dir, depth) => {
+        let entries;
+        try {
+            entries = fs.readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            return; // unreadable dir — skip
+        }
+        if (entries.some(e => e.name === '.git')) {
+            repos.push(dir);
+            return; // don't descend into a repo
+        }
+        if (depth >= maxDepth)
+            return;
+        for (const e of entries) {
+            if (!e.isDirectory() || e.name.startsWith('.') || SKIP_DIRS.has(e.name))
+                continue;
+            walk(path.join(dir, e.name), depth + 1);
+        }
+    };
+    walk(root, 0);
+    return repos;
+}
+/** git log for one repo (SHA + author email per commit), tolerant of empty/broken repos. */
+async function repoLog(repoDir, sinceIso) {
+    try {
+        const { stdout } = await execFileAsync('git', ['-C', repoDir, 'log', '--all', '--no-merges', `--since=${sinceIso}`, '--pretty=format:%H%x09%ae'], { maxBuffer: 64 * 1024 * 1024 });
+        const refs = [];
+        for (const line of stdout.split('\n')) {
+            const tab = line.indexOf('\t');
+            if (tab < 0)
+                continue;
+            refs.push({ sha: line.slice(0, tab).trim(), email: line.slice(tab + 1).trim() });
+        }
+        return refs;
+    }
+    catch {
+        return []; // no commits yet / not a real repo / detached weirdness
+    }
+}
+/**
+ * Discover the user's own author emails so commit counts exclude teammates.
+ * Union of `git config --global user.email` and each repo's local `user.email`.
+ */
+async function discoverAuthorEmails(repos) {
+    const emails = new Set();
+    try {
+        const { stdout } = await execFileAsync('git', ['config', '--global', 'user.email']);
+        const e = stdout.trim();
+        if (e)
+            emails.add(e.toLowerCase());
+    }
+    catch {
+        /* no global identity */
+    }
+    await Promise.all(repos.map(async (repo) => {
+        try {
+            const { stdout } = await execFileAsync('git', ['-C', repo, 'config', '--get', 'user.email']);
+            const e = stdout.trim();
+            if (e)
+                emails.add(e.toLowerCase());
+        }
+        catch {
+            /* repo has no local identity */
+        }
+    }));
+    return [...emails];
+}
+/**
+ * Count commits by our authors across all repos, deduped by SHA (so the same
+ * commit reachable via multiple repo clones/worktrees on this machine — or, at
+ * the fleet layer, across machines — is counted once), tallied per email.
+ */
+export async function collectCommits(repos, sinceIso, authors) {
+    const ours = new Set(authors.map(a => a.toLowerCase()));
+    const tally = new Map();
+    const seen = new Set();
+    const logs = await Promise.all(repos.map(r => repoLog(r, sinceIso)));
+    for (const refs of logs) {
+        for (const { sha, email } of refs) {
+            const key = email.toLowerCase();
+            if (ours.size > 0 && !ours.has(key))
+                continue;
+            if (seen.has(sha))
+                continue; // same commit seen via another clone/ref
+            seen.add(sha);
+            tally.set(key, (tally.get(key) ?? 0) + 1);
+        }
+    }
+    const byAuthor = [...tally.entries()]
+        .map(([author, commits]) => ({ author, commits }))
+        .sort((a, b) => b.commits - a.commits);
+    return { total: seen.size, byAuthor, shas: [...seen] };
+}
+/** Resolve the current gh login, or null if gh is unavailable/unauthed. */
+async function currentGhLogin() {
+    try {
+        const { stdout } = await execFileAsync('gh', ['api', 'user', '--jq', '.login']);
+        const login = stdout.trim();
+        return login || null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Count PRs matching a gh search query (author + date), returning null on failure. */
+async function ghSearchCount(args) {
+    try {
+        const { stdout } = await execFileAsync('gh', [...args, '--limit', '1000', '--json', 'number'], {
+            maxBuffer: 32 * 1024 * 1024,
+        });
+        const rows = JSON.parse(stdout);
+        return Array.isArray(rows) ? rows.length : 0;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Count PRs opened and merged in the window across the given logins. `gh search
+ * prs` searches all of GitHub, so one authed gh can cover multiple accounts'
+ * logins. Returns ghAvailable=false if gh can't be reached at all.
+ */
+export async function collectPrs(logins, sinceDate) {
+    let resolved = logins;
+    if (resolved.length === 0) {
+        const login = await currentGhLogin();
+        if (!login)
+            return { opened: 0, merged: 0, logins: [], ghAvailable: false };
+        resolved = [login];
+    }
+    let opened = 0;
+    let merged = 0;
+    let anyOk = false;
+    for (const login of resolved) {
+        const o = await ghSearchCount(['search', 'prs', '--author', login, '--created', `>=${sinceDate}`]);
+        const m = await ghSearchCount(['search', 'prs', '--author', login, '--merged', `>=${sinceDate}`]);
+        if (o !== null) {
+            opened += o;
+            anyOk = true;
+        }
+        if (m !== null) {
+            merged += m;
+            anyOk = true;
+        }
+    }
+    return { opened, merged, logins: resolved, ghAvailable: anyOk };
+}
+/** Format an epoch-ms as a YYYY-MM-DD date (UTC), for gh's date-range search. */
+export function toSearchDate(ms) {
+    return new Date(ms).toISOString().slice(0, 10);
+}
+/**
+ * Collect the full shipped-work summary for a window: commits (across accounts)
+ * plus PRs opened/merged.
+ */
+export async function collectGitOutput(options) {
+    const reposDir = options.reposDir.replace(/^~(?=$|\/)/, os.homedir());
+    const sinceIso = new Date(options.sinceMs).toISOString();
+    const sinceDate = toSearchDate(options.sinceMs);
+    const repos = findGitRepos(reposDir, options.maxDepth ?? 4);
+    const authors = options.authors && options.authors.length > 0
+        ? options.authors.map(a => a.toLowerCase())
+        : await discoverAuthorEmails(repos);
+    const { total: commits, byAuthor, shas: commitShas } = await collectCommits(repos, sinceIso, authors);
+    let prsOpened = 0;
+    let prsMerged = 0;
+    let ghAvailable = false;
+    let logins = options.logins ?? [];
+    if (options.includePrs !== false) {
+        const prs = await collectPrs(logins, sinceDate);
+        prsOpened = prs.opened;
+        prsMerged = prs.merged;
+        ghAvailable = prs.ghAvailable;
+        logins = prs.logins;
+    }
+    return {
+        reposScanned: repos.length,
+        commits,
+        byAuthor,
+        commitShas,
+        prsOpened,
+        prsMerged,
+        ghAvailable,
+        authors,
+        logins,
+        sinceIso,
+    };
+}

package/dist/lib/permissions.d.ts

@@ -1,4 +1,4 @@
-import type { AgentId, PermissionSet, InstalledPermission, ClaudePermissions, OpenCodePermissions, CodexPermissions } from './types.js';
+import type { AgentId, PermissionSet, InstalledPermission, ClaudePermissions, CursorPermissions, OpenCodePermissions, CodexPermissions } from './types.js';
 /** Filename used for Codex Starlark deny-rules generated from permission groups. */
 export declare const CODEX_RULES_FILENAME = "agents-deny.rules";
 export type ParsedRules = PermissionSet;
@@ -99,6 +99,11 @@ export declare function removePermissionSet(name: string): {
  * Claude uses: { permissions: { allow: ["Bash(*)", "Read(**)"], deny: [] } }
  */
 export declare function convertToClaudeFormat(set: PermissionSet): ClaudePermissions;
+/**
+ * Convert canonical permission set to Cursor CLI format
+ * (`~/.cursor/cli-config.json` permissions.allow/deny).
+ */
+export declare function convertToCursorFormat(set: PermissionSet): CursorPermissions;
 /**
  * Convert canonical permission set to Gemini format.
  * Gemini reads tool allow-lists from settings.json under `tools.allowed`.
@@ -112,6 +117,11 @@ export declare function convertToGeminiFormat(set: PermissionSet): {
         allowed: string[];
     };
 };
+/** Convert canonical Bash rules into Droid's command arrays. */
+export declare function convertToDroidFormat(set: PermissionSet): {
+    commandAllowlist: string[];
+    commandDenylist: string[];
+};
 /**
  * Convert canonical permission set to Antigravity format.
  * Antigravity reads ~/.gemini/antigravity-cli/settings.json with
@@ -152,6 +162,19 @@ export type KimiRule = {
     decision: 'allow' | 'deny';
     pattern: string;
 };
+export type KiroRule = {
+    capability: string;
+    effect: 'allow' | 'deny';
+    match?: string[];
+    exclude?: string[];
+};
+/**
+ * Convert canonical permissions to Kiro CLI v3 capability rules.
+ * Kiro stores these rules in ~/.kiro/settings/permissions.yaml.
+ */
+export declare function convertToKiroFormat(set: PermissionSet): {
+    rules: KiroRule[];
+};
 /**
  * Convert a canonical permission set to Kimi Code's `[permission].rules` format.
  * Kimi (`~/.kimi-code/config.toml`) reads rules of the form
@@ -194,6 +217,13 @@ export declare function applyClaudePermissions(set: PermissionSet, scope?: 'user
     success: boolean;
     error?: string;
 };
+/**
+ * Path OpenCode actually loads for global config:
+ *   ~/.config/opencode/opencode.jsonc  (or .json)
+ * Project: <cwd>/opencode.jsonc (or .json) at project root — not .opencode/.
+ * See https://opencode.ai/docs/config/
+ */
+export declare function openCodeConfigPath(scope: 'user' | 'project', cwd?: string, home?: string): string;
 /**
  * Apply a permission set to a specific version's home directory.
  * This writes to {versionHome}/.{agent}/settings.json (or equivalent).