@phnx-labs/agents-cli 1.20.72 → 1.20.74

package/dist/lib/teams/parsers.js

@@ -8,6 +8,7 @@
  */
 import { extractFileOpsFromBash } from './file_ops.js';
 const claudeToolUseMap = new Map();
+const droidToolUseMap = new Map();
 /** Normalize a raw JSON event from any agent type into an array of unified event objects. */
 export function normalizeEvents(agentType, raw) {
     if (agentType === 'codex') {
@@ -34,12 +35,9 @@ export function normalizeEvents(agentType, raw) {
     else if (agentType === 'kimi') {
         return normalizeKimi(raw);
     }
-    // droid (Factory AI) intentionally falls through to the generic normalizer
-    // below: its `-o stream-json` JSONL event schema is not yet verified against
-    // a live run (the documented `debug` format differs from stream-json). Events
-    // still stream and render; structured tool/file categorization will be added
-    // once a real `droid exec -o stream-json` sample is captured. Do NOT guess the
-    // schema here — a wrong discriminator silently mislabels every event.
+    else if (agentType === 'droid') {
+        return normalizeDroid(raw);
+    }
     const timestamp = new Date().toISOString();
     return [{
             type: raw.type || 'unknown',
@@ -1078,6 +1076,216 @@ function normalizeKimi(raw) {
             timestamp: timestamp,
         }];
 }
+// --- Droid parsing ---
+// Droid's `droid exec -o stream-json` stream mirrors the Factory session JSONL
+// envelope: session_start records plus Anthropic-shaped message content blocks.
+// Tool blocks carry the actionable file path / command in `input`; result blocks
+// only carry `tool_use_id`, so keep a small id map just like normalizeClaude.
+function normalizeDroid(raw) {
+    const timestamp = typeof raw?.timestamp === 'string' ? raw.timestamp : new Date().toISOString();
+    if (!raw || typeof raw !== 'object') {
+        return [{
+                type: 'unknown',
+                agent: 'droid',
+                raw: raw,
+                timestamp: timestamp,
+            }];
+    }
+    const eventType = typeof raw.type === 'string' ? raw.type : 'unknown';
+    if (eventType === 'session_start') {
+        return [{
+                type: 'init',
+                agent: 'droid',
+                session_id: typeof raw.id === 'string' ? raw.id : null,
+                timestamp: timestamp,
+            }];
+    }
+    if (eventType === 'result') {
+        return [{
+                type: 'result',
+                agent: 'droid',
+                status: raw.is_error === true ? 'error' : 'success',
+                message: typeof raw.result === 'string' ? raw.result : undefined,
+                timestamp: timestamp,
+            }];
+    }
+    if (eventType !== 'message') {
+        return [{
+                type: eventType,
+                agent: 'droid',
+                raw: raw,
+                timestamp: timestamp,
+            }];
+    }
+    const message = raw.message || {};
+    const role = message.role === 'user' ? 'user' : 'assistant';
+    const blocks = message.content;
+    if (typeof blocks === 'string') {
+        const content = blocks.trim();
+        if (!content)
+            return [];
+        return role === 'assistant'
+            ? [{ type: 'message', agent: 'droid', content, complete: true, timestamp }]
+            : [{ type: 'user_message', agent: 'droid', content, timestamp }];
+    }
+    if (!Array.isArray(blocks))
+        return [];
+    const events = [];
+    for (const block of blocks) {
+        if (!block || typeof block !== 'object')
+            continue;
+        if (block.type === 'text') {
+            const text = typeof block.text === 'string' ? block.text.trim() : '';
+            if (!text)
+                continue;
+            if (role === 'assistant') {
+                events.push({
+                    type: 'message',
+                    agent: 'droid',
+                    content: text,
+                    complete: true,
+                    timestamp: timestamp,
+                });
+            }
+            else if (!text.startsWith('<system-reminder>') && !text.startsWith('Hook execution:')) {
+                events.push({
+                    type: 'user_message',
+                    agent: 'droid',
+                    content: text,
+                    timestamp: timestamp,
+                });
+            }
+            continue;
+        }
+        if (block.type === 'thinking') {
+            const thinking = typeof block.thinking === 'string' ? block.thinking.trim() : '';
+            if (thinking) {
+                events.push({
+                    type: 'thinking',
+                    agent: 'droid',
+                    content: thinking,
+                    timestamp: timestamp,
+                });
+            }
+            continue;
+        }
+        if (block.type === 'tool_use') {
+            events.push(...normalizeDroidToolUse(block, timestamp));
+            continue;
+        }
+        if (block.type === 'tool_result') {
+            const toolUseId = typeof block.tool_use_id === 'string' ? block.tool_use_id : null;
+            const toolInfo = toolUseId ? droidToolUseMap.get(toolUseId) : undefined;
+            if (toolUseId)
+                droidToolUseMap.delete(toolUseId);
+            const content = extractDroidToolResultContent(block.content);
+            if (block.is_error === true) {
+                events.push({
+                    type: 'error',
+                    agent: 'droid',
+                    tool: toolInfo?.tool,
+                    content: content || 'Tool execution failed',
+                    timestamp: timestamp,
+                });
+            }
+            else {
+                events.push({
+                    type: 'tool_result',
+                    agent: 'droid',
+                    tool: toolInfo?.tool,
+                    tool_call_id: toolUseId,
+                    success: true,
+                    content: content.length > 500 ? content.slice(0, 497) + '...' : content,
+                    timestamp: timestamp,
+                });
+            }
+        }
+    }
+    return events;
+}
+function normalizeDroidToolUse(block, timestamp) {
+    const toolName = typeof block.name === 'string' ? block.name : 'unknown';
+    const toolInput = block.input && typeof block.input === 'object' ? block.input : {};
+    if (typeof block.id === 'string') {
+        droidToolUseMap.set(block.id, { tool: toolName, args: toolInput });
+    }
+    const filePath = toolInput.file_path || toolInput.path || '';
+    const command = toolInput.command || '';
+    if ((toolName === 'Execute' || toolName === 'Bash') && command) {
+        const events = [{
+                type: 'bash',
+                agent: 'droid',
+                tool: toolName,
+                command: command,
+                timestamp: timestamp,
+            }];
+        const [filesRead, filesWritten, filesDeleted] = extractFileOpsFromBash(command);
+        for (const path of filesRead) {
+            events.push({ type: 'file_read', agent: 'droid', tool: 'bash', path, command, timestamp });
+        }
+        for (const path of filesWritten) {
+            events.push({ type: 'file_write', agent: 'droid', tool: 'bash', path, command, timestamp });
+        }
+        for (const path of filesDeleted) {
+            events.push({ type: 'file_delete', agent: 'droid', tool: 'bash', path, command, timestamp });
+        }
+        return events;
+    }
+    if (toolName === 'Read' && filePath) {
+        return [{
+                type: 'file_read',
+                agent: 'droid',
+                tool: toolName,
+                path: filePath,
+                timestamp: timestamp,
+            }];
+    }
+    if ((toolName === 'Create' || toolName === 'Write') && filePath) {
+        return [{
+                type: 'file_create',
+                agent: 'droid',
+                tool: toolName,
+                path: filePath,
+                timestamp: timestamp,
+            }];
+    }
+    if ((toolName === 'Edit' || toolName === 'MultiEdit') && filePath) {
+        return [{
+                type: 'file_write',
+                agent: 'droid',
+                tool: toolName,
+                path: filePath,
+                timestamp: timestamp,
+            }];
+    }
+    if ((toolName === 'Delete' || toolName === 'Remove') && filePath) {
+        return [{
+                type: 'file_delete',
+                agent: 'droid',
+                tool: toolName,
+                path: filePath,
+                timestamp: timestamp,
+            }];
+    }
+    return [{
+            type: 'tool_use',
+            agent: 'droid',
+            tool: toolName,
+            args: toolInput,
+            timestamp: timestamp,
+        }];
+}
+function extractDroidToolResultContent(content) {
+    if (typeof content === 'string')
+        return content;
+    if (Array.isArray(content)) {
+        return content
+            .filter((part) => part && typeof part === 'object' && part.type === 'text')
+            .map((part) => typeof part.text === 'string' ? part.text : '')
+            .join('\n');
+    }
+    return '';
+}
 // --- Antigravity parsing ---
 // Intentionally conservative. Antigravity's `agy` binary advertises an
 // `--output-format json` flag in its docs, but the released binary errors with

package/dist/lib/teams/supervisor.d.ts

@@ -51,6 +51,13 @@ export interface SupervisorResult {
     waves: number;
     stoppedBy: 'drained' | 'max-waves' | 'signal' | 'callback' | 'budget';
     elapsed_ms: number;
+    /**
+     * Number of teammates in the `failed` state when the team drained. Only set
+     * for `stoppedBy === 'drained'`. A drained DAG means nothing is pending or
+     * running — NOT that everything succeeded — so callers that treat "drained"
+     * as success (e.g. a completion nudge) must check `failed === 0` first.
+     */
+    failed?: number;
     /** Set when `stoppedBy === 'budget'` — the breach that terminated the team. */
     budgetBreach?: BreachInfo;
 }

package/dist/lib/teams/supervisor.js

@@ -80,7 +80,8 @@ export async function runSupervisor(mgr, opts) {
             const afterCallback = await mgr.listByTask(team);
             const stillLive = afterCallback.some((a) => a.status === 'pending' || a.status === 'running');
             if (!stillLive) {
-                return { waves: wave, stoppedBy: 'drained', elapsed_ms: Date.now() - startedAt };
+                const failed = afterCallback.filter((a) => a.status === 'failed').length;
+                return { waves: wave, stoppedBy: 'drained', failed, elapsed_ms: Date.now() - startedAt };
             }
             if (stopSignal) {
                 return { waves: wave, stoppedBy: 'signal', elapsed_ms: Date.now() - startedAt };

package/dist/lib/template.d.ts

@@ -1,6 +1,6 @@
 /**
  * Template resolution utilities.
- * Ported from agents/halo/cli/pkg/template.
+ * Ported from the legacy agent CLI template helpers.
  *
  * Supports {{artifact.*}} and {{preflight.*}} placeholder patterns used in
  * artifact action input mappings.

package/dist/lib/template.js

@@ -1,6 +1,6 @@
 /**
  * Template resolution utilities.
- * Ported from agents/halo/cli/pkg/template.
+ * Ported from the legacy agent CLI template helpers.
  *
  * Supports {{artifact.*}} and {{preflight.*}} placeholder patterns used in
  * artifact action input mappings.

package/dist/lib/triggers/webhook.js

@@ -77,18 +77,46 @@ function linearTeamKey(payload) {
     return typeof team?.key === 'string' ? team.key : null;
 }
 function linearLabels(payload) {
+    // Linear webhook bodies flatten list relations: an Issue event carries
+    // `data.labels` as a flat array of label objects (`[{ id, name, color }]`),
+    // NOT the `{ nodes: [...] }` connection shape returned by the GraphQL API.
+    // Reading `.nodes` here made every `--label` filter match nothing.
     const data = payload.data;
-    const labels = data?.labels;
-    const nodes = Array.isArray(labels?.nodes) ? labels.nodes : [];
-    return nodes
+    const labels = Array.isArray(data?.labels) ? data?.labels : [];
+    return labels
         .map((n) => n.name)
         .filter((n) => typeof n === 'string' && n.length > 0);
 }
+function githubAction(payload) {
+    return typeof payload.action === 'string' ? payload.action : null;
+}
+function githubLabels(payload) {
+    const names = new Set();
+    const add = (value) => {
+        if (typeof value === 'string' && value.length > 0)
+            names.add(value);
+    };
+    const deliveryLabel = payload.label;
+    add(deliveryLabel?.name);
+    const pr = payload.pull_request;
+    const prLabels = Array.isArray(pr?.labels) ? pr.labels : [];
+    for (const label of prLabels) {
+        add(label.name);
+    }
+    const issue = payload.issue;
+    const issueLabels = Array.isArray(issue?.labels) ? issue.labels : [];
+    for (const label of issueLabels) {
+        add(label.name);
+    }
+    return [...names];
+}
 function githubTriggerMatches(trigger, webhook) {
     if (webhook.source !== 'github')
         return false;
     if (trigger.event !== webhook.event)
         return false;
+    if (trigger.action && githubAction(webhook.payload) !== trigger.action)
+        return false;
     if (trigger.repo) {
         const repo = webhookRepo(webhook.payload);
         if (!repo || repo.toLowerCase() !== trigger.repo.toLowerCase())
@@ -99,6 +127,11 @@ function githubTriggerMatches(trigger, webhook) {
         if (!branches.some((b) => b === trigger.branch))
             return false;
     }
+    if (trigger.label) {
+        const expected = trigger.label.toLowerCase();
+        if (!githubLabels(webhook.payload).some((name) => name.toLowerCase() === expected))
+            return false;
+    }
     return true;
 }
 function linearTriggerMatches(trigger, webhook) {

package/dist/lib/types.d.ts

@@ -508,6 +508,29 @@ export interface VersionResources {
     permissions?: ResourcePattern[];
     mcp?: ResourcePattern[];
 }
+/** Resource-kind selectors controlled by top-level resource profiles. */
+export interface ResourceProfilePreset {
+    description?: string;
+    commands?: ResourcePattern[];
+    skills?: ResourcePattern[];
+    hooks?: ResourcePattern[];
+    subagents?: ResourcePattern[];
+    plugins?: ResourcePattern[];
+    workflows?: ResourcePattern[];
+    permissions?: ResourcePattern[];
+    mcp?: ResourcePattern[];
+    /** Rule preset name to compose while this profile is active. */
+    rules?: string;
+    /** Alias for rules, accepted so YAML can mirror VersionResources naming. */
+    rulesPreset?: string;
+    /** Secrets bundle names, or "*" for every bundle. */
+    secrets?: string[];
+}
+/** Top-level profiles/presets that switch the resolved resource view. */
+export interface ResourceProfilesConfig {
+    active?: string;
+    presets?: Record<string, ResourceProfilePreset>;
+}
 /** A userConfig field declared in a plugin manifest. */
 export interface PluginUserConfigField {
     key: string;
@@ -644,9 +667,42 @@ export interface ExtraRepoConfig {
     path?: string;
     enabled: boolean;
 }
+/**
+ * A white-label brand — a personally-named CLI (e.g. `jack`) that IS agents-cli,
+ * minted by `agents setup mine` / `agents mine`. The brand's shim exports
+ * `AGENTS_BRAND=<name>`; the entrypoint reads it to present under this name and
+ * apply the customization below. Portable user config — rides `agents repo
+ * push/pull`. See lib/brand.ts.
+ */
+export interface BrandConfig {
+    /** The brand name; also the binary name on PATH. */
+    name: string;
+    /** Built-in top-level commands this brand hides/disables (e.g. `["teams"]`). */
+    disabledCommands?: string[];
+    /**
+     * Resource-profile preset this brand pins (a key in `profiles.presets`). When
+     * the CLI runs under this brand, that preset becomes the active profile, so
+     * skills/plugins/mcp/hooks/etc. filter to the brand's curated set. Defaults to
+     * `mine-<name>`.
+     */
+    profile?: string;
+    /** False to keep the config but stop minting/using the brand. */
+    enabled: boolean;
+}
 /** Top-level structure of ~/.agents/.system/agents.yaml -- the CLI's persistent state. */
 export interface Meta {
     agents?: Partial<Record<AgentId, string>>;
+    /**
+     * Per-agent preferred ISOLATED version — which copy a bare `agents run <agent>`
+     * resolves to when the agent has no global default.
+     *
+     * Kept separate from `agents` on purpose. An entry there is the global default,
+     * which owns the launcher, the bare shim and the real `~/.<agent>` config
+     * symlink, and arms the self-heal `shadowing` check. An isolated copy must never
+     * acquire any of that, so it cannot be recorded in the same place — the
+     * separation is what keeps `getGlobalDefault` incapable of returning one.
+     */
+    isolatedAgents?: Partial<Record<AgentId, string>>;
     run?: RunConfig;
     /**
      * `agents run --lease` config. `secretsBundle` names the keychain secrets bundle
@@ -682,6 +738,12 @@ export interface Meta {
         enabled?: BetaFeatureName[];
     };
     registries?: Record<RegistryType, Record<string, RegistryConfig>>;
+    /**
+     * Top-level resource profiles. Activating one filters the resolved resource
+     * set across commands, skills, hooks, rules, MCP, permissions, and secrets.
+     * Model-provider run profiles are separate YAML files under profiles/.
+     */
+    profiles?: ResourceProfilesConfig;
     versions?: Partial<Record<AgentId, Record<string, VersionResources>>>;
     source?: string;
     /**
@@ -696,6 +758,12 @@ export interface Meta {
      * via the `path` field.
      */
     extraRepos?: Record<string, ExtraRepoConfig>;
+    /**
+     * White-label brands keyed by name. Each mints a personally-named binary
+     * (e.g. `jack`) that runs agents-cli under that name with its own disabled
+     * commands + curated resource profile. See lib/brand.ts.
+     */
+    brands?: Record<string, BrandConfig>;
     /**
      * Keys like `skill.hermes` — registries seeded from SEEDED_REGISTRIES exactly
      * once. Tracked so a user `registry remove` won't silently re-seed.
@@ -746,6 +814,22 @@ export interface Meta {
         workerName?: string;
         bucketName?: string;
         domain?: string;
+        /** Cloudflare Web Analytics token injected into published HTML pages. */
+        analyticsToken?: string;
+    };
+    /**
+     * Owner/channel notification config for `agents send` / `agents notify`.
+     * `owner` is the default recipient for `agents notify` (channel + target).
+     * `transports` maps a user-facing channel name to the provider that actually
+     * delivers it — explicit, one provider per channel, no fallback. Omitted keys
+     * default to name-identity (channel `slack` -> provider `slack`).
+     */
+    notify?: {
+        owner?: {
+            channel: string;
+            to: string;
+        };
+        transports?: Record<string, string>;
     };
 }
 /** Persisted agent-host entry in agents.yaml (overlay or inline). */

package/dist/lib/uninstall.js

@@ -20,6 +20,7 @@ import * as os from 'os';
 import * as path from 'path';
 import { AGENTS, ALL_AGENT_IDS } from './agents.js';
 import { getAgentConfigPath, getConfigSymlinkVersion, stripShimPathLines, releaseAdoptedLauncher, } from './shims.js';
+import { moveDirCrossDevice, copyDirStrippingAgentsSymlinks } from './config-transfer.js';
 import { getUserAgentsDir, getBackupsDir, getHistoryDir, getShimsDir, getLegacySystemAgentsDir, } from './state.js';
 /** Home dir honoring the AGENTS_REAL_HOME test/override, mirroring shims.ts. */
 function realHome() {
@@ -60,51 +61,6 @@ function symlinkTarget(p) {
 function removeLink(p) {
     fs.unlinkSync(p);
 }
-/**
- * Move `source` onto `dest` across possibly-different volumes. `renameSync` is
- * atomic but throws EXDEV when `~/.agents` lives on a different filesystem than
- * `$HOME`; fall back to copy-then-remove so the restore still completes. The
- * source (a backup inside `~/.agents`) is removed only after the copy succeeds,
- * so a mid-copy failure never destroys the sole surviving copy.
- */
-function moveDirCrossDevice(source, dest) {
-    try {
-        fs.renameSync(source, dest);
-    }
-    catch (err) {
-        if (err.code !== 'EXDEV')
-            throw err;
-        fs.cpSync(source, dest, { recursive: true });
-        fs.rmSync(source, { recursive: true, force: true });
-    }
-}
-/**
- * Copy `source` to `dest`, dropping any symlink whose target resolves back into
- * `~/.agents`. Adoption syncs managed resources (skills/commands) into the
- * version home as symlinks into `~/.agents`; copying them verbatim would leave
- * the restored config full of links that dangle the moment `~/.agents` is
- * disposed. Stripping them yields a clean, self-contained restore.
- */
-function copyDirStrippingAgentsSymlinks(source, dest, agentsDir) {
-    const inside = agentsDir + path.sep;
-    fs.cpSync(source, dest, {
-        recursive: true,
-        filter: (src) => {
-            try {
-                const st = fs.lstatSync(src);
-                if (st.isSymbolicLink()) {
-                    const tgt = path.resolve(path.dirname(src), fs.readlinkSync(src));
-                    if (tgt === agentsDir || tgt.startsWith(inside))
-                        return false;
-                }
-            }
-            catch {
-                /* unreadable entry — let cpSync surface it on the real copy */
-            }
-            return true;
-        },
-    });
-}
 /** Classify one agent's config dir without mutating anything. */
 function planConfig(agent) {
     const realPath = getAgentConfigPath(agent);

package/dist/lib/version.d.ts

@@ -1,8 +1,48 @@
+/**
+ * Well-known locations of the `agents` launcher for PATH-less GUI/launchd
+ * processes (the menu-bar helper inherits no login PATH). Also the anchor for
+ * recovering the on-disk install layout when the CLI runs as a Bun single-file
+ * binary — see {@link resolveInstalledLayout}.
+ */
+export declare function resolveAgentsBin(): string | null;
+export interface InstallLayout {
+    /** The install's `dist/` directory (holds `index.js` + `lib/`). */
+    distDir: string;
+    /** The compiled CLI entry, `dist/index.js`. */
+    entryPath: string;
+    /** The shipping `package.json`, `dist/../package.json`. */
+    pkgJsonPath: string;
+}
+/**
+ * Pure derivation (no I/O) of an install's on-disk layout from the realpath of
+ * its `agents` launcher. A launcher lives at `<pkg>/dist/bin/agents`, so two
+ * levels up is `<pkg>/dist`. Exported for unit testing so the dirname chain the
+ * Bun-binary fallback depends on stays locked.
+ */
+export declare function installLayoutFromBin(realBin: string): InstallLayout;
+/**
+ * Resolve the on-disk install layout of the running CLI by following the
+ * `agents` launcher symlink.
+ *
+ * When the CLI runs as a Bun single-file executable, `import.meta.url` points
+ * inside the virtual bundle (`/$bunfs/…`), so sibling-relative resolution can't
+ * see the shipped `package.json`, `dist/index.js`, or `MenubarHelper.app` on
+ * disk. The launcher symlink points at the real files; walk up from it. Returns
+ * null when no launcher is found (dev/tsx runs, or a box without the helper) —
+ * callers keep their in-bundle resolution as the primary path and use this only
+ * as the fallback.
+ */
+export declare function resolveInstalledLayout(): InstallLayout | null;
 /**
  * Resolve the CLI version from the shipping package.json. Used by the daemon
  * to answer `IPCAction: 'version'` and by the client to detect daemon drift —
  * a dev-build CLI talking to a launchd-managed registry daemon would silently
  * get stale behavior without this check.
+ *
+ * Primary read is relative to this module; when that fails (the Bun single-file
+ * binary can't read its own bundled package.json), fall back to the on-disk
+ * install found via the launcher symlink so callers like the menu bar don't see
+ * a bogus `unknown`.
  */
 export declare function getCliVersion(): string;
 /**