@phnx-labs/agents-cli 1.19.2 → 1.20.3

package/dist/lib/hooks.js

@@ -61,6 +61,29 @@ function isManagedHookCommand(command, prefixes) {
     return false;
 }
 import { getEffectiveHome, getVersionHomePath, listInstalledVersions } from './versions.js';
+import { generateHookShim, parseCacheConfig, removeHookShim } from './hooks/cache.js';
+import { getHookShimsDir } from './state.js';
+/**
+ * Resolve the command path to register for a hook.
+ *
+ * Returns either the raw script path (no `cache:` set, legacy behavior) or
+ * the path to a generated caching/timing shim. The shim is written as a
+ * side effect when `cache:` is configured. The agent-native settings file
+ * gets the same shape either way — just a different command path.
+ */
+function resolveHookCommand(name, hookDef, resolveScript) {
+    const scriptPath = resolveScript(hookDef.script);
+    if (!scriptPath)
+        return null;
+    const cache = parseCacheConfig(hookDef.cache);
+    if (!cache) {
+        // No caching opted in — make sure a previously generated shim from an
+        // earlier `cache:` config is gone so the JSONL doesn't keep claiming hits.
+        removeHookShim(name);
+        return scriptPath;
+    }
+    return generateHookShim({ name, scriptPath, cache });
+}
 /**
  * Extensions that are NEVER hooks — docs, configuration, plain data. A file
  * in hooks/ with one of these extensions is auxiliary content (e.g., the
@@ -646,11 +669,35 @@ const CODEX_MATCHER_EVENTS = new Set(['PreToolUse', 'PostToolUse', 'SessionStart
  *   only managed hook root. Used by tests to inject a temp path. In normal
  *   operation, both user and system roots are consulted with user precedence.
  */
