@phnx-labs/agents-cli 0.1.0 → 1.14.1

package/dist/lib/pty-server.js

@@ -6,14 +6,51 @@
  * across multiple CLI invocations. Each session holds a real PTY (via node-pty)
  * and a headless terminal emulator (via @xterm/headless) for screen rendering.
  *
- * Protocol: newline-delimited JSON over ~/.agents/pty.sock
+ * Protocol: newline-delimited JSON over ~/.agents-system/pty.sock
  */
 import * as net from 'net';
 import * as fs from 'fs';
 import * as path from 'path';
 import * as crypto from 'crypto';
+import { execFileSync } from 'child_process';
 import { fileURLToPath } from 'url';
 import { getAgentsDir } from './state.js';
+/**
+ * Capture a stable identifier for a process at the moment it was started.
+ * Used to defeat PID reuse: a kill(pid, ...) is only safe when the process
+ * still occupies the PID we observed at spawn time.
+ *
+ * Linux:  field 22 of /proc/<pid>/stat (starttime in clock ticks since boot).
+ * macOS:  output of `ps -o lstart= -p <pid>` (start time in human format).
+ * Returns null on any error so callers can skip the guard rather than crash.
+ */
+export function captureProcessStartTime(pid) {
+    if (!pid || pid <= 0)
+        return null;
+    try {
+        if (process.platform === 'linux') {
+            const stat = fs.readFileSync(`/proc/${pid}/stat`, 'utf-8');
+            // The comm field (#2) is wrapped in parens and may contain spaces, so
+            // split off everything after the last `)` to get a clean field list.
+            const lastParen = stat.lastIndexOf(')');
+            if (lastParen < 0)
+                return null;
+            const tail = stat.slice(lastParen + 2);
+            const fields = tail.split(' ');
+            // After comm we are at field 3; starttime is field 22, so index 19 here.
+            return fields[19] || null;
+        }
+        const out = execFileSync('ps', ['-o', 'lstart=', '-p', String(pid)], {
+            encoding: 'utf-8',
+            stdio: ['ignore', 'pipe', 'ignore'],
+        });
+        const trimmed = out.trim();
+        return trimmed.length > 0 ? trimmed : null;
+    }
+    catch {
+        return null;
+    }
+}
 // --- Constants ---
 const SENTINEL = '__AGENTS_PTY_DONE__';
 const SOCKET_NAME = 'pty.sock';
@@ -22,15 +59,39 @@ const LOG_FILE = 'pty.log';
 const SESSION_IDLE_MS = 30 * 60 * 1000; // 30 min
 const SERVER_IDLE_MS = 60 * 60 * 1000; // 1 hour
 // --- Path helpers ---
+/** Env vars forwarded into PTY sessions. Excludes API tokens, cloud creds, etc. */
+const PTY_ENV_ALLOWLIST = [
+    'HOME', 'PATH', 'SHELL', 'USER', 'LOGNAME',
+    'TERM', 'TERM_PROGRAM', 'TERM_PROGRAM_VERSION', 'COLORTERM',
+    'LANG', 'LC_ALL', 'LC_CTYPE', 'LC_MESSAGES', 'TZ',
+    'TMPDIR',
+    'XDG_RUNTIME_DIR', 'XDG_CONFIG_HOME', 'XDG_DATA_HOME', 'XDG_CACHE_HOME',
+    'NODE_PATH', 'NVM_DIR', 'BUN_INSTALL',
+    'EDITOR', 'VISUAL', 'PAGER', 'LESS',
+    'NO_COLOR', 'FORCE_COLOR',
+];
+function buildPtyEnv() {
+    const env = {};
+    for (const key of PTY_ENV_ALLOWLIST) {
+        const v = process.env[key];
+        if (v !== undefined)
+            env[key] = v;
+    }
+    return env;
+}
+/** Get the unix socket path for the PTY server. */
 export function getSocketPath() {
     return path.join(getAgentsDir(), SOCKET_NAME);
 }
+/** Get the path to the PTY server PID file. */
 export function getPtyPidPath() {
     return path.join(getAgentsDir(), PID_FILE);
 }
+/** Get the path to the PTY server log file. */
 export function getPtyLogPath() {
     return path.join(getAgentsDir(), LOG_FILE);
 }
