@eide/foir-cli 0.1.33 → 0.1.35

package/dist/commands/register-commands.js

@@ -0,0 +1,259 @@
+import { readFileSync } from 'fs';
+import { resolve, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import { COMMANDS, createSchemaEngine, } from '@eide/command-registry';
+import { withErrorHandler } from '../lib/errors.js';
+import { createClient } from '../lib/client.js';
+import { formatOutput, formatList, timeAgo, success, } from '../lib/output.js';
+import { parseInputData, confirmAction, isUUID } from '../lib/input.js';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+function loadSchemaSDL() {
+    // Try monorepo path first (development)
+    const monorepoPath = resolve(__dirname, '../../../../graphql-core/schema.graphql');
+    try {
+        return readFileSync(monorepoPath, 'utf-8');
+    }
+    catch {
+        // Fall back to relative path from dist (might differ)
+        const altPath = resolve(__dirname, '../../../graphql-core/schema.graphql');
+        try {
+            return readFileSync(altPath, 'utf-8');
+        }
+        catch {
+            throw new Error('Could not find schema.graphql. Ensure you are running from within the EIDE monorepo.');
+        }
+    }
+}
+/**
+ * Extract the useful data from a GraphQL result, unwrapping list wrappers.
+ */
+function extractResult(result, operationName) {
+    const raw = result[operationName];
+    if (!raw || typeof raw !== 'object')
+        return { data: raw };
+    const obj = raw;
+    // Check for list wrappers: { items: [...], total } or { entityName: [...], total }
+    if ('total' in obj) {
+        for (const [key, val] of Object.entries(obj)) {
+            if (key !== 'total' && key !== '__typename' && Array.isArray(val)) {
+                return { data: val, total: obj.total };
+            }
+        }
+    }
+    return { data: raw };
+}
+/**
+ * Convert registry ColumnDef (with string format) to CLI ColumnDef (with format function).
+ */
+function toCliColumns(columns) {
+    if (!columns)
+        return undefined;
+    return columns.map((col) => {
+        const cliCol = {
+            key: col.key,
+            header: col.header,
+            width: col.width,
+        };
+        switch (col.format) {
+            case 'timeAgo':
+                cliCol.format = (v) => timeAgo(v);
+                break;
+            case 'boolean':
+                cliCol.format = (v) => (v ? 'yes' : '');
+                break;
+            case 'truncate':
+                cliCol.format = (v) => {
+                    const str = String(v ?? '');
+                    return str.length > 40 ? str.slice(0, 39) + '\u2026' : str;
+                };
+                break;
+            case 'join':
+                cliCol.format = (v) => Array.isArray(v) ? v.join(', ') : String(v ?? '');
+                break;
+            case 'bytes':
+                cliCol.format = (v) => {
+                    const num = Number(v);
+                    if (num < 1024)
+                        return `${num} B`;
+                    if (num < 1024 * 1024)
+                        return `${(num / 1024).toFixed(1)} KB`;
+                    return `${(num / (1024 * 1024)).toFixed(1)} MB`;
+                };
+                break;
+        }
+        return cliCol;
+    });
+}
+/**
+ * Register all declarative commands from the command registry.
+ */
+export function registerDynamicCommands(program, globalOpts) {
+    let engine;
+    try {
+        const sdl = loadSchemaSDL();
+        engine = createSchemaEngine(sdl);
+    }
+    catch (err) {
+        // If schema can't be loaded, skip dynamic command registration
+        // (special commands still work)
+        console.error(`Warning: Could not load schema for dynamic commands: ${err instanceof Error ? err.message : String(err)}`);
+        return;
+    }
+    // Group commands by group name
+    const groups = new Map();
+    for (const cmd of COMMANDS) {
+        if (!groups.has(cmd.group))
+            groups.set(cmd.group, []);
+        groups.get(cmd.group).push(cmd);
+    }
+    for (const [groupName, entries] of groups) {
+        const group = program.command(groupName).description(`Manage ${groupName}`);
+        for (const entry of entries) {
+            let cmd = group.command(entry.name).description(entry.description);
+            // Add positional args
+            for (const pos of entry.positionalArgs ?? []) {
+                cmd = cmd.argument(`<${pos.name}>`, pos.description ?? pos.name);
+            }
+            // Add flags from schema args (excluding positional args and input args)
+            const schemaArgs = engine.getOperationArgs(entry.operation, entry.operationType);
+            for (const arg of schemaArgs) {
+                // Skip if already a positional arg
+                if (entry.positionalArgs?.some((p) => p.graphqlArg === arg.name))
+                    continue;
+                // Skip if it's the input arg
+                if (entry.acceptsInput && arg.name === (entry.inputArgName ?? 'input'))
+                    continue;
+                const reqStr = arg.required ? ' (required)' : '';
+                cmd = cmd.option(`--${arg.name} <value>`, `${arg.name}${reqStr}`);
+            }
+            // Add --data/--file for input commands
+            if (entry.acceptsInput) {
+                cmd = cmd.option('-d, --data <json>', 'Data as JSON');
+                cmd = cmd.option('-f, --file <path>', 'Read data from file');
+            }
+            // Add --confirm for destructive commands
+            if (entry.requiresConfirmation) {
+                cmd = cmd.option('--confirm', 'Skip confirmation prompt');
+            }
+            // Action handler
+            cmd.action(withErrorHandler(globalOpts, async (...actionArgs) => {
+                const opts = globalOpts();
+                const client = await createClient(opts);
+                // Build variables from positional args + flags
+                const variables = {};
+                // Map positional args
+                const positionals = entry.positionalArgs ?? [];
+                for (let i = 0; i < positionals.length; i++) {
+                    const posDef = positionals[i];
+                    const value = actionArgs[i];
+                    if (value) {
+                        variables[posDef.graphqlArg] = value;
+                    }
+                }
+                // The flags/options object is the last argument from Commander
+                const flags = (actionArgs[positionals.length] ?? {});
+                // Map named flags to variables (coerce types)
+                const rawFlags = {};
+                for (const [key, val] of Object.entries(flags)) {
+                    if (key === 'data' || key === 'file' || key === 'confirm')
+                        continue;
+                    rawFlags[key] = String(val);
+                }
+                const coerced = engine.coerceArgs(entry.operation, entry.operationType, rawFlags);
+                Object.assign(variables, coerced);
+                // Handle input data (--data, --file, stdin)
+                if (entry.acceptsInput && (flags.data || flags.file)) {
+                    const inputData = await parseInputData({
+                        data: flags.data,
+                        file: flags.file,
+                    });
+                    const argName = entry.inputArgName ?? 'input';
+                    variables[argName] = inputData;
+                }
+                // Handle alternate get (by key/code instead of UUID)
+                if (entry.alternateGet &&
+                    positionals.length > 0 &&
+                    variables[positionals[0].graphqlArg]) {
+                    const firstArgValue = String(variables[positionals[0].graphqlArg]);
+                    if (!isUUID(firstArgValue)) {
+                        // Use alternate operation
+                        const altEntry = {
+                            ...entry,
+                            operation: entry.alternateGet.operation,
+                            positionalArgs: [
+                                {
+                                    name: positionals[0].name,
+                                    graphqlArg: entry.alternateGet.argName,
+                                },
+                            ],
+                        };
+                        // Remap the variable
+                        delete variables[positionals[0].graphqlArg];
+                        variables[entry.alternateGet.argName] = firstArgValue;
+                        const queryStr = engine.buildQuery(altEntry, variables);
+                        const result = (await client.request(queryStr, variables));
+                        const { data } = extractResult(result, altEntry.operation);
+                        formatOutput(data, opts);
+                        return;
+                    }
+                }
+                // Confirmation prompt for destructive actions
+                if (entry.requiresConfirmation) {
+                    const confirmed = await confirmAction(`${entry.description}?`, {
+                        confirm: !!flags.confirm,
+                    });
+                    if (!confirmed) {
+                        console.log('Aborted.');
+                        return;
+                    }
+                }
+                // Build and execute query
+                const queryStr = engine.buildQuery(entry, variables);
+                const result = (await client.request(queryStr, variables));
+                const { data, total } = extractResult(result, entry.operation);
+                // Format output
+                if (entry.scalarResult) {
+                    if (!(opts.json || opts.jsonl || opts.quiet)) {
+                        if (entry.successMessage) {
+                            success(entry.successMessage);
+                        }
+                    }
+                    else {
+                        formatOutput(data, opts);
+                    }
+                }
+                else if (Array.isArray(data)) {
+                    const cliColumns = toCliColumns(entry.columns);
+                    formatList(data, opts, {
+                        columns: cliColumns ?? autoColumns(data),
+                        total,
+                    });
+                }
+                else {
+                    formatOutput(data, opts);
+                    if (entry.successMessage &&
+                        !(opts.json || opts.jsonl || opts.quiet)) {
+                        success(entry.successMessage);
+                    }
+                }
+            }));
+        }
+    }
+}
+/**
+ * Auto-generate column definitions from the first item in an array.
+ */
+function autoColumns(items) {
+    if (items.length === 0)
+        return [];
+    const first = items[0];
+    return Object.keys(first)
+        .filter((k) => k !== '__typename')
+        .slice(0, 6)
+        .map((key) => ({
+        key,
+        header: key,
+        width: 20,
+    }));
+}

package/dist/commands/select-project.js

@@ -38,8 +38,8 @@ async function fetchSessionContext(apiUrl, accessToken) {
     return data.sessionContext;
 }
 async function fetchApiKeys(apiUrl, accessToken, projectId, tenantId) {
-    const data = await gqlRequest(apiUrl, accessToken, `query { listApiKeys(includeInactive: false, limit: 100) { apiKeys { id name isActive } } }`, undefined, { 'x-tenant-id': tenantId, 'x-project-id': projectId });
-    return data.listApiKeys?.apiKeys ?? [];
+    const data = await gqlRequest(apiUrl, accessToken, `query { listApiKeys(includeInactive: false, limit: 100) { items { id name isActive } } }`, undefined, { 'x-tenant-id': tenantId, 'x-project-id': projectId });
+    return data.listApiKeys?.items ?? [];
 }
 async function createApiKey(apiUrl, accessToken, projectId, tenantId) {
     const data = await gqlRequest(apiUrl, accessToken, `mutation($input: CreateApiKeyInput!) { createApiKey(input: $input) { apiKey { id name isActive } plainKey } }`, {