agentspd 1.0.0

package/dist/api.js

@@ -0,0 +1,171 @@
+import { getApiUrl, getAuthHeader, isAuthenticated } from './config.js';
+class EmotosApiClient {
+    async request(method, path, body, requireAuth = true) {
+        if (requireAuth && !isAuthenticated()) {
+            return {
+                error: { message: 'Not authenticated. Run `emotos auth login` first.', code: 'NOT_AUTHENTICATED' },
+                status: 401,
+            };
+        }
+        const url = `${getApiUrl()}/v1${path}`;
+        const headers = {
+            'Content-Type': 'application/json',
+            ...getAuthHeader(),
+        };
+        try {
+            const response = await fetch(url, {
+                method,
+                headers,
+                body: body ? JSON.stringify(body) : undefined,
+            });
+            const data = await response.json().catch(() => ({}));
+            if (!response.ok) {
+                return {
+                    error: {
+                        message: data.error || data.message || `Request failed with status ${response.status}`,
+                        code: data.code,
+                    },
+                    status: response.status,
+                };
+            }
+            return { data, status: response.status };
+        }
+        catch (error) {
+            return {
+                error: {
+                    message: error instanceof Error ? error.message : 'Network error',
+                    code: 'NETWORK_ERROR',
+                },
+                status: 0,
+            };
+        }
+    }
+    // Auth endpoints
+    async login(email, password) {
+        return this.request('POST', '/auth/login', { email, password }, false);
+    }
+    async signup(data) {
+        return this.request('POST', '/auth/signup', data, false);
+    }
+    async logout() {
+        return this.request('POST', '/auth/logout');
+    }
+    async me() {
+        return this.request('GET', '/auth/me');
+    }
+    // Agent endpoints
+    async createAgent(data) {
+        return this.request('POST', '/agents', data);
+    }
+    async listAgents(params) {
+        const query = new URLSearchParams();
+        if (params?.environment)
+            query.set('environment', params.environment);
+        if (params?.status)
+            query.set('status', params.status);
+        if (params?.limit)
+            query.set('limit', String(params.limit));
+        if (params?.offset)
+            query.set('offset', String(params.offset));
+        const queryStr = query.toString();
+        return this.request('GET', `/agents${queryStr ? `?${queryStr}` : ''}`);
+    }
+    async getAgent(agentId) {
+        return this.request('GET', `/agents/${agentId}`);
+    }
+    async issueToken(agentId, ttlSeconds) {
+        return this.request('POST', `/agents/${agentId}/token`, { ttlSeconds });
+    }
+    async revokeAgent(agentId) {
+        return this.request('POST', `/agents/${agentId}/revoke`);
+    }
+    async rotateCredentials(agentId) {
+        return this.request('POST', `/agents/${agentId}/rotate`);
+    }
+    // Policy endpoints
+    async createPolicy(data) {
+        return this.request('POST', '/policies', data);
+    }
+    async listPolicies() {
+        return this.request('GET', '/policies');
+    }
+    async getPolicy(policyId) {
+        return this.request('GET', `/policies/${policyId}`);
+    }
+    async updatePolicy(policyId, content) {
+        return this.request('PUT', `/policies/${policyId}`, { content });
+    }
+    async validatePolicy(content) {
+        return this.request('POST', '/policies/validate', { content });
+    }
+    async activatePolicy(policyId) {
+        return this.request('POST', `/policies/${policyId}/activate`);
+    }
+    async deactivatePolicy(policyId) {
+        return this.request('POST', `/policies/${policyId}/deactivate`);
+    }
+    // Audit endpoints
+    async queryAuditEvents(params) {
+        const query = new URLSearchParams();
+        if (params?.agentId)
+            query.set('agentId', params.agentId);
+        if (params?.eventType)
+            query.set('eventType', params.eventType);
+        if (params?.startTime)
+            query.set('startTime', params.startTime);
+        if (params?.endTime)
+            query.set('endTime', params.endTime);
+        if (params?.limit)
+            query.set('limit', String(params.limit));
+        const queryStr = query.toString();
+        return this.request('GET', `/audit/events${queryStr ? `?${queryStr}` : ''}`);
+    }
+    async getAuditEvent(eventId) {
+        return this.request('GET', `/audit/events/${eventId}`);
+    }
+    // Threat endpoints
+    async listThreats(params) {
+        const query = new URLSearchParams();
+        if (params?.agentId)
+            query.set('agentId', params.agentId);
+        if (params?.severity)
+            query.set('severity', params.severity);
+        if (params?.status)
+            query.set('status', params.status);
+        if (params?.limit)
+            query.set('limit', String(params.limit));
+        const queryStr = query.toString();
+        return this.request('GET', `/threats${queryStr ? `?${queryStr}` : ''}`);
+    }
+    async resolveThreat(threatId) {
+        return this.request('POST', `/threats/${threatId}/resolve`);
+    }
+    // Webhook endpoints
+    async createWebhook(data) {
+        return this.request('POST', '/webhooks', data);
+    }
+    async listWebhooks() {
+        return this.request('GET', '/webhooks');
+    }
+    async deleteWebhook(webhookId) {
+        return this.request('DELETE', `/webhooks/${webhookId}`);
+    }
+    async testWebhook(webhookId) {
+        return this.request('POST', `/webhooks/${webhookId}/test`);
+    }
+    // Organization endpoints
+    async getOrganization() {
+        return this.request('GET', '/org');
+    }
+    async updateOrganization(data) {
+        return this.request('PUT', '/org', data);
+    }
+    async rotateOrgApiKey() {
+        return this.request('POST', '/org/rotate-key');
+    }
+    // Metrics endpoints
+    async getMetrics() {
+        return this.request('GET', '/metrics');
+    }
+}
+export const api = new EmotosApiClient();

