@phnx-labs/agents-cli 1.20.70 → 1.20.72

package/dist/lib/session/render.d.ts

@@ -108,6 +108,14 @@ export declare function renderConversationMarkdown(events: SessionEvent[], opts?
  * `{ session, events }` wrapper so top-level fields (`plan`, `prUrl`, …) that
  * live on `SessionMeta` are visible without re-parsing events. Legacy
  * callers that pass no meta still get a bare `SessionEvent[]` array.
+ *
+ * Secrets are redacted by default (`opts.redact !== false`), matching
+ * `renderConversationMarkdown` — the JSON path must not be the one output
+ * format that leaks credentials. Redaction covers both events AND the session
+ * meta (e.g. `topic`, a verbatim first-message excerpt). Pass `{ redact: false }`
+ * for `--no-redact`.
  */
-export declare function renderJson(events: SessionEvent[], meta?: SessionMeta): string;
+export declare function renderJson(events: SessionEvent[], meta?: SessionMeta, opts?: {
+    redact?: boolean;
+}): string;
 export {};

package/dist/lib/session/render.js

@@ -913,19 +913,50 @@ export function renderConversationMarkdown(events, opts = {}) {
     }
     return parts.join('\n\n');
 }
+/**
+ * Deep-redact every string reachable from a JSON value, preserving structure.
+ * `redactSecrets` only rewrites secret-shaped substrings, so non-secret strings
+ * (paths, URLs, ids) and non-strings (numbers, booleans) pass through unchanged.
+ * Applied to the whole `--json` payload so every free-text field — event
+ * `content`/`command`/`output`/`args`, and meta `topic`/`label`/`plan`/`todos`
+ * — is covered, including fields added later.
+ */
+function redactDeep(value, sanitize) {
+    if (typeof value === 'string')
+        return sanitize(value);
+    if (Array.isArray(value))
+        return value.map((item) => redactDeep(item, sanitize));
+    if (value && typeof value === 'object') {
+        const out = {};
+        for (const [key, val] of Object.entries(value))
+            out[key] = redactDeep(val, sanitize);
+        return out;
+    }
+    return value;
+}
 /**
  * Render one session's JSON output — the shape `agents sessions <id> --json`
  * emits. When `meta` is provided (the standard path), returns a
  * `{ session, events }` wrapper so top-level fields (`plan`, `prUrl`, …) that
  * live on `SessionMeta` are visible without re-parsing events. Legacy
  * callers that pass no meta still get a bare `SessionEvent[]` array.
+ *
+ * Secrets are redacted by default (`opts.redact !== false`), matching
+ * `renderConversationMarkdown` — the JSON path must not be the one output
+ * format that leaks credentials. Redaction covers both events AND the session
+ * meta (e.g. `topic`, a verbatim first-message excerpt). Pass `{ redact: false }`
+ * for `--no-redact`.
  */
