@phnx-labs/agents-cli 1.20.71 → 1.20.73

package/dist/commands/logs.js

@@ -23,9 +23,9 @@
 import chalk from 'chalk';
 import * as fs from 'fs';
 import { discoverSessions, resolveSessionById } from '../lib/session/discover.js';
-import { parseAgentFilter, renderSessionLog } from './sessions.js';
+import { parseAgentFilter, renderSessionLog, renderSessionLogJson } from './sessions.js';
 import { streamSessionTail, isTailable } from './sessions-tail.js';
-import { showHostTaskLog } from '../lib/hosts/logs.js';
+import { showHostTaskLog, hostTaskLogJson } from '../lib/hosts/logs.js';
 import { listTasks } from '../lib/hosts/tasks.js';
 import { itemPicker } from '../lib/picker.js';
 import { query, stats, getLogsPath, rotate, levelFor, } from '../lib/events.js';
@@ -43,29 +43,57 @@ function candidateLabel(c) {
     const title = s.label || s.topic || '';
     return `${chalk.gray('sess')} ${s.shortId.padEnd(9)} ${(s.agent + ver).padEnd(14)} ${chalk.gray(s.timestamp.slice(0, 16))}  ${title.slice(0, 40)}`;
 }
+/** Emit a host-dispatch task's log as JSON: `{ kind, task, log }`. */
+function emitHostTaskJson(id) {
+    const hj = hostTaskLogJson(id);
+    if (!hj.found)
+        return false;
+    process.stdout.write(JSON.stringify({ kind: 'task', task: hj.task, log: hj.log ?? null }, null, 2) + '\n');
+    return true;
+}
 /** Show a resolved session — follow (tail), concise summary, or (`full`) transcript. */