+/** Check if the PTY server process is alive by probing the stored PID. */
 export function isPtyServerRunning() {
     const pidPath = getPtyPidPath();
     if (!fs.existsSync(pidPath))
@@ -60,6 +121,7 @@ function log(level, message) {
     catch { }
 }
 // --- Server ---
+/** Start the PTY sidecar server, listening on the unix socket for JSON requests. */
 export async function runPtyServer() {
     // Dynamic imports for optional native deps
     let nodePty;
@@ -177,7 +239,7 @@ export async function runPtyServer() {
                         cols,
                         rows,
                         cwd,
-                        env: { ...process.env },
+                        env: buildPtyEnv(),
                     });
                 }
                 catch (err) {
@@ -193,6 +255,7 @@ export async function runPtyServer() {
                     shell,
                     cwd,
                     pid: ptyProcess.pid,
+                    startTime: captureProcessStartTime(ptyProcess.pid),
                     startedAt: Date.now(),
                     lastActivity: Date.now(),
                     pendingOutput: '',
@@ -308,6 +371,18 @@ export async function runPtyServer() {
                 if (!['INT', 'TERM', 'KILL', 'HUP'].includes(sig)) {
                     return { ok: false, error: `Unsupported signal: ${sig}` };
                 }
+                // Guard against PID reuse: confirm the PID is still owned by the
+                // process we spawned. If the start-time we captured at spawn no
+                // longer matches /proc or `ps`, treat the session as exited and
+                // refuse to signal — otherwise we'd kill an unrelated process that
+                // happens to have inherited this PID.
+                if (session.startTime !== null) {
+                    const current = captureProcessStartTime(session.pid);
+                    if (current === null || current !== session.startTime) {
+                        session.exited = true;
+                        return { ok: false, error: 'Session has exited' };
+                    }
+                }
                 try {
                     // node-pty kill accepts signal number; use process.kill for named signals
                     process.kill(session.pid, `SIG${sig}`);
@@ -389,9 +464,24 @@ export async function runPtyServer() {
         });
         conn.on('error', () => { });
     });
+    // Lock down ~/.agents-system/ before opening the socket — without this, any local
+    // user with execute on the parent dir could connect to the socket during
+    // the listen()-to-chmod() window. macOS BSD AF_UNIX semantics make socket
+    // mode advisory only, so the parent dir is the real boundary.
+    const agentsDir = getAgentsDir();
+    fs.mkdirSync(agentsDir, { recursive: true });
+    fs.chmodSync(agentsDir, 0o700);
+    // umask covers any inherited group/other bits while listen() is creating
+    // the socket inode — it only matters for the unobservable instant before
+    // we can chmod the inode itself.
+    process.umask(0o077);
     await new Promise((resolve) => {
         server.listen(socketPath, () => resolve());
     });
+    // Surface chmod failures: a 0o600 socket is a load-bearing security
+    // assumption, not a nice-to-have. If we can't lock it down, refuse to
+    // start so the caller learns immediately.
+    fs.chmodSync(socketPath, 0o600);
     // Write PID
     fs.writeFileSync(getPtyPidPath(), String(process.pid), 'utf-8');
     log('INFO', `PTY server started (PID: ${process.pid}, socket: ${socketPath})`);
@@ -419,4 +509,3 @@ export async function runPtyServer() {
     // Keep alive
     await new Promise(() => { });
 }
-//# sourceMappingURL=pty-server.js.map

package/dist/lib/registry.d.ts

@@ -1,28 +1,48 @@
-import type { RegistryType, RegistryConfig, McpServerEntry, RegistrySearchResult, ResolvedPackage } from './types.js';
+/**
+ * Package registry client -- search, resolve, and install from remote registries.
+ *
+ * Queries the MCP registry (registry.modelcontextprotocol.io) and future skill
+ * registries to find packages, then resolves them into installable entries
+ * with transport, runtime, and argument metadata.
+ */
+import type { RegistryType, RegistryConfig, McpServerEntry, SkillEntry, RegistrySearchResult, ResolvedPackage } from './types.js';
+/** Get all registries of a given type, merging defaults with user overrides. */
 export declare function getRegistries(type: RegistryType): Record<string, RegistryConfig>;
+/** Get only the enabled registries of a given type. */
 export declare function getEnabledRegistries(type: RegistryType): Array<{
     name: string;
     config: RegistryConfig;
 }>;
+/** Add or update a registry configuration in agents.yaml. */
 export declare function setRegistry(type: RegistryType, name: string, config: Partial<RegistryConfig>): void;
+/** Remove a user-configured registry. Returns false if it did not exist. */
 export declare function removeRegistry(type: RegistryType, name: string): boolean;
+/** Search MCP registries for servers matching a query string. */
 export declare function searchMcpRegistries(query: string, options?: {
     registry?: string;
     limit?: number;
 }): Promise<RegistrySearchResult[]>;
+/** Look up detailed info for an MCP server by exact name. */
 export declare function getMcpServerInfo(serverName: string, registryName?: string): Promise<McpServerEntry | null>;
-export declare function searchSkillRegistries(_query: string, _options?: {
+/** Search skill registries for entries matching a query string. */
+export declare function searchSkillRegistries(query: string, options?: {
     registry?: string;
     limit?: number;
 }): Promise<RegistrySearchResult[]>;
+/** Look up a skill by identifier (or name) across enabled skill registries. */
+export declare function getSkillEntry(skillIdentifier: string, registryName?: string): Promise<SkillEntry | null>;
+/** Derive a cloneable git source from a skill entry's repo/source metadata. */
+export declare function skillEntryToGitSource(entry: SkillEntry): string | null;
+/** Unified search across all enabled registries of the specified type(s). */
 export declare function search(query: string, options?: {
     type?: RegistryType;
     registry?: string;
     limit?: number;
 }): Promise<RegistrySearchResult[]>;
+/** Parse a package identifier into its type (mcp, skill, git) and name. */
 export declare function parsePackageIdentifier(identifier: string): {
     type: RegistryType | 'git' | 'unknown';
     name: string;
 };
+/** Resolve a package identifier to an installable package with source metadata. */
 export declare function resolvePackage(identifier: string): Promise<ResolvedPackage | null>;
-//# sourceMappingURL=registry.d.ts.map

package/dist/lib/registry.js

@@ -1,6 +1,14 @@
+/**
+ * Package registry client -- search, resolve, and install from remote registries.
+ *
+ * Queries the MCP registry (registry.modelcontextprotocol.io) and future skill
+ * registries to find packages, then resolves them into installable entries
+ * with transport, runtime, and argument metadata.
+ */
 import * as fs from 'fs';
 import { DEFAULT_REGISTRIES } from './types.js';
 import { readMeta, writeMeta } from './state.js';
+/** Get all registries of a given type, merging defaults with user overrides. */
 export function getRegistries(type) {
     const meta = readMeta();
     const defaultRegs = DEFAULT_REGISTRIES[type] || {};
@@ -8,12 +16,14 @@ export function getRegistries(type) {
     // Merge defaults with user config (user overrides defaults)
     return { ...defaultRegs, ...userRegs };
 }
+/** Get only the enabled registries of a given type. */
 export function getEnabledRegistries(type) {
     const registries = getRegistries(type);
     return Object.entries(registries)
         .filter(([, config]) => config.enabled)
         .map(([name, config]) => ({ name, config }));
 }
+/** Add or update a registry configuration in agents.yaml. */
 export function setRegistry(type, name, config) {
     const meta = readMeta();
     if (!meta.registries) {
@@ -26,6 +36,7 @@ export function setRegistry(type, name, config) {
     meta.registries[type][name] = { ...existing, ...config };
     writeMeta(meta);
 }
+/** Remove a user-configured registry. Returns false if it did not exist. */
 export function removeRegistry(type, name) {
     const meta = readMeta();
     if (meta.registries?.[type]?.[name]) {
@@ -53,6 +64,7 @@ async function fetchMcpRegistry(url, query, limit = 20, apiKey) {
     }
     return response.json();
 }
+/** Search MCP registries for servers matching a query string. */
 export async function searchMcpRegistries(query, options) {
     const registries = getEnabledRegistries('mcp');
     const results = [];
@@ -86,6 +98,7 @@ export async function searchMcpRegistries(query, options) {
     }
     return results;
 }
+/** Look up detailed info for an MCP server by exact name. */
 export async function getMcpServerInfo(serverName, registryName) {
     const registries = getEnabledRegistries('mcp');
     const targetRegistries = registryName
@@ -108,16 +121,134 @@ export async function getMcpServerInfo(serverName, registryName) {
     }
     return null;
 }
-export async function searchSkillRegistries(_query, _options) {
+const skillIndexCache = new Map();
+const SKILL_INDEX_TTL_MS = 10 * 60_000;
+/** Fetch and cache a flat skill-index JSON document. */
+async function fetchSkillIndex(url, apiKey) {
+    const cached = skillIndexCache.get(url);
+    if (cached && Date.now() - cached.fetchedAt < SKILL_INDEX_TTL_MS) {
+        return cached.doc;
+    }
+    const headers = { Accept: 'application/json' };
+    if (apiKey)
+        headers['Authorization'] = `Bearer ${apiKey}`;
+    const response = await fetch(url, { headers });
+    if (!response.ok) {
+        throw new Error(`Registry request failed: ${response.status} ${response.statusText}`);
+    }
+    const doc = (await response.json());
+    skillIndexCache.set(url, { fetchedAt: Date.now(), doc });
+    return doc;
+}
+/** Map a raw skill-index row into the canonical SkillEntry shape. */
+function normalizeSkillEntry(raw) {
+    return {
+        name: raw.name,
+        description: raw.description,
+        source: raw.source || 'unknown',
+        identifier: raw.identifier,
+        repo: raw.repo || undefined,
+        path: raw.path || undefined,
+        author: raw.author,
+        installs: raw.installs,
+        tags: raw.tags,
+        trustLevel: raw.trust_level,
+    };
+}
+/** Case-insensitive substring match against the fields users expect to search. */
+function skillMatchesQuery(entry, query) {
+    if (!query)
+        return true;
+    const q = query.toLowerCase();
+    const haystack = [
+        entry.name,
+        entry.identifier,
+        entry.description,
+        entry.source,
+        ...(entry.tags || []),
+    ]
+        .filter(Boolean)
+        .join(' ')
+        .toLowerCase();
+    return haystack.includes(q);
+}
+/** Search skill registries for entries matching a query string. */
+export async function searchSkillRegistries(query, options) {
     const registries = getEnabledRegistries('skill');
-    if (registries.length === 0) {
-        // No skill registries configured - this is expected for now
+    if (registries.length === 0)
+        return [];
+    const targetRegistries = options?.registry
+        ? registries.filter((r) => r.name === options.registry)
+        : registries;
+    if (targetRegistries.length === 0) {
+        if (options?.registry) {
+            throw new Error(`Registry '${options.registry}' not found or not enabled`);
+        }
         return [];
     }
-    // Future: implement skill registry API calls when available
-    // For now, skill: prefix falls back to git sources
-    return [];
+    const limit = options?.limit ?? 20;
+    const results = [];
+    for (const { name, config } of targetRegistries) {
+        try {
+            const doc = await fetchSkillIndex(config.url, config.apiKey);
+            for (const raw of doc.skills || []) {
+                const entry = normalizeSkillEntry(raw);
+                if (!skillMatchesQuery(entry, query))
+                    continue;
+                results.push({
+                    name: entry.identifier || entry.name,
+                    description: entry.description,
+                    type: 'skill',
+                    source: entry.source,
+                    registry: name,
+                    installs: entry.installs,
+                });
+                if (results.length >= limit)
+                    break;
+            }
+            if (results.length >= limit)
+                break;
+        }
+        catch (err) {
+            console.error(`Failed to search ${name}: ${err.message}`);
+        }
+    }
+    return results;
+}
+/** Look up a skill by identifier (or name) across enabled skill registries. */
+export async function getSkillEntry(skillIdentifier, registryName) {
+    const registries = getEnabledRegistries('skill');
+    const targets = registryName
+        ? registries.filter((r) => r.name === registryName)
+        : registries;
+    for (const { config } of targets) {
+        try {
+            const doc = await fetchSkillIndex(config.url, config.apiKey);
+            const match = (doc.skills || []).find((s) => s.identifier === skillIdentifier || s.name === skillIdentifier);
+            if (match)
+                return normalizeSkillEntry(match);
+        }
+        catch {
+            /* try next registry */
+        }
+    }
+    return null;
+}
+/** Derive a cloneable git source from a skill entry's repo/source metadata. */
+export function skillEntryToGitSource(entry) {
+    if (entry.repo) {
+        // Already an owner/repo; cloneRepo understands the `gh:` shorthand.
+        return `gh:${entry.repo.replace(/\.git$/, '')}`;
+    }
+    if (entry.source === 'official') {
+        // Hermes 'official' entries live in NousResearch/hermes-agent; the path
+        // sits under optional-skills/. cloneRepo pulls the whole repo — the
+        // per-path narrowing is a follow-on improvement.
+        return 'gh:NousResearch/hermes-agent';
+    }
+    return null;
 }
+/** Unified search across all enabled registries of the specified type(s). */
 export async function search(query, options) {
     const results = [];
     if (!options?.type || options.type === 'mcp') {
@@ -130,6 +261,7 @@ export async function search(query, options) {
     }
     return results;
 }
+/** Parse a package identifier into its type (mcp, skill, git) and name. */
 export function parsePackageIdentifier(identifier) {
     // mcp:filesystem -> MCP registry
     if (identifier.startsWith('mcp:')) {
@@ -161,6 +293,7 @@ export function parsePackageIdentifier(identifier) {
     // Single word -> search MCP registries first
     return { type: 'unknown', name: identifier };
 }
+/** Resolve a package identifier to an installable package with source metadata. */
 export async function resolvePackage(identifier) {
     const parsed = parsePackageIdentifier(identifier);
     if (parsed.type === 'git') {
@@ -178,7 +311,20 @@ export async function resolvePackage(identifier) {
         return null;
     }
     if (parsed.type === 'skill') {
-        // Skill registries not available yet, treat as git source
+        const entry = await getSkillEntry(parsed.name);
+        if (entry) {
+            const gitSource = skillEntryToGitSource(entry);
+            if (gitSource) {
+                return {
+                    type: 'skill',
+                    source: gitSource,
+                    skillEntry: entry,
+                };
+            }
+            // Entry found but has no installable repo (e.g. lobehub-only listings).
+            return null;
+        }
+        // Fall back to git shorthand when the identifier isn't in any registry.
         const gitSource = parsed.name.startsWith('gh:') ? parsed.name : `gh:${parsed.name}`;
         return { type: 'git', source: gitSource };
     }
@@ -200,4 +346,3 @@ export async function resolvePackage(identifier) {
     }
     return null;
 }
-//# sourceMappingURL=registry.js.map

package/dist/lib/resources.d.ts

@@ -4,19 +4,46 @@
  */
 import type { AgentId } from './types.js';
 import { type SkillParseError } from './skills.js';
+/** Resource kind — matches the subdirectory name under each repo root. */
+export type ResourceKind = 'commands' | 'skills' | 'hooks' | 'rules' | 'mcp' | 'permissions' | 'subagents' | 'profiles' | 'secrets';
+/** A resource resolved with its origin. */
+export interface ResolvedResource {
+    name: string;
+    /** Absolute path to the resource file or directory. */
+    path: string;
+    source: 'project' | 'user' | 'system';
+}
+/**
+ * Resolve a single resource by kind + name using project > user > system precedence.
+ * For file-based resources the path ends in `.md`, `.yaml`, or `.yml` as appropriate.
+ * Returns null when the resource does not exist in any scope.
+ *
+ * Extra repos are searched last (after system) to match syncResourcesToVersion order.
+ */
+export declare function resolveResource(kind: ResourceKind, name: string, cwd?: string): ResolvedResource | null;
+/**
+ * List all resources of a given kind across project, user, and system scopes.
+ * Returns a deduplicated union (project wins on name collision), each entry
+ * annotated with its origin source.
+ */
+export declare function listResources(kind: ResourceKind, cwd?: string): ResolvedResource[];
+/** A single installed resource (command, skill, memory file, or hook). */
 export interface ResourceEntry {
     name: string;
     path: string;
     scope: 'user' | 'project';
 }
+/** A skill resource entry with optional rule count. */
 export interface SkillResourceEntry extends ResourceEntry {
     ruleCount?: number;
 }
+/** An MCP server resource entry. */
 export interface McpResourceEntry {
     name: string;
     scope: 'user' | 'project';
     version?: string;
 }
+/** All resources installed for a specific agent. */
 export interface AgentResources {
     agentId: AgentId;
     commands: ResourceEntry[];
@@ -26,6 +53,7 @@ export interface AgentResources {
     memory: ResourceEntry[];
     hooks: ResourceEntry[];
 }
+/** Options for resource discovery. */
 export interface GetAgentResourcesOptions {
     cwd?: string;
     scope?: 'user' | 'project' | 'all';
@@ -47,4 +75,3 @@ export declare function getAllAgentResources(agentIds: AgentId[], options?: GetA
         installed: boolean;
     }>;
 }): AgentResources[];
-//# sourceMappingURL=resources.d.ts.map

package/dist/lib/resources.js

@@ -2,6 +2,8 @@
  * Unified resource discovery for agents.
  * Scans filesystem (source of truth) to find all installed resources for an agent.
  */
+import * as fs from 'fs';
+import * as path from 'path';
 import { AGENTS, listInstalledMcpsWithScope } from './agents.js';
 import { listInstalledCommandsWithScope } from './commands.js';
 import { listInstalledSkillsWithScope } from './skills.js';
@@ -9,6 +11,83 @@ import { listInstalledHooksWithScope } from './hooks.js';
 import { listInstalledInstructionsWithScope } from './memory.js';
 import { getEffectiveHome } from './versions.js';
 import { listMcpServerConfigs } from './mcp.js';
+import { getProjectAgentsDir, getUserAgentsDir, getSystemAgentsDir, getEnabledExtraRepos, } from './state.js';
+/**
+ * Resolve a single resource by kind + name using project > user > system precedence.
+ * For file-based resources the path ends in `.md`, `.yaml`, or `.yml` as appropriate.
+ * Returns null when the resource does not exist in any scope.
+ *
+ * Extra repos are searched last (after system) to match syncResourcesToVersion order.
+ */
+export function resolveResource(kind, name, cwd) {
+    const projectDir = getProjectAgentsDir(cwd);
+    const extraRepos = getEnabledExtraRepos();
+    const candidates = [
+        ...(projectDir ? [[path.join(projectDir, kind), 'project']] : []),
+        [path.join(getUserAgentsDir(), kind), 'user'],
+        [path.join(getSystemAgentsDir(), kind), 'system'],
+        ...extraRepos.map((e) => [path.join(e.dir, kind), 'system']),
+    ];
+    for (const [dir, source] of candidates) {
+        if (!fs.existsSync(dir))
+            continue;
+        // Try exact name (for directories like skills/subagents)
+        const exactPath = path.join(dir, name);
+        if (fs.existsSync(exactPath)) {
+            return { name, path: exactPath, source };
+        }
+        // Try with common file extensions
+        for (const ext of ['.md', '.yaml', '.yml']) {
+            const withExt = exactPath + ext;
+            if (fs.existsSync(withExt)) {
+                return { name, path: withExt, source };
+            }
+        }
+    }
+    return null;
+}
+/**
+ * List all resources of a given kind across project, user, and system scopes.
+ * Returns a deduplicated union (project wins on name collision), each entry
+ * annotated with its origin source.
+ */
+export function listResources(kind, cwd) {
+    const seen = new Set();
+    const results = [];
+    const projectDir = getProjectAgentsDir(cwd);
+    const extraRepos = getEnabledExtraRepos();
+    const roots = [
+        ...(projectDir ? [[path.join(projectDir, kind), 'project']] : []),
+        [path.join(getUserAgentsDir(), kind), 'user'],
+        [path.join(getSystemAgentsDir(), kind), 'system'],
+        ...extraRepos.map((e) => [path.join(e.dir, kind), 'system']),
+    ];
+    for (const [dir, source] of roots) {
+        if (!fs.existsSync(dir))
+            continue;
+        let entries;
+        try {
+            entries = fs.readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            if (entry.name.startsWith('.'))
+                continue;
+            const rawName = entry.name.replace(/\.(md|yaml|yml)$/, '');
+            if (seen.has(rawName))
+                continue;
+            seen.add(rawName);
+            results.push({
+                name: rawName,
+                path: path.join(dir, entry.name),
+                source,
+            });
+        }
+    }
+    return results;
+}
 /**
  * Get all resources installed for a specific agent by scanning the filesystem.
  * This is the source of truth - not the tracking data in agents.yaml.
@@ -100,4 +179,3 @@ export function getAllAgentResources(agentIds, options = {}) {
         return getAgentResources(agentId, { ...restOptions, cliInstalled });
     });
 }
-//# sourceMappingURL=resources.js.map