-export function renderJson(events, meta) {
+export function renderJson(events, meta, opts = {}) {
+    const redact = opts.redact !== false;
+    const sanitize = (text) => redactSecrets(text);
+    const safeEvents = redact ? events.map((event) => redactDeep(event, sanitize)) : events;
     if (!meta)
-        return JSON.stringify(events, null, 2);
+        return JSON.stringify(safeEvents, null, 2);
     // Strip internal-only bookkeeping fields the listing --json path also strips.
-    const { _matchedTerms, _bm25Score, _remote, ...session } = meta;
-    return JSON.stringify({ session, events }, null, 2);
+    const { _matchedTerms, _bm25Score, _remote, ...rest } = meta;
+    const session = redact ? redactDeep(rest, sanitize) : rest;
+    return JSON.stringify({ session, events: safeEvents }, null, 2);
 }
 /** Replace the home directory prefix with ~ for trace display. */
 function shortenPathTrace(p) {

package/dist/lib/share/capture.d.ts

@@ -21,6 +21,8 @@ export declare const OG_HEIGHT = 630;
 export declare const OG_SCALE = 2;
 /** Ordered list of candidate Chromium-family binaries to try for headless capture. */
 export declare function candidateBrowsers(): string[];
+/** Newest-first Chromium binaries under the Playwright / Puppeteer download caches. */
+export declare function scanCaches(home?: string, platform?: NodeJS.Platform): string[];
 /**
  * Screenshot `htmlPath`'s top 1200×630 (its hero) to a PNG buffer, or null if no
  * headless-capable browser is available or every candidate fails. Never throws —

package/dist/lib/share/capture.js

@@ -55,22 +55,29 @@ export function candidateBrowsers() {
     return out;
 }
 /** Newest-first Chromium binaries under the Playwright / Puppeteer download caches. */
-function scanCaches() {
-    const home = os.homedir();
-    const roots = os.platform() === 'darwin'
+export function scanCaches(home = os.homedir(), platform = os.platform()) {
+    const roots = platform === 'darwin'
         ? [
             path.join(home, 'Library/Caches/ms-playwright'),
             path.join(home, '.cache/ms-playwright'),
             path.join(home, '.cache/puppeteer/chrome'),
         ]
         : [path.join(home, '.cache/ms-playwright'), path.join(home, '.cache/puppeteer/chrome')];
-    const rel = os.platform() === 'darwin'
+    const rel = platform === 'darwin'
         ? [
             'chrome-mac/Chromium.app/Contents/MacOS/Chromium',
             'chrome-mac-arm64/Google Chrome for Testing.app/Contents/MacOS/Google Chrome for Testing',
             'chrome-mac-x64/Google Chrome for Testing.app/Contents/MacOS/Google Chrome for Testing',
+            // Playwright's newer headless-shell packages (chromium_headless_shell-*) —
+            // a raw binary, not an .app bundle.
+            'chrome-headless-shell-mac-arm64/chrome-headless-shell',
+            'chrome-headless-shell-mac-x64/chrome-headless-shell',
         ]
-        : ['chrome-linux/chrome', 'chrome-linux64/chrome'];
+        : [
+            'chrome-linux/chrome',
+            'chrome-linux64/chrome',
+            'chrome-headless-shell-linux64/chrome-headless-shell',
+        ];
     const found = [];
     for (const root of roots) {
         let entries;

package/dist/lib/shims.d.ts

@@ -153,6 +153,27 @@ export declare function removeShim(agent: AgentId): boolean;
  *        self-update under the shim).
  */
 export declare const VERSIONED_ALIAS_SCHEMA_VERSION = 13;
+/**
+ * Agents whose config directory can be relocated by an environment variable
+ * (the per-agent `managedEnv` block in `generateVersionedAliasScript` below).
+ *
+ * Only these can be installed with `agents add --isolated`: the versioned alias
+ * points that env var at the copy's private home, so the copy never reads or
+ * writes the user's real `~/.<agent>`. Every other agent isolates ONLY by
+ * adopting `~/.<agent>` via a symlink — which an isolated install deliberately
+ * skips — so an isolated copy would silently fall back to (and mutate) the real
+ * config dir. For those agents `--isolated` is refused up front.
+ *
+ * KEEP IN SYNC with the `managedEnv` switch in `generateVersionedAliasScript`.
+ * The colocated test `shims.isolation-capability.test.ts` enforces this.
+ */
+export declare const CONFIG_ENV_ISOLATED_AGENTS: readonly AgentId[];
+/**
+ * Whether an agent supports a clean `--isolated` install — i.e. its config
+ * location can be redirected by an env var so the isolated copy stays fully
+ * separate from the user's real `~/.<agent>`. See {@link CONFIG_ENV_ISOLATED_AGENTS}.
+ */
+export declare function supportsIsolatedInstall(agent: AgentId): boolean;
 /**
  * Generate a versioned alias script that directly execs a specific version.
  * e.g., claude@2.0.65 -> directly runs that version's binary
@@ -209,6 +230,11 @@ export declare function removeVersionedAlias(agent: AgentId, version: string): b
  * Check if a versioned alias exists (the on-disk artifact for this platform).
  */
 export declare function versionedAliasExists(agent: AgentId, version: string): boolean;
+/**
+ * Get the path to the agent's config directory in HOME.
+ * e.g., ~/.claude for claude, ~/.codex for codex
+ */
+export declare function getAgentConfigPath(agent: AgentId): string;
 /**
  * Read the user's configured Codex model from their active `~/.codex/config.toml`.
  *
@@ -449,6 +475,7 @@ export declare function hasAliasShadowingShim(agent: AgentId, overrides?: {
  * Check if shims directory is in PATH.
  */
 export declare function isShimsInPath(): boolean;
+export declare function stripShimPathLines(content: string, shimsDir: string): string;
 /**
  * Get shell configuration instructions for adding shims to PATH.
  */

package/dist/lib/shims.js

@@ -785,6 +785,29 @@ function assertSafeVersion(version) {
         throw new Error(`Refusing to generate shim for unsafe version: ${JSON.stringify(version)}`);
     }
 }
+/**
+ * Agents whose config directory can be relocated by an environment variable
+ * (the per-agent `managedEnv` block in `generateVersionedAliasScript` below).
+ *
+ * Only these can be installed with `agents add --isolated`: the versioned alias
+ * points that env var at the copy's private home, so the copy never reads or
+ * writes the user's real `~/.<agent>`. Every other agent isolates ONLY by
+ * adopting `~/.<agent>` via a symlink — which an isolated install deliberately
+ * skips — so an isolated copy would silently fall back to (and mutate) the real
+ * config dir. For those agents `--isolated` is refused up front.
+ *
+ * KEEP IN SYNC with the `managedEnv` switch in `generateVersionedAliasScript`.
+ * The colocated test `shims.isolation-capability.test.ts` enforces this.
+ */
+export const CONFIG_ENV_ISOLATED_AGENTS = ['claude', 'codex', 'copilot', 'grok', 'kimi'];
+/**
+ * Whether an agent supports a clean `--isolated` install — i.e. its config
+ * location can be redirected by an env var so the isolated copy stays fully
+ * separate from the user's real `~/.<agent>`. See {@link CONFIG_ENV_ISOLATED_AGENTS}.
+ */
+export function supportsIsolatedInstall(agent) {
+    return CONFIG_ENV_ISOLATED_AGENTS.includes(agent);
+}
 /**
  * Generate a versioned alias script that directly execs a specific version.
  * e.g., claude@2.0.65 -> directly runs that version's binary
@@ -1039,7 +1062,7 @@ export function versionedAliasExists(agent, version) {
  * Get the path to the agent's config directory in HOME.
  * e.g., ~/.claude for claude, ~/.codex for codex
  */
-function getAgentConfigPath(agent) {
+export function getAgentConfigPath(agent) {
     const agentConfig = AGENTS[agent];
     const home = process.env.AGENTS_REAL_HOME || os.homedir();
     return agentConfig.configDir.replace(os.homedir(), home);
@@ -1567,7 +1590,10 @@ export function getConfigSymlinkVersion(agent) {
         if (!stat.isSymbolicLink()) {
             return null;
         }
-        const target = fs.readlinkSync(configPath);
+        // Normalize separators so this matches on Windows too — readlinkSync there
+        // returns backslash paths, which the forward-slash-only regex never matched
+        // (misclassifying an owned symlink as foreign, e.g. in `agents uninstall`).
+        const target = fs.readlinkSync(configPath).replace(/\\/g, '/');
         // Extract version from path like ~/.agents/versions/claude/2.0.65/home/.claude
         const match = target.match(/versions\/[^/]+\/([^/]+)\/home/);
         return match ? match[1] : null;
@@ -2194,7 +2220,7 @@ function isShimPathCommandLine(line, shimsDir) {
     }
     return trimmed.startsWith('export PATH=') || trimmed.startsWith('fish_add_path ');
 }
-function stripShimPathLines(content, shimsDir) {
+export function stripShimPathLines(content, shimsDir) {
     const lines = content.split('\n');
     const kept = [];
     for (let i = 0; i < lines.length; i++) {

package/dist/lib/skills.d.ts

@@ -92,7 +92,14 @@ export declare function listAllSkills(): string[];
  */
 export declare function getVersionSkillsDir(agent: AgentId, version: string): string;
 /**
- * List skill names installed in a specific version home.
+ * List real skill names installed in a specific version home.
+ *
+ * Command-as-skill WRAPPERS (a `skills/<name>/SKILL.md` carrying the
+ * `agents_command` marker — how command-runtime agents like Codex/Kimi install
+ * commands) are excluded: they are commands, reconciled by the commands diff
+ * against the command source, not skills. Counting them here made the skill
+ * orphan/extra detectors flag every command wrapper (tickets, prune, swarm-plan,
+ * …) as an unmanaged skill — a false positive that `prune cleanup` would delete.
  */
 export declare function listSkillsInVersionHome(agent: AgentId, version: string): string[];
 export interface VersionSkillDiff {

package/dist/lib/skills.js

@@ -14,6 +14,7 @@ import { AGENTS, ensureSkillsDir, agentConfigDirName } from './agents.js';
 import { capableAgents, isCapable } from './capabilities.js';
 import { getUserSkillsDir, getSkillsDir as getSystemSkillsDir, getProjectAgentsDir, getEnabledExtraRepos, getTrashSkillsDir } from './state.js';
 import { getEffectiveHome, getVersionHomePath, listInstalledVersions } from './versions.js';
+import { listCommandSkillsInVersion } from './command-skills.js';
 import { emit } from './events.js';
 const HOME = os.homedir();
 /** User-scoped skills dir (~/.agents/skills/). Used for installs. */
@@ -392,16 +393,25 @@ export function getVersionSkillsDir(agent, version) {
     return path.join(home, agentConfigDirName(agent), 'skills');
 }
 /**
- * List skill names installed in a specific version home.
+ * List real skill names installed in a specific version home.
+ *
+ * Command-as-skill WRAPPERS (a `skills/<name>/SKILL.md` carrying the
+ * `agents_command` marker — how command-runtime agents like Codex/Kimi install
+ * commands) are excluded: they are commands, reconciled by the commands diff
+ * against the command source, not skills. Counting them here made the skill
+ * orphan/extra detectors flag every command wrapper (tickets, prune, swarm-plan,
+ * …) as an unmanaged skill — a false positive that `prune cleanup` would delete.
  */
 export function listSkillsInVersionHome(agent, version) {
     const dir = getVersionSkillsDir(agent, version);
     if (!fs.existsSync(dir))
         return [];
+    const commandWrappers = new Set(listCommandSkillsInVersion(path.join(getVersionHomePath(agent, version), agentConfigDirName(agent))));
     return fs.readdirSync(dir, { withFileTypes: true })
         .filter((e) => e.isDirectory() && !e.name.startsWith('.'))
         .filter((e) => fs.existsSync(path.join(dir, e.name, 'SKILL.md')))
         .map((e) => e.name)
+        .filter((name) => !commandWrappers.has(name))
         .sort();
 }
 /**

package/dist/lib/startup/command-registry.d.ts

@@ -85,6 +85,7 @@ export declare const loadPull: ModuleLoader;
 export declare const loadPush: ModuleLoader;
 export declare const loadRepo: ModuleLoader;
 export declare const loadSetup: ModuleLoader;
+export declare const loadUninstall: ModuleLoader;
 export declare const loadSessions: ModuleLoader;
 export declare const loadTeams: ModuleLoader;
 export declare const loadCloud: ModuleLoader;

package/dist/lib/startup/command-registry.js

@@ -63,6 +63,7 @@ export const loadPull = async () => (await import('../../commands/pull.js')).reg
 export const loadPush = async () => (await import('../../commands/push.js')).registerPushCommand;
 export const loadRepo = async () => (await import('../../commands/repo.js')).registerRepoCommands;
 export const loadSetup = async () => (await import('../../commands/setup.js')).registerSetupCommand;
+export const loadUninstall = async () => (await import('../../commands/uninstall.js')).registerUninstallCommands;
 export const loadSessions = async () => (await import('../../commands/sessions.js')).registerSessionsCommands;
 export const loadTeams = async () => (await import('../../commands/teams.js')).registerTeamsCommands;
 export const loadCloud = async () => (await import('../../commands/cloud.js')).registerCloudCommands;
@@ -174,6 +175,7 @@ export const COMMAND_LOADERS = {
     repos: [loadRepo],
     repo: [loadRepo],
     setup: [loadSetup],
+    uninstall: [loadUninstall],
     sessions: [loadSessions],
     teams: [loadTeams],
     cloud: [loadCloud],

package/dist/lib/types.d.ts

@@ -664,12 +664,16 @@ export interface Meta {
      * concurrent runs read silently — set it `false` to force a prompt on every read.
      * `holdMs` caps how long an unlocked/auto-cached bundle is held before the next
      * read re-prompts (default 7 days; e.g. 86400000 for a 24h cap). Clamped to
-     * [1 minute, 30 days]. */
+     * [1 minute, 30 days]. `durable` (default off) makes every `agents secrets
+     * unlock` survive sleep + reboot as well as upgrade/restart — the same effect as
+     * passing `--durable` per unlock; off means the secure split default (survive
+     * upgrade/restart, re-lock on sleep). */
     secrets?: {
         policy?: 'always' | 'daily';
         agent?: {
             auto?: boolean;
             holdMs?: number;
+            durable?: boolean;
         };
     };
     /** Spend guardrails (issue #346). User-global caps; project agents.yaml overrides. */

package/dist/lib/uninstall.d.ts

@@ -0,0 +1,84 @@
+import type { AgentId } from './types.js';
+/** What the uninstall intends to do with one agent's config directory. */
+export type ConfigAction = {
+    agent: AgentId;
+    realPath: string;
+    kind: 'restore-backup';
+    source: string;
+} | {
+    agent: AgentId;
+    realPath: string;
+    kind: 'restore-version-home';
+    source: string;
+} | {
+    agent: AgentId;
+    realPath: string;
+    kind: 'remove-dangling';
+} | {
+    agent: AgentId;
+    realPath: string;
+    kind: 'leave-real';
+} | {
+    agent: AgentId;
+    realPath: string;
+    kind: 'leave-foreign';
+} | {
+    agent: AgentId;
+    realPath: string;
+    kind: 'absent';
+};
+/** A home-level file symlink (e.g. `~/.claude.json`) agents-cli owns. */
+export interface HomeFileAction {
+    realPath: string;
+    /** Resolved symlink target whose contents are copied back to `realPath`. */
+    source: string;
+}
+/** The full, read-only plan describing what an uninstall would change. */
+export interface UninstallPlan {
+    isInstalled: boolean;
+    agentsDir: string;
+    legacySymlink: string | null;
+    configs: ConfigAction[];
+    homeFiles: HomeFileAction[];
+    launchers: string[];
+    rcFiles: string[];
+}
+/** Structured result of an executed uninstall (for reporting). */
+export interface UninstallResult {
+    restoredConfigs: Array<{
+        agent: AgentId;
+        realPath: string;
+    }>;
+    removedDanglingConfigs: Array<{
+        agent: AgentId;
+        realPath: string;
+    }>;
+    restoredHomeFiles: string[];
+    releasedLaunchers: string[];
+    cleanedRcFiles: string[];
+    agentsDir: {
+        path: string;
+        disposition: 'moved' | 'purged' | 'absent';
+        movedTo?: string;
+    };
+    legacySymlinkRemoved: boolean;
+    /** True when `--purge` was requested but downgraded to move-aside after errors. */
+    purgeDowngraded: boolean;
+    errors: string[];
+}
+/**
+ * Build a read-only plan of everything a complete uninstall would change.
+ * Performs no mutations; safe to run for `--dry-run` and to print for confirm.
+ */
+export declare function planUninstall(): UninstallPlan;
+/**
+ * Execute a plan built by {@link planUninstall}. Restores adopted config dirs
+ * and home files, releases adopted launchers, strips shim PATH lines, then
+ * disposes of `~/.agents` — moved aside to `~/.agents.removed-<ts>` (recoverable)
+ * by default, or hard-deleted when `purge` is set. Config restore always runs
+ * before disposal because the backups live inside `~/.agents`.
+ */
+export declare function executeUninstall(plan: UninstallPlan, opts: {
+    purge?: boolean;
+    timestamp: number;
+}): UninstallResult;