-async function showSession(session, follow, full) {
+async function showSession(session, follow, full, json = false) {
+    if (json) {
+        await renderSessionLogJson(session);
+        return;
+    }
     if (follow) {
         if (!isTailable(session.agent)) {
             console.error(chalk.red(`Tailing is supported for claude and codex sessions only (got ${session.agent}).`));
             process.exit(2);
         }
-        await streamSessionTail(session, {});
+        await streamSessionTail(session, { raw: full });
         return;
     }
     await renderSessionLog(session, full ? 'markdown' : 'summary');
 }
-async function showCandidate(c, follow, full) {
+async function showCandidate(c, follow, full, json = false) {
     if (c.kind === 'task') {
+        if (json) {
+            emitHostTaskJson(c.task.id);
+            return;
+        }
         const res = await showHostTaskLog(c.task.id, follow, full);
         if (res.exitCode !== undefined)
             process.exitCode = res.exitCode;
         return;
     }
-    await showSession(c.session, follow, full);
+    await showSession(c.session, follow, full, json);
 }
 /** Resolve an explicit id/--session: host task first, then a session. */
-async function showById(id, follow, full) {
+async function showById(id, follow, full, json = false) {
+    if (json) {
+        if (emitHostTaskJson(id))
+            return;
+        const sessions = await discoverSessions({ all: true, limit: 5000 });
+        const matches = resolveSessionById(sessions, id);
+        if (matches.length === 0) {
+            console.error(chalk.red(`No run or session found matching "${id}".`));
+            process.exit(1);
+        }
+        await renderSessionLogJson(matches[0]);
+        return;
+    }
     const hostRes = await showHostTaskLog(id, follow, full);
     if (hostRes.found) {
         if (hostRes.exitCode !== undefined)
@@ -85,7 +113,7 @@ async function runLogs(id, opts) {
     const full = !!opts.full;
     const directId = opts.session ?? id;
     if (directId) {
-        await showById(directId, follow, full);
+        await showById(directId, follow, full, !!opts.json);
         return;
     }
     const { agent, version } = parseAgentFilter(opts.agent);
@@ -110,7 +138,7 @@ async function runLogs(id, opts) {
         process.exit(1);
     }
     if (candidates.length === 1) {
-        await showCandidate(candidates[0], follow, full);
+        await showCandidate(candidates[0], follow, full, !!opts.json);
         return;
     }
     // Multiple sessions matched → picker if interactive, else a list to pick from.
@@ -134,7 +162,7 @@ async function runLogs(id, opts) {
     });
     if (!picked)
         return;
-    await showCandidate(picked.item, follow, full);
+    await showCandidate(picked.item, follow, full, !!opts.json);
 }
 function parseSince(s) {
     const m = s.match(/^(\d+)([smhdw])$/);
@@ -343,6 +371,7 @@ export function registerLogsCommand(program) {
         .option('--session <id>', 'Select a session/run by id (same as the positional id)')
         .option('-f, --follow', 'Follow live output')
         .option('-m, --full', 'Show the full raw transcript / stdout instead of the concise summary')
+        .option('--json', 'Machine-readable JSON: a host task as { kind, task, log }, a session as the redacted { session, events } (same shape as `sessions <id> --json`)')
         .action((id, opts) => runLogs(id, opts));
     logsCmd
         .command('audit')

package/dist/commands/mcp.js

@@ -147,6 +147,7 @@ When to use:
         .command('list [agent]')
         .description('Show which MCP servers are registered and which agent versions they are synced to')
         .option('-a, --agent <agent>', 'Filter to a specific agent (alternative to positional arg)')
+        .option('--json', 'Emit machine-readable JSON instead of the table/picker')
         .action(async (agentArg, options) => {
         const spinner = ora({ text: 'Loading...', isSilent: !process.stdout.isTTY }).start();
         const agentInput = agentArg || options.agent;
@@ -176,6 +177,7 @@ When to use:
             centralPath: getMcpDir(),
             filterAgent,
             filterVersion,
+            json: options.json,
         });
     });
     mcpCmd

package/dist/commands/mine.d.ts

@@ -0,0 +1,27 @@
+/**
+ * `agents mine` — white-label the CLI under your own name.
+ *
+ * `agents mine init <name>` mints a personally-named binary (e.g. `jack`) that
+ * IS agents-cli: a pure pass-through shim on PATH that runs every `agents` verb
+ * under the brand's name, with the brand's disabled commands and curated
+ * resource profile applied. `list` / `toggle` / `remove` manage brands.
+ *
+ * The discoverable entry point is the `agents setup mine` wizard
+ * (see setup-mine.ts), which delegates to `initBrand` here.
+ *
+ * Storage: brand config in `meta.brands` (agents.yaml); the curated resource set
+ * reuses the resource-profile engine — each brand owns a preset named
+ * `mine-<name>` in `meta.profiles.presets`. See lib/brand.ts.
+ */
+import type { Command } from 'commander';
+/**
+ * Create (or re-mint) a brand. Shared by `mine init` and the `setup mine`
+ * wizard. Writes the shim, the brand config, and an empty resource preset.
+ */
+export declare function initBrand(name: string, opts?: {
+    disabledCommands?: string[];
+    force?: boolean;
+}): {
+    pathWarning: boolean;
+};
+export declare function registerMineCommand(program: Command): void;

package/dist/commands/mine.js

@@ -0,0 +1,207 @@
+import chalk from 'chalk';
+import { validateBrandName, listBrands, getBrandConfig, upsertBrand, removeBrand, brandPresetName, } from '../lib/brand.js';
+import { createBrandShim, removeBrandShim, isShimsInPath } from '../lib/shims.js';
+import { updateMeta } from '../lib/state.js';
+import { COMMAND_LOADERS } from '../lib/startup/command-registry.js';
+/** Built-in top-level command names, for validating `--disable <cmd>`. */
+function knownCommandNames() {
+    const names = new Set(Object.keys(COMMAND_LOADERS));
+    // Inline aliases registered outside COMMAND_LOADERS (see src/index.ts).
+    for (const n of ['perms', 'exec', 'jobs', 'cron', 'upgrade'])
+        names.add(n);
+    return names;
+}
+/**
+ * Add/remove a `!name` exclusion on a preset's pattern list for one kind,
+ * keeping `*` so everything not explicitly disabled stays enabled. Deletes the
+ * key entirely once nothing but `*` remains, so a clean brand has an empty preset.
+ */
+function applyResourceToggle(preset, kind, name, enable) {
+    // Cast to a plain string-bag: writing through the union-keyed `preset[kind]`
+    // collapses to `never` under strict TS, so index the bag instead.
+    const bag = preset;
+    const arr = [...(bag[kind] ?? [])];
+    if (arr.length === 0)
+        arr.push('*');
+    const excl = `!${name}`;
+    const idx = arr.indexOf(excl);
+    if (enable) {
+        if (idx !== -1)
+            arr.splice(idx, 1);
+    }
+    else if (idx === -1) {
+        arr.push(excl);
+    }
+    const onlyStar = arr.length === 1 && arr[0] === '*';
+    if (onlyStar)
+        delete bag[kind];
+    else
+        bag[kind] = arr;
+}
+/** Ensure the brand's preset exists in meta.profiles.presets and return a mutable copy path. */
+function ensurePresetExists(name) {
+    const presetName = brandPresetName(name);
+    updateMeta((meta) => {
+        const profiles = meta.profiles ?? {};
+        const presets = { ...(profiles.presets ?? {}) };
+        if (!presets[presetName]) {
+            presets[presetName] = { description: `Resource set for the "${name}" brand` };
+        }
+        return { ...meta, profiles: { ...profiles, presets } };
+    });
+}
+/** Mutate the brand's resource preset under lock. */
+function editPreset(name, fn) {
+    const presetName = brandPresetName(name);
+    updateMeta((meta) => {
+        const profiles = meta.profiles ?? {};
+        const presets = { ...(profiles.presets ?? {}) };
+        const preset = { ...(presets[presetName] ?? {}) };
+        fn(preset);
+        presets[presetName] = preset;
+        return { ...meta, profiles: { ...profiles, presets } };
+    });
+}
+/**
+ * Create (or re-mint) a brand. Shared by `mine init` and the `setup mine`
+ * wizard. Writes the shim, the brand config, and an empty resource preset.
+ */
+export function initBrand(name, opts = {}) {
+    const err = validateBrandName(name);
+    if (err) {
+        console.error(chalk.red(err));
+        process.exit(1);
+    }
+    if (getBrandConfig(name) && !opts.force) {
+        console.error(chalk.red(`Brand "${name}" already exists. Use --force to re-mint, or 'agents mine toggle ${name}'.`));
+        process.exit(1);
+    }
+    ensurePresetExists(name);
+    const disabled = (opts.disabledCommands ?? []).filter((c) => c.length > 0);
+    const known = knownCommandNames();
+    for (const c of disabled) {
+        if (!known.has(c))
+            console.error(chalk.yellow(`  note: "${c}" is not a known command — kept anyway.`));
+    }
+    const cfg = {
+        name,
+        enabled: true,
+        profile: brandPresetName(name),
+        ...(disabled.length > 0 ? { disabledCommands: disabled } : {}),
+    };
+    upsertBrand(cfg);
+    createBrandShim(name);
+    const pathWarning = !isShimsInPath();
+    return { pathWarning };
+}
+function printMinted(name, pathWarning) {
+    console.log(`${chalk.green('Minted')} ${chalk.bold(name)} — your own agents CLI.`);
+    console.log(chalk.dim(`  try:  ${name} --help    ${name} run claude "hello"`));
+    if (pathWarning) {
+        console.log(chalk.yellow(`  note: the shims dir isn't on your PATH yet — run 'agents setup' or open a new shell.`));
+    }
+}
+export function registerMineCommand(program) {
+    const cmd = program
+        .command('mine')
+        .description('White-label the CLI: your own personally-named binary (e.g. `jack`)');
+    cmd
+        .command('init <name>')
+        .description('Mint your own branded CLI that runs every agents verb under <name>')
+        .option('--disable <commands...>', 'Built-in commands to hide from this brand (e.g. teams cloud)')
+        .option('--force', 'Re-mint even if the brand already exists')
+        .action((name, options) => {
+        const { pathWarning } = initBrand(name, {
+            disabledCommands: options.disable,
+            force: options.force,
+        });
+        printMinted(name, pathWarning);
+    });
+    cmd
+        .command('list')
+        .alias('ls')
+        .description('Show your brands and what each has turned off')
+        .action(() => {
+        const brands = listBrands();
+        const entries = Object.entries(brands);
+        if (entries.length === 0) {
+            console.log(chalk.gray("No brands yet. Try: agents setup mine   (or: agents mine init jack)"));
+            return;
+        }
+        const width = entries.reduce((m, [n]) => Math.max(m, n.length), 0);
+        for (const [name, cfg] of entries) {
+            const off = cfg.disabledCommands?.length ? `disabled: ${cfg.disabledCommands.join(', ')}` : 'all commands on';
+            const state = cfg.enabled === false ? chalk.yellow('(disabled) ') : '';
+            console.log(`  ${chalk.bold(name.padEnd(width))}  ${state}${chalk.dim(off)}`);
+        }
+    });
+    cmd
+        .command('toggle <name>')
+        .description('Enable/disable features for a brand')
+        .option('--disable <commands...>', 'Hide these built-in commands')
+        .option('--enable <commands...>', 'Un-hide these built-in commands')
+        .option('--disable-plugin <names...>', 'Disable these plugins for the brand')
+        .option('--enable-plugin <names...>', 'Re-enable these plugins')
+        .option('--disable-skill <names...>', 'Disable these skills for the brand')
+        .option('--enable-skill <names...>', 'Re-enable these skills')
+        .action((name, options) => {
+        const cfg = getBrandConfig(name);
+        if (!cfg) {
+            console.error(chalk.red(`No brand named "${name}". Create it with 'agents mine init ${name}'.`));
+            process.exit(1);
+        }
+        // Built-in command toggles → brand.disabledCommands.
+        const disabledSet = new Set(cfg.disabledCommands ?? []);
+        const known = knownCommandNames();
+        for (const c of options.disable ?? []) {
+            if (!known.has(c))
+                console.error(chalk.yellow(`  note: "${c}" is not a known command — kept anyway.`));
+            disabledSet.add(c);
+        }
+        for (const c of options.enable ?? [])
+            disabledSet.delete(c);
+        const nextDisabled = [...disabledSet];
+        const nextCfg = { ...cfg };
+        if (nextDisabled.length > 0)
+            nextCfg.disabledCommands = nextDisabled;
+        else
+            delete nextCfg.disabledCommands;
+        upsertBrand(nextCfg);
+        // Resource toggles → the brand's profile preset.
+        const resourceOps = [];
+        for (const p of options.disablePlugin ?? [])
+            resourceOps.push(['plugins', p, false]);
+        for (const p of options.enablePlugin ?? [])
+            resourceOps.push(['plugins', p, true]);
+        for (const s of options.disableSkill ?? [])
+            resourceOps.push(['skills', s, false]);
+        for (const s of options.enableSkill ?? [])
+            resourceOps.push(['skills', s, true]);
+        if (resourceOps.length > 0) {
+            ensurePresetExists(name);
+            editPreset(name, (preset) => {
+                for (const [kind, n, enable] of resourceOps)
+                    applyResourceToggle(preset, kind, n, enable);
+            });
+        }
+        console.log(`${chalk.green('Updated')} ${chalk.bold(name)}.`);
+        const finalCfg = getBrandConfig(name);
+        const off = finalCfg.disabledCommands?.length ? finalCfg.disabledCommands.join(', ') : '(none)';
+        console.log(chalk.dim(`  disabled commands: ${off}`));
+    });
+    cmd
+        .command('remove <name>')
+        .alias('rm')
+        .description('Remove a brand (its shim + config)')
+        .option('--purge', "Also delete the brand's resource profile preset")
+        .action((name, options) => {
+        const existed = getBrandConfig(name) !== undefined;
+        const shimRemoved = removeBrandShim(name);
+        if (!existed && !shimRemoved) {
+            console.error(chalk.red(`No brand named "${name}".`));
+            process.exit(1);
+        }
+        removeBrand(name, options.purge === true);
+        console.log(`${chalk.yellow('Removed')} brand ${chalk.bold(name)}`);
+    });
+}