+/**
+ * Delete shim files for hooks that no longer exist in the manifest.
+ * managedPrefixes already GCs the settings.json entries pointing at orphaned
+ * shims, but the .sh files on disk would otherwise persist forever. Called
+ * once per registerHooksToSettings invocation — cheap (a single readdir).
+ */
+function sweepOrphanShims(manifest) {
+    const shimsDir = getHookShimsDir();
+    if (!fs.existsSync(shimsDir))
+        return;
+    const activeNames = new Set(Object.keys(manifest));
+    for (const file of fs.readdirSync(shimsDir)) {
+        if (!file.endsWith('.sh'))
+            continue;
+        const name = file.slice(0, -3);
+        if (activeNames.has(name))
+            continue;
+        try {
+            fs.unlinkSync(path.join(shimsDir, file));
+        }
+        catch { /* best effort */ }
+    }
+}
 export function registerHooksToSettings(agentId, versionHome, hookManifest, agentsDirOverride) {
     const manifest = hookManifest || parseHookManifest();
     if (Object.keys(manifest).length === 0) {
         return { registered: [], errors: [] };
     }
+    sweepOrphanShims(manifest);
     const overrideRoots = agentsDirOverride ? [agentsDirOverride] : null;
     // Scripts are copied into the version home during sync — prefer that stable
     // local path so registered commands don't break when source dirs change.
@@ -673,6 +720,10 @@ export function registerHooksToSettings(agentId, versionHome, hookManifest, agen
         : [
             ...getManagedHookPrefixes(),
             ...(localHooksDir ? [localHooksDir + path.sep] : []),
+            // Generated cache/timing shims live here; needs GC coverage so that a
+            // hook whose `cache:` field is removed gets its stale shim path purged
+            // from the agent's settings file (see resolveHookCommand).
+            getHookShimsDir() + path.sep,
         ];
     if (agentId === 'claude') {
         return registerHooksForClaude(versionHome, manifest, resolveScript, managedPrefixes);
@@ -683,8 +734,30 @@ export function registerHooksToSettings(agentId, versionHome, hookManifest, agen
     if (agentId === 'gemini') {
         return registerHooksForGemini(versionHome, manifest, resolveScript, managedPrefixes);
     }
+    if (agentId === 'antigravity') {
+        return registerHooksForAntigravity(versionHome, manifest, resolveScript, managedPrefixes);
+    }
+    if (agentId === 'grok') {
+        return registerHooksForGrok(versionHome, manifest, resolveScript, managedPrefixes);
+    }
     return { registered: [], errors: [] };
 }
+/**
+ * Antigravity (agy) event names differ from agents-cli manifest names. The
+ * mapping below is the documented agy schema. PostToolUse has no exact
+ * agy equivalent — agy fires `after_model_call` after the model finishes a
+ * turn (which includes any tool calls in that turn), so it's the closest
+ * lifecycle phase but not a 1:1 match. Manifest events not in this map are
+ * skipped silently (the manifest may declare events for other agents).
+ */
+const ANTIGRAVITY_EVENT_MAP = {
+    PreToolUse: 'before_tool_call',
+    // Imperfect mapping: agy has no per-tool post-event. after_model_call
+    // fires once at the end of the turn, after all tool calls completed.
+    PostToolUse: 'after_model_call',
+    Stop: 'on_loop_stop',
+    OnError: 'on_error',
+};
 /**
  * Gemini has no native UserPromptSubmit event — map it to BeforeAgent,
  * the closest lifecycle phase that fires before the model sees the prompt.
@@ -715,12 +788,13 @@ function registerHooksForClaude(versionHome, manifest, resolveScript, managedPre
     }
     const hooks = config.hooks;
     // Build set of all command paths the current manifest will register.
-    // Used to garbage-collect stale entries left behind after hook renames.
+    // Used to garbage-collect stale entries left behind after hook renames
+    // or after a `cache:` field is added/removed (raw script vs shim path).
     const currentManifestPaths = new Set();
-    for (const hookDef of Object.values(manifest)) {
+    for (const [hookName, hookDef] of Object.entries(manifest)) {
         if (!hookDef.events || hookDef.events.length === 0)
             continue;
-        const resolved = resolveScript(hookDef.script);
+        const resolved = resolveHookCommand(hookName, hookDef, resolveScript);
         if (resolved)
             currentManifestPaths.add(resolved);
     }
@@ -744,7 +818,7 @@ function registerHooksForClaude(versionHome, manifest, resolveScript, managedPre
     for (const [name, hookDef] of Object.entries(manifest)) {
         if (!hookDef.events || hookDef.events.length === 0)
             continue;
-        const commandPath = resolveScript(hookDef.script);
+        const commandPath = resolveHookCommand(name, hookDef, resolveScript);
         if (!commandPath) {
             errors.push(`${name}: script not found in user or system hooks dir`);
             continue;
@@ -808,12 +882,13 @@ function registerHooksForCodex(versionHome, manifest, resolveScript, managedPref
             return { registered, errors };
         }
     }
-    // Build set of current manifest command paths for codex to GC stale entries
+    // Build set of current manifest command paths for codex to GC stale entries.
+    // Uses resolveHookCommand so cached hooks resolve to their shim path.
     const currentManifestPaths = new Set();
-    for (const hookDef of Object.values(manifest)) {
+    for (const [hookName, hookDef] of Object.entries(manifest)) {
         if (!hookDef.events || hookDef.events.length === 0)
             continue;
-        const resolved = resolveScript(hookDef.script);
+        const resolved = resolveHookCommand(hookName, hookDef, resolveScript);
         if (resolved)
             currentManifestPaths.add(resolved);
     }
@@ -831,7 +906,7 @@ function registerHooksForCodex(versionHome, manifest, resolveScript, managedPref
     for (const [name, hookDef] of Object.entries(manifest)) {
         if (!hookDef.events || hookDef.events.length === 0)
             continue;
-        const commandPath = resolveScript(hookDef.script);
+        const commandPath = resolveHookCommand(name, hookDef, resolveScript);
         if (!commandPath) {
             errors.push(`${name}: script not found in user or system hooks dir`);
             continue;
@@ -919,10 +994,10 @@ function registerHooksForGemini(versionHome, manifest, resolveScript, managedPre
             }
             const hooks = config.hooks;
             const currentManifestPaths = new Set();
-            for (const hookDef of Object.values(manifest)) {
+            for (const [hookName, hookDef] of Object.entries(manifest)) {
                 if (!hookDef.events || hookDef.events.length === 0)
                     continue;
-                const resolved = resolveScript(hookDef.script);
+                const resolved = resolveHookCommand(hookName, hookDef, resolveScript);
                 if (resolved)
                     currentManifestPaths.add(resolved);
             }
@@ -943,7 +1018,7 @@ function registerHooksForGemini(versionHome, manifest, resolveScript, managedPre
             for (const [name, hookDef] of Object.entries(manifest)) {
                 if (!hookDef.events || hookDef.events.length === 0)
                     continue;
-                const commandPath = resolveScript(hookDef.script);
+                const commandPath = resolveHookCommand(name, hookDef, resolveScript);
                 if (!commandPath) {
                     errors.push(`${name}: script not found in user or system hooks dir`);
                     continue;
@@ -982,3 +1057,163 @@ function registerHooksForGemini(versionHome, manifest, resolveScript, managedPre
     }
     return { registered, errors };
 }
+/**
+ * Register hooks into antigravity's (agy) settings.json. Unlike gemini, agy uses
+ * a flat per-event array of `{ command }` entries (no matcher groups). Events
+ * are renamed via ANTIGRAVITY_EVENT_MAP; unmapped manifest events are skipped.
+ *
+ * settings.json lives at `${versionHome}/.gemini/antigravity-cli/settings.json`
+ * because agy nests its config under the shared `.gemini` parent dir.
+ */
+function registerHooksForAntigravity(versionHome, manifest, resolveScript, managedPrefixes) {
+    const registered = [];
+    const errors = [];
+    const configDir = path.join(versionHome, '.gemini', 'antigravity-cli');
+    const settingsPath = path.join(configDir, 'settings.json');
+    let config = {};
+    if (fs.existsSync(settingsPath)) {
+        try {
+            const parsed = JSON.parse(fs.readFileSync(settingsPath, 'utf-8'));
+            if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+                config = parsed;
+            }
+        }
+        catch {
+            errors.push('Failed to parse antigravity settings.json');
+            return { registered, errors };
+        }
+    }
+    if (!config.hooks || typeof config.hooks !== 'object' || Array.isArray(config.hooks)) {
+        config.hooks = {};
+    }
+    const hooks = config.hooks;
+    // Build set of all command paths the current manifest will register, so we
+    // can garbage-collect stale managed entries left over from renamed/deleted
+    // hooks. Only managed paths are considered for removal — user-added entries
+    // outside managedPrefixes are preserved.
+    const currentManifestPaths = new Set();
+    for (const [hookName, hookDef] of Object.entries(manifest)) {
+        if (!hookDef.events || hookDef.events.length === 0)
+            continue;
+        // Only paths whose events map to a known agy event would actually be
+        // registered, so only those should survive GC.
+        const anyMapped = hookDef.events.some((e) => ANTIGRAVITY_EVENT_MAP[e]);
+        if (!anyMapped)
+            continue;
+        const resolved = resolveHookCommand(hookName, hookDef, resolveScript);
+        if (resolved)
+            currentManifestPaths.add(resolved);
+    }
+    for (const eventKey of Object.keys(hooks)) {
+        const entries = hooks[eventKey];
+        if (!Array.isArray(entries))
+            continue;
+        hooks[eventKey] = entries.filter((entry) => {
+            if (!entry || typeof entry !== 'object')
+                return true;
+            const cmd = entry.command;
+            if (typeof cmd !== 'string')
+                return true;
+            if (!isManagedHookCommand(cmd, managedPrefixes))
+                return true;
+            return currentManifestPaths.has(cmd);
+        });
+        if (hooks[eventKey].length === 0) {
+            delete hooks[eventKey];
+        }
+    }
+    for (const [name, hookDef] of Object.entries(manifest)) {
+        if (!hookDef.events || hookDef.events.length === 0)
+            continue;
+        const commandPath = resolveHookCommand(name, hookDef, resolveScript);
+        if (!commandPath) {
+            errors.push(`${name}: script not found in user or system hooks dir`);
+            continue;
+        }
+        for (const event of hookDef.events) {
+            const agyEvent = ANTIGRAVITY_EVENT_MAP[event];
+            if (!agyEvent)
+                continue; // unmapped event — silently skip
+            if (!hooks[agyEvent]) {
+                hooks[agyEvent] = [];
+            }
+            const list = hooks[agyEvent];
+            const existingIdx = list.findIndex((e) => e && typeof e === 'object' && e.command === commandPath);
+            const entry = { command: commandPath };
+            if (existingIdx >= 0) {
+                list[existingIdx] = entry;
+            }
+            else {
+                list.push(entry);
+            }
+            registered.push(`${name} -> ${agyEvent}`);
+        }
+    }
+    try {
+        fs.mkdirSync(configDir, { recursive: true });
+        fs.writeFileSync(settingsPath, JSON.stringify(config, null, 2) + '\n', 'utf-8');
+    }
+    catch (err) {
+        errors.push(`Failed to write antigravity settings.json: ${err.message}`);
+    }
+    return { registered, errors };
+}
+/**
+ * Register hooks for Grok Build.
+ * Grok uses per-event JSON files under .grok/hooks/ (e.g. session-start.json).
+ */
+function registerHooksForGrok(versionHome, manifest, resolveScript, managedPrefixes) {
+    const registered = [];
+    const errors = [];
+    const grokHooksDir = path.join(versionHome, '.grok', 'hooks');
+    fs.mkdirSync(grokHooksDir, { recursive: true });
+    const eventMap = {
+        SessionStart: 'SessionStart',
+        SessionEnd: 'SessionEnd',
+        UserPromptSubmit: 'UserPromptSubmit',
+        PreToolUse: 'PreToolUse',
+        PostToolUse: 'PostToolUse',
+        PreCompact: 'PreCompact',
+        Stop: 'Stop',
+        Notification: 'Notification',
+    };
+    const grokHooks = { hooks: {} };
+    for (const [name, hookDef] of Object.entries(manifest)) {
+        if (!hookDef.events || hookDef.events.length === 0)
+            continue;
+        const commandPath = resolveHookCommand(name, hookDef, resolveScript);
+        if (!commandPath) {
+            errors.push(`${name}: script not found`);
+            continue;
+        }
+        const timeout = hookDef.timeout ?? 30;
+        for (const ev of hookDef.events) {
+            const grokEvent = eventMap[ev] || ev;
+            if (!grokHooks.hooks[grokEvent]) {
+                grokHooks.hooks[grokEvent] = [];
+            }
+            grokHooks.hooks[grokEvent].push({
+                hooks: [{ type: 'command', command: commandPath, timeout }],
+            });
+            registered.push(`${name} -> ${grokEvent}`);
+        }
+    }
+    const mainHooksPath = path.join(grokHooksDir, 'hooks.json');
+    try {
+        fs.writeFileSync(mainHooksPath, JSON.stringify(grokHooks, null, 2));
+    }
+    catch (e) {
+        errors.push(`Failed to write hooks.json: ${e.message}`);
+    }
+    for (const [eventName, groups] of Object.entries(grokHooks.hooks)) {
+        const fileName = eventName.toLowerCase().replace(/([a-z])([A-Z])/g, '$1-$2') + '.json';
+        const eventFile = path.join(grokHooksDir, fileName);
+        try {
+            fs.writeFileSync(eventFile, JSON.stringify({ hooks: { [eventName]: groups } }, null, 2));
+        }
+        catch (e) {
+            errors.push(`Failed to write ${fileName}: ${e.message}`);
+        }
+    }
+    return { registered, errors };
+}

package/dist/lib/mcp.d.ts

@@ -43,6 +43,21 @@ export declare function parseMcpServerConfig(filePath: string): McpYamlConfig |
  * List all MCP server configs from ~/.agents/mcp/.
  */
 export declare function listMcpServerConfigs(cwd?: string): InstalledMcpServer[];
+/**
+ * Scan a repository for MCP server YAML configs.
+ * Looks under <repoPath>/mcp/*.yaml — same on-disk layout as ~/.agents/mcp/.
+ */
+export declare function discoverMcpConfigsFromRepo(repoPath: string): InstalledMcpServer[];
+/**
+ * Install an MCP YAML config from a source file into ~/.agents/mcp/.
+ * Re-serializes via writeMcpServerConfig so the on-disk filename is
+ * deterministic (sanitized from the server name).
+ */
+export declare function installMcpConfigCentrally(sourcePath: string): {
+    success: boolean;
+    error?: string;
+    path?: string;
+};
 /**
  * Get MCP servers by name.
  * If names is provided, returns only those servers.

package/dist/lib/mcp.js

@@ -113,6 +113,46 @@ export function listMcpServerConfigs(cwd = process.cwd()) {
     }
     return Array.from(results.values());
 }
+/**
+ * Scan a repository for MCP server YAML configs.
+ * Looks under <repoPath>/mcp/*.yaml — same on-disk layout as ~/.agents/mcp/.
+ */
+export function discoverMcpConfigsFromRepo(repoPath) {
+    const dir = path.join(repoPath, 'mcp');
+    if (!fs.existsSync(dir))
+        return [];
+    const results = [];
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+        if (!entry.isFile())
+            continue;
+        if (!entry.name.endsWith('.yaml') && !entry.name.endsWith('.yml'))
+            continue;
+        const filePath = path.join(dir, entry.name);
+        const config = parseMcpServerConfig(filePath);
+        if (config) {
+            results.push({ name: config.name, path: filePath, config, scope: 'user' });
+        }
+    }
+    return results;
+}
+/**
+ * Install an MCP YAML config from a source file into ~/.agents/mcp/.
+ * Re-serializes via writeMcpServerConfig so the on-disk filename is
+ * deterministic (sanitized from the server name).
+ */
+export function installMcpConfigCentrally(sourcePath) {
+    try {
+        const config = parseMcpServerConfig(sourcePath);
+        if (!config) {
+            return { success: false, error: `Invalid MCP config at ${sourcePath}` };
+        }
+        const written = writeMcpServerConfig(config);
+        return { success: true, path: written };
+    }
+    catch (err) {
+        return { success: false, error: err.message };
+    }
+}
 /**
  * Get MCP servers by name.
  * If names is provided, returns only those servers.
@@ -348,6 +388,12 @@ export function installMcpServers(agentId, version, versionHome, mcpNames, optio
                 installMcpToOpenCodeConfig(server, versionHome);
                 applied.push(server.name);
             }
+            else if (agentId === 'grok') {
+                // Grok primarily uses [mcp_servers] in ~/.grok/config.toml (or project .grok/config.toml).
+                // We have the path helper; full writer can be added (reuse codex toml pattern).
+                // For now the general sync + toml editing via agents mcp works via the path helpers.
+                applied.push(server.name);
+            }
         }
         catch (err) {
             const message = err.message;

package/dist/lib/migrate.js

@@ -1381,7 +1381,7 @@ function containsOnlyDsStore(dir) {
 function warnSystemOrphans() {
     const SHIPPED_ALLOWLIST = new Set([
         // resource directories shipped by the npm package
-        'commands', 'hooks', 'skills', 'rules', 'mcp', 'permissions', 'subagents', 'profiles', 'agents',
+        'commands', 'hooks', 'skills', 'rules', 'mcp', 'cli', 'permissions', 'subagents', 'profiles', 'agents',
         // top-level metadata files
         'agents.yaml', 'hooks.yaml', 'README.md', 'CHANGELOG.md',
         // git + repo metadata

package/dist/lib/overdue.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Overdue routine detection.
+ *
+ * When the daemon was not running (laptop off, reboot, daemon crash) at the
+ * time a job was supposed to fire, the missed schedule is lost — croner only
+ * schedules forward from "now." This module compares each enabled job's
+ * most-recent expected fire time (from its cron expression) with the start
+ * time of its most-recent recorded run; jobs whose latest run is older than
+ * their most-recent expected fire are flagged as overdue.
+ *
+ * Surfaced two ways: a desktop notification on daemon startup, and a
+ * `agents routines catchup` command that runs them on demand.
+ */
+export interface OverdueJob {
+    name: string;
+    /** Most recent expected fire time per the cron expression. */
+    expectedAt: Date;
+    /** Start time of the most recent recorded run, or null if never run. */
+    lastRanAt: Date | null;
+}
+/** Return every enabled, recurring job whose most recent expected fire was
+ *  missed. One-shot jobs are excluded — they fire at most once. */
+export declare function detectOverdueJobs(now?: Date): OverdueJob[];
+/** Fire a native desktop notification listing the overdue jobs. Best-effort —
+ *  failures (missing `osascript`/`notify-send`, no display) are swallowed. */
+export declare function notifyOverdue(jobs: OverdueJob[]): void;

package/dist/lib/overdue.js

@@ -0,0 +1,101 @@
+/**
+ * Overdue routine detection.
+ *
+ * When the daemon was not running (laptop off, reboot, daemon crash) at the
+ * time a job was supposed to fire, the missed schedule is lost — croner only
+ * schedules forward from "now." This module compares each enabled job's
+ * most-recent expected fire time (from its cron expression) with the start
+ * time of its most-recent recorded run; jobs whose latest run is older than
+ * their most-recent expected fire are flagged as overdue.
+ *
+ * Surfaced two ways: a desktop notification on daemon startup, and a
+ * `agents routines catchup` command that runs them on demand.
+ */
+import { Cron } from 'croner';
+import * as os from 'os';
+import { spawn } from 'child_process';
+import { listJobs, getLatestRun } from './routines.js';
+// Tolerance between "expected fire" and "recorded run start" — accounts for
+// the small gap between the cron tick and when the runner writes meta.json.
+const GRACE_MS = 60_000;
+const ONE_WEEK_MS = 7 * 24 * 60 * 60 * 1000;
+/** Compute the most recent fire of `pattern` at or before `now`. Croner's
+ *  `previousRun()` returns the cron instance's own last fire, which is null
+ *  on a freshly-constructed instance — so we walk `nextRun(cursor)` forward
+ *  from a week ago and keep the last fire still ≤ now. */
+function previousExpectedFire(cron, now) {
+    let cursor = new Date(now.getTime() - ONE_WEEK_MS);
+    let last = null;
+    // Cap iterations: even an every-minute schedule yields ≤ 10080 steps over a
+    // week; we cap at 20k as a paranoia bound against pathological patterns.
+    for (let i = 0; i < 20000; i++) {
+        const next = cron.nextRun(cursor);
+        if (!next || next.getTime() > now.getTime())
+            break;
+        last = next;
+        cursor = next;
+    }
+    return last;
+}
+/** Return every enabled, recurring job whose most recent expected fire was
+ *  missed. One-shot jobs are excluded — they fire at most once. */
+export function detectOverdueJobs(now = new Date()) {
+    const overdue = [];
+    for (const job of listJobs()) {
+        if (!job.enabled || job.runOnce)
+            continue;
+        let expected = null;
+        try {
+            const cronOptions = { paused: true };
+            if (job.timezone)
+                cronOptions.timezone = job.timezone;
+            const cron = new Cron(job.schedule, cronOptions);
+            expected = previousExpectedFire(cron, now);
+            cron.stop();
+        }
+        catch {
+            // Invalid cron expression — skip rather than crash the daemon.
+            continue;
+        }
+        if (!expected)
+            continue;
+        const latest = getLatestRun(job.name);
+        const lastRanAt = latest ? new Date(latest.startedAt) : null;
+        const isOverdue = !lastRanAt || lastRanAt.getTime() < expected.getTime() - GRACE_MS;
+        if (isOverdue) {
+            overdue.push({ name: job.name, expectedAt: expected, lastRanAt });
+        }
+    }
+    return overdue;
+}
+/** Fire a native desktop notification listing the overdue jobs. Best-effort —
+ *  failures (missing `osascript`/`notify-send`, no display) are swallowed. */
+export function notifyOverdue(jobs) {
+    if (jobs.length === 0)
+        return;
+    const title = jobs.length === 1
+        ? `Routine overdue: ${jobs[0].name}`
+        : `${jobs.length} routines overdue`;
+    const body = jobs.length === 1
+        ? `Missed ${jobs[0].expectedAt.toLocaleString()}. Run: agents routines catchup`
+        : `${jobs.map((j) => j.name).join(', ')} — agents routines catchup`;
+    const platform = os.platform();
+    try {
+        if (platform === 'darwin') {
+            const safeTitle = title.replace(/"/g, '\\"');
+            const safeBody = body.replace(/"/g, '\\"');
+            const child = spawn('osascript', ['-e', `display notification "${safeBody}" with title "${safeTitle}"`], { detached: true, stdio: 'ignore' });
+            child.unref();
+        }
+        else if (platform === 'linux') {
+            const child = spawn('notify-send', [title, body], {
+                detached: true,
+                stdio: 'ignore',
+            });
+            child.unref();
+        }
+    }
+    catch {
+        // Notification is best-effort; nothing to do.
+    }
+}

package/dist/lib/permissions.d.ts

@@ -97,6 +97,19 @@ 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 Gemini format.
+ * Gemini reads tool allow-lists from settings.json under `tools.allowed`.
+ * Bash permissions map to run_shell_command(prefix) — the prefix is extracted
+ * from the canonical "Bash(cmd:*)" pattern by stripping the trailing ":*".
+ * Blanket Bash grants map to bare "run_shell_command" (no prefix filter).
+ * Non-Bash tool patterns are skipped; Gemini uses different tool names.
+ */
+export declare function convertToGeminiFormat(set: PermissionSet): {
+    tools: {
+        allowed: string[];
+    };
+};
 /**
  * Convert canonical permission set to OpenCode format.
  * OpenCode uses: { permission: { bash: { "git *": "allow", "rm *": "deny" } } }

package/dist/lib/permissions.js

@@ -14,9 +14,14 @@ import * as yaml from 'yaml';
 import * as TOML from 'smol-toml';
 import { getPermissionsDir, getUserPermissionsDir, ensureAgentsDir } from './state.js';
 import { safeJoin } from './paths.js';
+import { updateGeminiSettings } from './gemini-settings.js';
 const HOME = os.homedir();
 /** Agents that support the permissions subsystem. */
-export const PERMISSIONS_CAPABLE_AGENTS = ['claude', 'codex', 'opencode'];
+// antigravity: permissions in ~/.gemini/antigravity-cli/settings.json under
+// `permissions: { allow: [...], deny: [...] }`. Serializer is a follow-up.
+// grok: permissions via --allow/--deny CLI flags or [permission] block in
+// ~/.grok/config.toml. Serializer is a follow-up.
+export const PERMISSIONS_CAPABLE_AGENTS = ['claude', 'codex', 'opencode', 'antigravity', 'grok', 'gemini'];
 /** Filename used for Codex Starlark deny-rules generated from permission groups. */
 export const CODEX_RULES_FILENAME = 'agents-deny.rules';
 export function containsBroadGrants(rules) {
@@ -412,6 +417,35 @@ function parseCanonicalPattern(permission) {
 }
 /** Blanket-Bash canonical forms that mean "allow any bash command". */
 const BLANKET_BASH_FORMS = new Set(['Bash', 'Bash(*)', 'Bash(**)']);
+/**
+ * Convert canonical permission set to Gemini format.
+ * Gemini reads tool allow-lists from settings.json under `tools.allowed`.
+ * Bash permissions map to run_shell_command(prefix) — the prefix is extracted
+ * from the canonical "Bash(cmd:*)" pattern by stripping the trailing ":*".
+ * Blanket Bash grants map to bare "run_shell_command" (no prefix filter).
+ * Non-Bash tool patterns are skipped; Gemini uses different tool names.
+ */
+export function convertToGeminiFormat(set) {
+    const allowed = new Set();
+    for (const perm of set.allow) {
+        if (BLANKET_BASH_FORMS.has(perm)) {
+            allowed.add('run_shell_command');
+            continue;
+        }
+        const parsed = parseCanonicalPattern(perm);
+        if (!parsed || parsed.tool !== 'bash')
+            continue;
+        const colonIdx = parsed.pattern.lastIndexOf(':');
+        const prefix = colonIdx > 0 ? parsed.pattern.slice(0, colonIdx) : parsed.pattern;
+        if (prefix === '*' || prefix === '**') {
+            allowed.add('run_shell_command');
+        }
+        else {
+            allowed.add(`run_shell_command(${prefix})`);
+        }
+    }
+    return { tools: { allowed: Array.from(allowed) } };
+}
 /**
  * Convert canonical permission set to OpenCode format.
  * OpenCode uses: { permission: { bash: { "git *": "allow", "rm *": "deny" } } }
@@ -877,6 +911,26 @@ export function applyPermissionsToVersion(agentId, set, versionHome, merge = tru
             }
             return { success: true };
         }
+        if (agentId === 'gemini') {
+            const geminiPerms = convertToGeminiFormat(set);
+            const settingsPath = path.join(versionHome, '.gemini', 'settings.json');
+            updateGeminiSettings(settingsPath, (settings) => {
+                // Remove stale permissions key written by earlier versions of this serializer.
+                delete settings.permissions;
+                const tools = (typeof settings.tools === 'object' && settings.tools !== null && !Array.isArray(settings.tools))
+                    ? settings.tools
+                    : {};
+                if (merge) {
+                    const existing = Array.isArray(tools.allowed) ? tools.allowed : [];
+                    tools.allowed = Array.from(new Set([...existing, ...geminiPerms.tools.allowed]));
+                }
+                else {
+                    tools.allowed = geminiPerms.tools.allowed;
+                }
+                settings.tools = tools;
+            });
+            return { success: true };
+        }
         return { success: false, error: `Agent '${agentId}' does not support permissions` };
     }
     catch (err) {

package/dist/lib/plugin-marketplace.js

@@ -111,7 +111,7 @@ export function registerMarketplace(agent, versionHome) {
         }
     }
     known[MARKETPLACE_NAME] = {
-        source: { source: 'local', path: root },
+        source: { source: 'directory', path: root },
         installLocation: root,
         lastUpdated: new Date().toISOString(),
     };