package/dist/commands/agents.d.ts

@@ -0,0 +1,3 @@
+import { Command } from 'commander';
+export declare function createAgentsCommand(): Command;
+//# sourceMappingURL=agents.d.ts.map

package/dist/commands/agents.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agents.d.ts","sourceRoot":"","sources":["../../src/commands/agents.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAOpC,wBAAgB,mBAAmB,IAAI,OAAO,CA8S7C"}

package/dist/commands/agents.js

@@ -0,0 +1,277 @@
+import { Command } from 'commander';
+import inquirer from 'inquirer';
+import ora from 'ora';
+import { api } from '../api.js';
+import * as output from '../output.js';
+import { getConfig } from '../config.js';
+export function createAgentsCommand() {
+    const agents = new Command('agents')
+        .alias('agent')
+        .description('Manage AI agents');
+    agents
+        .command('create')
+        .alias('register')
+        .description('Register a new AI agent')
+        .option('-n, --name <name>', 'Agent name')
+        .option('-d, --description <desc>', 'Agent description')
+        .option('-e, --environment <env>', 'Environment (development, staging, production)')
+        .option('-p, --policy <policyId>', 'Policy ID to assign')
+        .option('--json', 'Output as JSON')
+        .action(async (options) => {
+        let name = options.name;
+        let description = options.description;
+        let environment = options.environment;
+        let policyId = options.policy;
+        // Interactive prompts
+        if (!name) {
+            const answers = await inquirer.prompt([
+                {
+                    type: 'input',
+                    name: 'name',
+                    message: 'Agent name:',
+                    validate: (input) => input.length > 0 || 'Name is required',
+                },
+            ]);
+            name = answers.name;
+        }
+        if (!description) {
+            const answers = await inquirer.prompt([
+                {
+                    type: 'input',
+                    name: 'description',
+                    message: 'Description (optional):',
+                },
+            ]);
+            description = answers.description || undefined;
+        }
+        if (!environment) {
+            const answers = await inquirer.prompt([
+                {
+                    type: 'list',
+                    name: 'environment',
+                    message: 'Environment:',
+                    choices: ['development', 'staging', 'production'],
+                    default: getConfig().defaultEnvironment,
+                },
+            ]);
+            environment = answers.environment;
+        }
+        const spinner = ora('Registering agent...').start();
+        const result = await api.createAgent({
+            name,
+            description,
+            environment,
+            policyId,
+        });
+        if (result.error) {
+            spinner.fail('Failed to register agent');
+            output.error(result.error.message);
+            return;
+        }
+        spinner.succeed('Agent registered successfully!');
+        if (options.json) {
+            output.printJson(result.data);
+        }
+        else if (result.data) {
+            console.log();
+            output.printKeyValue([
+                ['Agent ID', result.data.id],
+                ['Name', result.data.name],
+                ['Status', result.data.status],
+                ['Environment', result.data.environment],
+                ['Reputation', `${result.data.reputationScore}/100`],
+            ]);
+            // Show the API key if returned
+            const apiKey = result.data.metadata?.apiKey;
+            if (apiKey && typeof apiKey === 'string') {
+                output.printSecret('API Key', apiKey);
+            }
+            console.log();
+            output.info('Next steps:');
+            console.log(`  1. Issue a token: ${output.highlight(`emotos agents token ${result.data.id}`)}`);
+            console.log(`  2. Connect to proxy: ${output.highlight('wss://proxy.emotos.ai/v1/mcp')}`);
+        }
+    });
+    agents
+        .command('list')
+        .alias('ls')
+        .description('List all agents')
+        .option('-e, --environment <env>', 'Filter by environment')
+        .option('-s, --status <status>', 'Filter by status (active, suspended, revoked)')
+        .option('-l, --limit <n>', 'Limit results', '20')
+        .option('--json', 'Output as JSON')
+        .action(async (options) => {
+        const spinner = ora('Fetching agents...').start();
+        const result = await api.listAgents({
+            environment: options.environment,
+            status: options.status,
+            limit: Number.parseInt(options.limit, 10),
+        });
+        if (result.error) {
+            spinner.fail('Failed to fetch agents');
+            output.error(result.error.message);
+            return;
+        }
+        spinner.stop();
+        if (options.json) {
+            output.printJson(result.data);
+        }
+        else if (result.data) {
+            if (result.data.items.length === 0) {
+                output.info('No agents found');
+                output.info('Create one with: emotos agents create');
+                return;
+            }
+            output.heading(`Agents (${result.data.total} total)`);
+            output.printAgentTable(result.data.items);
+        }
+    });
+    agents
+        .command('get <agentId>')
+        .alias('show')
+        .description('Get agent details')
+        .option('--json', 'Output as JSON')
+        .action(async (agentId, options) => {
+        const spinner = ora('Fetching agent...').start();
+        const result = await api.getAgent(agentId);
+        if (result.error) {
+            spinner.fail('Failed to fetch agent');
+            output.error(result.error.message);
+            return;
+        }
+        spinner.stop();
+        if (options.json) {
+            output.printJson(result.data);
+        }
+        else if (result.data) {
+            output.heading(`Agent: ${result.data.name}`);
+            output.printKeyValue([
+                ['ID', result.data.id],
+                ['Name', result.data.name],
+                ['Description', result.data.description],
+                ['Status', output.formatStatus(result.data.status)],
+                ['Environment', output.formatEnvironment(result.data.environment)],
+                ['Reputation', output.formatReputation(result.data.reputationScore)],
+                ['Policy ID', result.data.policyId],
+                ['Created', output.formatDate(result.data.createdAt)],
+                ['Updated', result.data.updatedAt ? output.formatDate(result.data.updatedAt) : undefined],
+            ]);
+        }
+    });
+    agents
+        .command('token <agentId>')
+        .alias('issue-token')
+        .description('Issue a JWT token for an agent')
+        .option('-t, --ttl <seconds>', 'Token TTL in seconds', '3600')
+        .option('--json', 'Output as JSON')
+        .action(async (agentId, options) => {
+        const spinner = ora('Issuing token...').start();
+        const result = await api.issueToken(agentId, Number.parseInt(options.ttl, 10));
+        if (result.error) {
+            spinner.fail('Failed to issue token');
+            output.error(result.error.message);
+            return;
+        }
+        spinner.succeed('Token issued successfully');
+        if (options.json) {
+            output.printJson(result.data);
+        }
+        else if (result.data) {
+            output.printSecret('JWT Token', result.data.token);
+            output.info(`Expires: ${output.formatDate(result.data.expiresAt)}`);
+            console.log();
+            output.info('Usage:');
+            console.log('  Connect to MCP proxy with this token:');
+            console.log();
+            console.log(output.highlight('  const ws = new WebSocket("wss://proxy.emotos.ai/v1/mcp", {'));
+            console.log(output.highlight('    headers: { "Authorization": "Bearer <token>" }'));
+            console.log(output.highlight('  });'));
+        }
+    });
+    agents
+        .command('revoke <agentId>')
+        .description('Revoke an agent and all its tokens')
+        .option('-f, --force', 'Skip confirmation')
+        .action(async (agentId, options) => {
+        if (!options.force) {
+            const answers = await inquirer.prompt([
+                {
+                    type: 'confirm',
+                    name: 'confirm',
+                    message: `Are you sure you want to revoke agent ${agentId}? This cannot be undone.`,
+                    default: false,
+                },
+            ]);
+            if (!answers.confirm) {
+                output.info('Operation cancelled');
+                return;
+            }
+        }
+        const spinner = ora('Revoking agent...').start();
+        const result = await api.revokeAgent(agentId);
+        if (result.error) {
+            spinner.fail('Failed to revoke agent');
+            output.error(result.error.message);
+            return;
+        }
+        spinner.succeed('Agent revoked successfully');
+        if (result.data) {
+            output.info(`Revoked at: ${output.formatDate(result.data.revokedAt)}`);
+        }
+    });
+    agents
+        .command('rotate <agentId>')
+        .description('Rotate agent credentials')
+        .option('--json', 'Output as JSON')
+        .action(async (agentId, options) => {
+        const spinner = ora('Rotating credentials...').start();
+        const result = await api.rotateCredentials(agentId);
+        if (result.error) {
+            spinner.fail('Failed to rotate credentials');
+            output.error(result.error.message);
+            return;
+        }
+        spinner.succeed('Credentials rotated successfully');
+        if (options.json) {
+            output.printJson(result.data);
+        }
+        else if (result.data) {
+            output.printSecret('New API Key', result.data.apiKey);
+            output.printSecret('New JWT Token', result.data.token);
+            output.info(`Token expires: ${output.formatDate(result.data.expiresAt)}`);
+        }
+    });
+    agents
+        .command('monitor <agentId>')
+        .description('Monitor agent activity in real-time')
+        .option('-l, --limit <n>', 'Number of events to show', '10')
+        .action(async (agentId, options) => {
+        output.heading(`Monitoring agent: ${agentId}`);
+        output.info('Press Ctrl+C to stop');
+        console.log();
+        const fetchEvents = async () => {
+            const result = await api.queryAuditEvents({
+                agentId,
+                limit: Number.parseInt(options.limit, 10),
+            });
+            if (result.data && result.data.items.length > 0) {
+                output.printAuditTable(result.data.items);
+            }
+            else {
+                output.dim('No recent events');
+            }
+        };
+        // Initial fetch
+        await fetchEvents();
+        // Poll every 5 seconds
+        const interval = setInterval(fetchEvents, 5000);
+        // Handle Ctrl+C
+        process.on('SIGINT', () => {
+            clearInterval(interval);
+            console.log();
+            output.info('Monitoring stopped');
+            process.exit(0);
+        });
+    });
+    return agents;
+}

