@phnx-labs/agents-cli 1.20.4 → 1.20.6

package/dist/lib/migrate.js

@@ -8,11 +8,76 @@ import * as fs from 'fs';
 import * as path from 'path';
 import * as os from 'os';
 import * as yaml from 'yaml';
+import { AGENTS, agentConfigDirName } from './agents.js';
 const HOME = process.env.HOME ?? os.homedir();
-const SYSTEM_DIR = path.join(HOME, '.agents-system');
 const USER_DIR = path.join(HOME, '.agents');
+/** Canonical system-repo location (post-fold). */
+const SYSTEM_DIR = path.join(USER_DIR, '.system');
+/** Legacy system-repo location — folded into SYSTEM_DIR by foldLegacySystemRepo(). */
+const LEGACY_SYSTEM_DIR = path.join(HOME, '.agents-system');
 const HISTORY_DIR = path.join(USER_DIR, '.history');
 const CACHE_DIR = path.join(USER_DIR, '.cache');
+/**
+ * Fold ~/.agents-system/ into ~/.agents/.system/.
+ *
+ * MUST run first in runMigration() — every other migrator reads SYSTEM_DIR
+ * (the new path), so the contents have to be there before they execute.
+ *
+ * Strategy:
+ *   1. If legacy dir doesn't exist or is already a symlink, no-op.
+ *   2. If new path doesn't exist yet, rename in one shot (fast path).
+ *   3. If both exist (mid-migration / re-run on partially-migrated state),
+ *      merge legacy → new with new winning on collision, then drop legacy.
+ *
+ * After the contents move, the legacy path becomes a symlink → SYSTEM_DIR
+ * so external tooling that still references ~/.agents-system/ keeps
+ * resolving correctly. The symlink is harmless on its own and can be
+ * removed with `rm ~/.agents-system` once everything has updated.
+ *
+ * Idempotent: re-running converges to "contents at SYSTEM_DIR, symlink at
+ * LEGACY_SYSTEM_DIR" without duplicating data.
+ */
+export function foldLegacySystemRepo() {
+    let legacyStat = null;
+    try {
+        legacyStat = fs.lstatSync(LEGACY_SYSTEM_DIR);
+    }
+    catch { /* missing */ }
+    if (!legacyStat)
+        return;
+    if (legacyStat.isSymbolicLink())
+        return;
+    if (!legacyStat.isDirectory())
+        return;
+    try {
+        fs.mkdirSync(USER_DIR, { recursive: true, mode: 0o700 });
+    }
+    catch { /* best-effort */ }
+    if (!fs.existsSync(SYSTEM_DIR)) {
+        try {
+            fs.renameSync(LEGACY_SYSTEM_DIR, SYSTEM_DIR);
+            try {
+                fs.symlinkSync(SYSTEM_DIR, LEGACY_SYSTEM_DIR);
+            }
+            catch { /* best-effort */ }
+            console.error('Folded ~/.agents-system/ into ~/.agents/.system/ (left back-compat symlink)');
+            return;
+        }
+        catch {
+            // Cross-device rename or perm issue — fall through to copy + remove.
+        }
+    }
+    try {
+        copyDirSkipExisting(LEGACY_SYSTEM_DIR, SYSTEM_DIR);
+        fs.rmSync(LEGACY_SYSTEM_DIR, { recursive: true, force: true });
+        try {
+            fs.symlinkSync(SYSTEM_DIR, LEGACY_SYSTEM_DIR);
+        }
+        catch { /* best-effort */ }
+        console.error('Merged ~/.agents-system/ into ~/.agents/.system/ (left back-compat symlink)');
+    }
+    catch { /* best-effort */ }
+}
 /**
  * Move ~/.agents-system/agents.yaml -> ~/.agents/agents.yaml.
  * No-op if user file already exists or system file absent.
@@ -608,12 +673,13 @@ function repairAgentConfigSymlinks() {
     }
     let repaired = 0;
     for (const { agent, version } of defaults) {
-        const userTarget = fs.existsSync(path.join(HISTORY_DIR, 'versions', agent, version, 'home', `.${agent}`))
-            ? path.join(HISTORY_DIR, 'versions', agent, version, 'home', `.${agent}`)
-            : path.join(USER_DIR, 'versions', agent, version, 'home', `.${agent}`);
+        const configDirName = agent in AGENTS ? agentConfigDirName(agent) : `.${agent}`;
+        const userTarget = fs.existsSync(path.join(HISTORY_DIR, 'versions', agent, version, 'home', configDirName))
+            ? path.join(HISTORY_DIR, 'versions', agent, version, 'home', configDirName)
+            : path.join(USER_DIR, 'versions', agent, version, 'home', configDirName);
         if (!fs.existsSync(userTarget))
             continue;
-        const symlinkPath = path.join(HOME, `.${agent}`);
+        const symlinkPath = path.join(HOME, configDirName);
         let stat = null;
         try {
             stat = fs.lstatSync(symlinkPath);
@@ -1461,8 +1527,166 @@ function migrateVersionResourcesToPatterns() {
         console.error('Migrated agents.yaml versions: entries to pattern format');
     }
 }
+/**
+ * Rename the legacy `extras-extras/` plugin-marketplace dir to `agents-extras/`
+ * inside every installed agent version-home, and rewrite cross-references in
+ * `known_marketplaces.json` and the agent's `settings.json`.
+ *
+ * A previous dev build of `agents-cli` named the extras-aliased repo's
+ * synthesized marketplace dir `extras-extras` (double "extras" because the alias
+ * itself was `extras`). The new naming convention is `agents-<alias>`, so the
+ * directory should be `agents-extras`. Without this migration the orphan dir
+ * stays on disk and Claude Code loads two parallel marketplaces (the legacy
+ * `extras-extras` entry from `known_marketplaces.json` plus the freshly
+ * synthesized `agents-extras` from the new code path).
+ *
+ * Strategy per `<historyDir>/versions/<agent>/<ver>/home/.<agent>/plugins/`:
+ *   1. `marketplaces/extras-extras/` → `marketplaces/agents-extras/`
+ *      (drops `extras-extras/` outright when `agents-extras/` already exists —
+ *      previous incomplete migration ran)
+ *   2. Inside the renamed dir's `.claude-plugin/marketplace.json`, set
+ *      `"name": "agents-extras"`.
+ *   3. In `<configDir>/plugins/known_marketplaces.json`, rename the
+ *      `extras-extras` key to `agents-extras` and rewrite `source.path` /
+ *      `installLocation`.
+ *   4. In `<configDir>/settings.json`'s `enabledPlugins`, rename every
+ *      `<plugin>@extras-extras` key to `<plugin>@agents-extras` (preserving
+ *      its boolean value, skipping if the new key already exists).
+ *
+ * Idempotent: re-running converges without further writes once everything is on
+ * the new name.
+ */
+export function migrateExtrasExtrasToAgentsExtras(historyDir = HISTORY_DIR) {
+    const versionsRoot = path.join(historyDir, 'versions');
+    if (!fs.existsSync(versionsRoot))
+        return;
+    const OLD = 'extras-extras';
+    const NEW = 'agents-extras';
+    let agentEntries;
+    try {
+        agentEntries = fs.readdirSync(versionsRoot, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    let renamedDirs = 0;
+    let rewroteKnown = 0;
+    let rewroteSettings = 0;
+    for (const agentEntry of agentEntries) {
+        if (!agentEntry.isDirectory())
+            continue;
+        const agentId = agentEntry.name;
+        const agentVersionsDir = path.join(versionsRoot, agentId);
+        let verEntries;
+        try {
+            verEntries = fs.readdirSync(agentVersionsDir, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const ver of verEntries) {
+            if (!ver.isDirectory())
+                continue;
+            const configDir = path.join(agentVersionsDir, ver.name, 'home', `.${agentId}`);
+            const pluginsDir = path.join(configDir, 'plugins');
+            if (!fs.existsSync(pluginsDir))
+                continue;
+            const marketplacesDir = path.join(pluginsDir, 'marketplaces');
+            const oldDir = path.join(marketplacesDir, OLD);
+            const newDir = path.join(marketplacesDir, NEW);
+            const oldExists = fs.existsSync(oldDir);
+            const newExists = fs.existsSync(newDir);
+            if (oldExists && !newExists) {
+                try {
+                    fs.renameSync(oldDir, newDir);
+                    renamedDirs++;
+                }
+                catch { /* best-effort, leave orphan */ }
+            }
+            else if (oldExists && newExists) {
+                // Previous incomplete migration — drop the stale old dir.
+                try {
+                    fs.rmSync(oldDir, { recursive: true, force: true });
+                }
+                catch { /* best-effort */ }
+            }
+            // Rewrite marketplace.json name field inside the (now) agents-extras dir.
+            const marketplaceJson = path.join(newDir, '.claude-plugin', 'marketplace.json');
+            if (fs.existsSync(marketplaceJson)) {
+                try {
+                    const raw = fs.readFileSync(marketplaceJson, 'utf-8');
+                    const parsed = JSON.parse(raw);
+                    if (parsed?.name === OLD) {
+                        parsed.name = NEW;
+                        fs.writeFileSync(marketplaceJson, JSON.stringify(parsed, null, 2) + '\n', 'utf-8');
+                    }
+                }
+                catch { /* best-effort */ }
+            }
+            // Rewrite known_marketplaces.json key + path fields.
+            const knownFile = path.join(pluginsDir, 'known_marketplaces.json');
+            if (fs.existsSync(knownFile)) {
+                try {
+                    const raw = fs.readFileSync(knownFile, 'utf-8');
+                    const known = JSON.parse(raw);
+                    if (known && typeof known === 'object' && OLD in known) {
+                        const entry = known[OLD];
+                        if (!(NEW in known)) {
+                            if (entry?.source?.path)
+                                entry.source.path = entry.source.path.split(OLD).join(NEW);
+                            if (entry?.installLocation)
+                                entry.installLocation = entry.installLocation.split(OLD).join(NEW);
+                            known[NEW] = entry;
+                        }
+                        delete known[OLD];
+                        fs.writeFileSync(knownFile, JSON.stringify(known, null, 2) + '\n', 'utf-8');
+                        rewroteKnown++;
+                    }
+                }
+                catch { /* best-effort */ }
+            }
+            // Rewrite settings.json enabledPlugins keys.
+            const settingsFile = path.join(configDir, 'settings.json');
+            if (fs.existsSync(settingsFile)) {
+                try {
+                    const raw = fs.readFileSync(settingsFile, 'utf-8');
+                    const settings = JSON.parse(raw);
+                    const enabled = settings?.enabledPlugins;
+                    if (enabled && typeof enabled === 'object') {
+                        const suffix = `@${OLD}`;
+                        const newSuffix = `@${NEW}`;
+                        let changed = false;
+                        for (const key of Object.keys(enabled)) {
+                            if (!key.endsWith(suffix))
+                                continue;
+                            const renamed = key.slice(0, -suffix.length) + newSuffix;
+                            if (renamed in enabled) {
+                                delete enabled[key];
+                            }
+                            else {
+                                enabled[renamed] = enabled[key];
+                                delete enabled[key];
+                            }
+                            changed = true;
+                        }
+                        if (changed) {
+                            fs.writeFileSync(settingsFile, JSON.stringify(settings, null, 2) + '\n', 'utf-8');
+                            rewroteSettings++;
+                        }
+                    }
+                }
+                catch { /* best-effort */ }
+            }
+        }
+    }
+    if (renamedDirs > 0 || rewroteKnown > 0 || rewroteSettings > 0) {
+        console.error(`Renamed extras-extras → agents-extras (dirs: ${renamedDirs}, known_marketplaces: ${rewroteKnown}, settings: ${rewroteSettings})`);
+    }
+}
 /** Run all idempotent migrations. Safe to call multiple times. */
 export async function runMigration() {
+    // MUST run first: every other migrator reads SYSTEM_DIR (the new path).
+    foldLegacySystemRepo();
     migrateAgentsYaml();
     deleteSystemPromptsJson();
     migrateSystemConfigJson();
@@ -1503,6 +1727,10 @@ export async function runMigration() {
     await migrateSystemCloudToCache();
     dropDeadSystemArtifacts();
     warnSystemOrphans();
+    // Rename the legacy extras-extras marketplace dir to agents-extras across every
+    // installed version-home. Runs after migrateRuntimeToHistory so the version
+    // homes are at their canonical HISTORY_DIR location.
+    migrateExtrasExtrasToAgentsExtras();
     // Symlink repair runs LAST so it can find the post-move version homes.
     repairAgentConfigSymlinks();
 }

package/dist/lib/models.js

@@ -78,27 +78,72 @@ export function locateModelSource(agent, version) {
         return null;
     }
     if (agent === 'codex') {
+        // Codex's vendored binary has moved across releases:
+        //   <=0.98:     @openai/codex/vendor/<triple>/codex/codex
+        //   0.99..0.13: @openai/codex-<plat>-<arch>/vendor/<triple>/codex/codex
+        //   0.134+:     @openai/codex-<plat>-<arch>/vendor/<triple>/bin/codex
+        // We probe all known shapes; first hit wins.
+        const triples = ['aarch64-apple-darwin', 'x86_64-apple-darwin', 'x86_64-unknown-linux-musl', 'aarch64-unknown-linux-musl', 'x86_64-pc-windows-msvc', 'aarch64-pc-windows-msvc'];
         const triple = currentTargetTriple();
-        if (triple) {
-            const platformPkg = path.join(versionDir, 'node_modules', '@openai', `codex-${triple.includes('apple') ? 'darwin' : triple.includes('linux') ? 'linux' : 'win32'}-${triple.includes('aarch64') ? 'arm64' : 'x64'}`, 'vendor', triple, 'codex', 'codex');
-            if (fs.existsSync(platformPkg))
-                return { path: platformPkg, kind: 'binary' };
-        }
-        // 0.98 layout: binary inside @openai/codex itself
-        const triples = ['aarch64-apple-darwin', 'x86_64-apple-darwin', 'x86_64-unknown-linux-musl', 'aarch64-unknown-linux-musl'];
-        for (const t of triples) {
-            const p = path.join(versionDir, 'node_modules', '@openai', 'codex', 'vendor', t, 'codex', 'codex');
-            if (fs.existsSync(p))
-                return { path: p, kind: 'binary' };
+        const orderedTriples = triple ? [triple, ...triples.filter((t) => t !== triple)] : triples;
+        const platformPkgFor = (t) => `codex-${t.includes('apple') ? 'darwin' : t.includes('linux') ? 'linux' : 'win32'}-${t.includes('aarch64') ? 'arm64' : 'x64'}`;
+        for (const t of orderedTriples) {
+            const candidates = [
+                path.join(versionDir, 'node_modules', '@openai', platformPkgFor(t), 'vendor', t, 'bin', 'codex'),
+                path.join(versionDir, 'node_modules', '@openai', platformPkgFor(t), 'vendor', t, 'codex', 'codex'),
+                path.join(versionDir, 'node_modules', '@openai', 'codex', 'vendor', t, 'bin', 'codex'),
+                path.join(versionDir, 'node_modules', '@openai', 'codex', 'vendor', t, 'codex', 'codex'),
+            ];
+            for (const p of candidates) {
+                if (fs.existsSync(p))
+                    return { path: p, kind: 'binary' };
+            }
         }
         return null;
     }
     if (agent === 'gemini') {
-        // Gemini ships a clean ES module with all constants and aliases -- no need
-        // to parse the minified CLI bundle.
+        // <=0.41 shipped a clean ES module at @google/gemini-cli-core/dist/src/config/models.js.
+        // 0.42+ inlines the same constants into a minified chunk under @google/gemini-cli/bundle/.
         const modelsJs = path.join(versionDir, 'node_modules', '@google', 'gemini-cli-core', 'dist', 'src', 'config', 'models.js');
         if (fs.existsSync(modelsJs))
             return { path: modelsJs, kind: 'js' };
+        const bundleDir = path.join(versionDir, 'node_modules', '@google', 'gemini-cli', 'bundle');
+        if (fs.existsSync(bundleDir)) {
+            try {
+                const entries = fs.readdirSync(bundleDir);
+                // The model constants live in a single chunk; pick the first .js file
+                // whose contents contain VALID_GEMINI_MODELS. Skip subdirectories.
+                for (const name of entries) {
+                    if (!name.endsWith('.js'))
+                        continue;
+                    const full = path.join(bundleDir, name);
+                    let stat;
+                    try {
+                        stat = fs.statSync(full);
+                    }
+                    catch {
+                        continue;
+                    }
+                    if (!stat.isFile())
+                        continue;
+                    // Most chunks just re-export the constants; only the defining chunk
+                    // actually has `var VALID_GEMINI_MODELS = ... new Set(`. Match that
+                    // shape so we pick the chunk that the extractor can parse.
+                    let body;
+                    try {
+                        body = fs.readFileSync(full, 'utf-8');
+                    }
+                    catch {
+                        continue;
+                    }
+                    if (/var\s+VALID_GEMINI_MODELS\s*=[^\n]*new\s+Set/.test(body) &&
+                        /var\s+DEFAULT_GEMINI_MODEL\s*=/.test(body)) {
+                        return { path: full, kind: 'js' };
+                    }
+                }
+            }
+            catch { /* unreadable bundle dir */ }
+        }
         return null;
     }
     if (agent === 'opencode') {
@@ -296,7 +341,9 @@ function extractCodexCatalog(text) {
  * would pollute the runtime and ES-module interop is awkward from a CJS build).
  */
 function extractGeminiCatalog(text) {
-    const constRe = /export\s+const\s+([A-Z0-9_]+)\s*=\s*'([^']+)'/g;
+    // Old (<=0.41) layout used `export const FOO = 'bar';` in models.js.
+    // New (0.42+) bundle inlines the same constants as `var FOO = "bar";`.
+    const constRe = /(?:export\s+const|var)\s+([A-Z0-9_]+)\s*=\s*['"]([^'"]+)['"]/g;
     const constants = new Map();
     let m;
     while ((m = constRe.exec(text)) !== null) {
@@ -305,7 +352,7 @@ function extractGeminiCatalog(text) {
     // The set of ids the CLI accepts as "valid model names". Names (not values)
     // are listed inside `new Set([...])`, so we expand them via the constants map.
     const validIds = new Set();
-    const setBlock = text.match(/VALID_GEMINI_MODELS\s*=\s*new\s+Set\(\[([\s\S]*?)\]\)/);
+    const setBlock = text.match(/VALID_GEMINI_MODELS\s*=\s*(?:\/\*[^*]*\*\/\s*)?new\s+Set\(\[([\s\S]*?)\]\)/);
     if (setBlock) {
         const nameRe = /([A-Z0-9_]+)/g;
         let nm;

package/dist/lib/permissions.d.ts

@@ -1,6 +1,4 @@
 import type { AgentId, PermissionSet, InstalledPermission, ClaudePermissions, OpenCodePermissions, CodexPermissions } from './types.js';
-/** Agents that support the permissions subsystem. */
-export declare const PERMISSIONS_CAPABLE_AGENTS: AgentId[];
 /** Filename used for Codex Starlark deny-rules generated from permission groups. */
 export declare const CODEX_RULES_FILENAME = "agents-deny.rules";
 export type ParsedRules = PermissionSet;
@@ -110,6 +108,65 @@ export declare function convertToGeminiFormat(set: PermissionSet): {
         allowed: string[];
     };
 };
+/**
+ * Convert canonical permission set to Antigravity format.
+ * Antigravity reads ~/.gemini/antigravity-cli/settings.json with
+ *   { permissions: { allow: [...], deny: [...] } }
+ * where each entry is action-namespaced: command(...), read_file(...),
+ * write_file(...), read_url(...), mcp(...).
+ * Bash maps to `command`, Read to `read_file`, Write to `write_file`,
+ * WebFetch to `read_url`. Other canonical tools are skipped.
+ * Note: Antigravity matches `command(npm install)` as an exact string,
+ * not a prefix — `Bash(npm:*)` becomes `command(npm *)` which is a glob
+ * but Antigravity upstream has a known exact-match bug for some forms.
+ */
+export declare function convertToAntigravityFormat(set: PermissionSet): {
+    permissions: {
+        allow: string[];
+        deny?: string[];
+    };
+};
+/**
+ * Convert canonical permission set to Grok format.
+ * Grok reads ~/.grok/config.toml with
+ *   [permission]
+ *   rules = [ { action = "allow", tool = "bash", pattern = "git *" }, ... ]
+ * Tool names are lowercase: bash, read, edit, grep, mcptool, webfetch.
+ * Canonical Write maps to Grok's `edit` tool.
+ */
+export declare function convertToGrokFormat(set: PermissionSet): {
+    permission: {
+        rules: GrokRule[];
+    };
+};
+export type GrokRule = {
+    action: 'allow' | 'deny';
+    tool: string;
+    pattern?: string;
+};
+export type KimiRule = {
+    decision: 'allow' | 'deny';
+    pattern: string;
+};
+/**
+ * Convert a canonical permission set to Kimi Code's `[permission].rules` format.
+ * Kimi (`~/.kimi-code/config.toml`) reads rules of the form
+ *   [[permission.rules]]
+ *   decision = "allow"
+ *   pattern  = "Bash(git status*)"
+ * Tool names are capitalized and the Bash arg-glob uses a trailing `*` (no
+ * Claude `:*` separator). Without this conversion the canonical strings match
+ * nothing in Kimi's engine and every tool call falls through to a prompt.
+ *
+ * Each `:*` Bash rule expands to TWO patterns (`cmd*` and `cmd*​/**`) so the
+ * command auto-approves whether or not its arguments contain a slash — see
+ * `kimiBashPatterns` for why Kimi's picomatch matcher needs both.
+ */
+export declare function convertToKimiFormat(set: PermissionSet): {
+    permission: {
+        rules: KimiRule[];
+    };
+};
 /**
  * Convert canonical permission set to OpenCode format.
  * OpenCode uses: { permission: { bash: { "git *": "allow", "rm *": "deny" } } }