package/dist/commands/audit.d.ts

@@ -0,0 +1,3 @@
+import { Command } from 'commander';
+export declare function createAuditCommand(): Command;
+//# sourceMappingURL=audit.d.ts.map

package/dist/commands/audit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"audit.d.ts","sourceRoot":"","sources":["../../src/commands/audit.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAKpC,wBAAgB,kBAAkB,IAAI,OAAO,CAwM5C"}

package/dist/commands/audit.js

@@ -0,0 +1,181 @@
+import { Command } from 'commander';
+import ora from 'ora';
+import { api } from '../api.js';
+import * as output from '../output.js';
+export function createAuditCommand() {
+    const audit = new Command('audit')
+        .description('Query audit logs');
+    audit
+        .command('events')
+        .alias('list')
+        .description('Query audit events')
+        .option('-a, --agent <agentId>', 'Filter by agent ID')
+        .option('-t, --type <eventType>', 'Filter by event type')
+        .option('--start <date>', 'Start time (ISO 8601)')
+        .option('--end <date>', 'End time (ISO 8601)')
+        .option('-l, --limit <n>', 'Limit results', '50')
+        .option('--json', 'Output as JSON')
+        .action(async (options) => {
+        const spinner = ora('Fetching audit events...').start();
+        const result = await api.queryAuditEvents({
+            agentId: options.agent,
+            eventType: options.type,
+            startTime: options.start,
+            endTime: options.end,
+            limit: Number.parseInt(options.limit, 10),
+        });
+        if (result.error) {
+            spinner.fail('Failed to fetch audit events');
+            output.error(result.error.message);
+            return;
+        }
+        spinner.stop();
+        if (options.json) {
+            output.printJson(result.data);
+        }
+        else if (result.data) {
+            if (result.data.items.length === 0) {
+                output.info('No audit events found');
+                return;
+            }
+            output.heading(`Audit Events (${result.data.total} total)`);
+            output.printAuditTable(result.data.items);
+        }
+    });
+    audit
+        .command('get <eventId>')
+        .alias('show')
+        .description('Get audit event details')
+        .option('--json', 'Output as JSON')
+        .action(async (eventId, options) => {
+        const spinner = ora('Fetching audit event...').start();
+        const result = await api.getAuditEvent(eventId);
+        if (result.error) {
+            spinner.fail('Failed to fetch audit event');
+            output.error(result.error.message);
+            return;
+        }
+        spinner.stop();
+        if (options.json) {
+            output.printJson(result.data);
+        }
+        else if (result.data) {
+            output.heading('Audit Event');
+            output.printKeyValue([
+                ['ID', result.data.id],
+                ['Agent ID', result.data.agentId],
+                ['Event Type', result.data.eventType],
+                ['Timestamp', output.formatDate(result.data.timestamp)],
+                ['Signature', result.data.signature ? 'Verified' : 'Not signed'],
+            ]);
+            if (result.data.requestData) {
+                console.log();
+                output.heading('Request Data');
+                output.printJson(result.data.requestData);
+            }
+            if (result.data.responseData) {
+                console.log();
+                output.heading('Response Data');
+                output.printJson(result.data.responseData);
+            }
+        }
+    });
+    audit
+        .command('export')
+        .description('Export audit events to file')
+        .option('-a, --agent <agentId>', 'Filter by agent ID')
+        .option('--start <date>', 'Start time (ISO 8601)')
+        .option('--end <date>', 'End time (ISO 8601)')
+        .option('-o, --output <path>', 'Output file path', 'audit-export.json')
+        .option('-f, --format <format>', 'Output format (json, csv)', 'json')
+        .action(async (options) => {
+        const spinner = ora('Exporting audit events...').start();
+        let allEvents = [];
+        let cursor;
+        let hasMore = true;
+        while (hasMore) {
+            const result = await api.queryAuditEvents({
+                agentId: options.agent,
+                startTime: options.start,
+                endTime: options.end,
+                limit: 100,
+            });
+            if (result.error) {
+                spinner.fail('Failed to export audit events');
+                output.error(result.error.message);
+                return;
+            }
+            if (result.data) {
+                allEvents = [...allEvents, ...result.data.items];
+                hasMore = result.data.hasMore;
+                cursor = result.data.cursor;
+                spinner.text = `Exporting audit events... (${allEvents.length} events)`;
+            }
+            else {
+                hasMore = false;
+            }
+        }
+        // Write to file
+        const fs = await import('node:fs');
+        if (options.format === 'csv') {
+            const events = allEvents;
+            const csv = [
+                'id,agentId,eventType,timestamp',
+                ...events.map(e => `${e.id},${e.agentId},${e.eventType},${e.timestamp}`),
+            ].join('\n');
+            fs.writeFileSync(options.output, csv);
+        }
+        else {
+            fs.writeFileSync(options.output, JSON.stringify(allEvents, null, 2));
+        }
+        spinner.succeed(`Exported ${allEvents.length} events to ${options.output}`);
+    });
+    audit
+        .command('stats')
+        .description('Show audit statistics')
+        .option('--start <date>', 'Start time (ISO 8601)')
+        .option('--end <date>', 'End time (ISO 8601)')
+        .action(async (options) => {
+        const spinner = ora('Calculating statistics...').start();
+        const result = await api.queryAuditEvents({
+            startTime: options.start,
+            endTime: options.end,
+            limit: 1000,
+        });
+        if (result.error) {
+            spinner.fail('Failed to fetch audit events');
+            output.error(result.error.message);
+            return;
+        }
+        spinner.stop();
+        if (result.data) {
+            const events = result.data.items;
+            const byType = {};
+            const byAgent = {};
+            for (const event of events) {
+                byType[event.eventType] = (byType[event.eventType] || 0) + 1;
+                byAgent[event.agentId] = (byAgent[event.agentId] || 0) + 1;
+            }
+            output.heading('Audit Statistics');
+            output.printKeyValue([
+                ['Total Events', result.data.total],
+                ['Unique Event Types', Object.keys(byType).length],
+                ['Unique Agents', Object.keys(byAgent).length],
+            ]);
+            console.log();
+            output.heading('Events by Type');
+            const typeRows = Object.entries(byType)
+                .sort((a, b) => b[1] - a[1])
+                .map(([type, count]) => [type, String(count)]);
+            output.printTable(['Event Type', 'Count'], typeRows);
+            console.log();
+            output.heading('Events by Agent');
+            const agentRows = Object.entries(byAgent)
+                .sort((a, b) => b[1] - a[1])
+                .slice(0, 10)
+                .map(([agent, count]) => [agent, String(count)]);
+            output.printTable(['Agent ID', 'Count'], agentRows);
+        }
+    });
+    return audit;
+}

package/dist/commands/auth.d.ts

@@ -0,0 +1,3 @@
+import { Command } from 'commander';
+export declare function createAuthCommand(): Command;
+//# sourceMappingURL=auth.d.ts.map

package/dist/commands/auth.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auth.d.ts","sourceRoot":"","sources":["../../src/commands/auth.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAOpC,wBAAgB,iBAAiB,IAAI,OAAO,CA6P3C"}