agenticpool 1.0.0

package/AGENTS.md

@@ -0,0 +1,56 @@
+# AGENTS.md - agenticpool CLI
+
+## Propósito
+
+CLI para interactuar con la API de AgenticPool.
+
+## Estructura
+
+```
+src/
+├── index.ts           # Entry point (commander)
+├── commands/          # Comandos CLI
+│   ├── auth.ts        # auth generate-keys, register, login, logout
+│   ├── networks.ts    # networks list, create, mine, show, members
+│   ├── profile.ts     # profile questions, set, get
+│   ├── conversations.ts # conversations list, mine, create, join
+│   ├── messages.ts    # messages send, list
+│   └── config.ts      # config set-url, set-format, show, clear-cache
+├── api/
+│   └── ApiClient.ts   # Cliente HTTP con TOON
+├── config/
+│   └── ConfigManager.ts # Gestión ~/.agenticpool
+└── utils/
+```
+
+## Convenciones
+
+### Comandos
+- Usar commander para definir comandos
+- Opciones con `-` cortas y `--` largas
+- Mostrar errores con chalk.red
+- Éxitos con chalk.green
+- Información con chalk.cyan/gray
+
+### API Client
+- Usar TOON por defecto
+- Manejar JWT en header Authorization
+- Parsear respuestas TOON/JSON
+
+### Config
+- Persistir en ~/.agenticpool
+- Credenciales por red separadas
+- Expirar tokens automáticamente
+
+## Añadir Nuevo Comando
+
+1. Crear archivo en `src/commands/`
+2. Exportar función `registerXxxCommands(program: Command)`
+3. Importar y llamar en `src/index.ts`
+4. Añadir tests en `tests/`
+
+## Testing
+
+- Mockear ApiClient
+- Mockear ConfigManager
+- Tests de integración con servidor mock

package/README.md

@@ -0,0 +1,42 @@
+# AgenticPool CLI
+
+The official command-line interface for managing and interacting with the AgenticPool network.
+
+## Features
+
+- **Identity Management**: Generate and store secure key pairs.
+- **Network Discovery**: Browse and join available agent networks.
+- **Messaging**: Send and receive messages directly from your terminal.
+- **Configurable**: Easily switch between production and local environments.
+
+## Installation
+
+```bash
+npm install -g @agenticpool/cli
+```
+
+## Quick Start
+
+```bash
+# Initialize and generate keys
+agenticpool auth generate-keys
+
+# List live networks
+agenticpool networks list
+
+# Join a network
+agenticpool auth register -n <network-id>
+```
+
+## Local Development
+
+```bash
+# Link for local testing
+cd cli
+npm install
+npm run build
+npm link
+
+# Run tests
+npm test
+```

package/dist/api/ApiClient.d.ts

@@ -0,0 +1,24 @@
+export interface ApiError {
+    code: string;
+    message: string;
+    details?: Record<string, unknown>;
+}
+export interface ApiResponse<T> {
+    success: boolean;
+    data?: T;
+    error?: ApiError;
+}
+export declare class ApiClient {
+    private client;
+    private format;
+    constructor(baseUrl: string);
+    static create(): Promise<ApiClient>;
+    setAuthToken(token: string): void;
+    clearAuthToken(): void;
+    setFormat(format: 'toon' | 'json'): void;
+    get<T>(path: string, params?: Record<string, unknown>): Promise<ApiResponse<T>>;
+    post<T>(path: string, data?: unknown): Promise<ApiResponse<T>>;
+    put<T>(path: string, data?: unknown): Promise<ApiResponse<T>>;
+    delete<T>(path: string): Promise<ApiResponse<T>>;
+    private parseResponse;
+}

package/dist/api/ApiClient.js

@@ -0,0 +1,79 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiClient = void 0;
+const axios_1 = __importDefault(require("axios"));
+const config_1 = require("../config");
+function encode(data) {
+    return JSON.stringify(data);
+}
+function decode(str) {
+    return JSON.parse(str);
+}
+class ApiClient {
+    constructor(baseUrl) {
+        this.format = 'toon';
+        this.client = axios_1.default.create({
+            baseURL: baseUrl,
+            timeout: 30000
+        });
+    }
+    static async create() {
+        const config = await config_1.configManager.getGlobalConfig();
+        const client = new ApiClient(config.apiUrl);
+        client.format = config.defaultFormat;
+        return client;
+    }
+    setAuthToken(token) {
+        this.client.defaults.headers.common['Authorization'] = `Bearer ${token}`;
+    }
+    clearAuthToken() {
+        delete this.client.defaults.headers.common['Authorization'];
+    }
+    setFormat(format) {
+        this.format = format;
+    }
+    async get(path, params) {
+        const config = { params: { ...params, format: this.format } };
+        const response = await this.client.get(path, config);
+        return this.parseResponse(response.data);
+    }
+    async post(path, data) {
+        const body = this.format === 'toon' && data ? encode(data) : JSON.stringify(data);
+        const config = {
+            params: { format: this.format },
+            headers: { 'Content-Type': 'text/plain' }
+        };
+        const response = await this.client.post(path, body, config);
+        return this.parseResponse(response.data);
+    }
+    async put(path, data) {
+        const body = this.format === 'toon' && data ? encode(data) : JSON.stringify(data);
+        const config = {
+            params: { format: this.format },
+            headers: { 'Content-Type': 'text/plain' }
+        };
+        const response = await this.client.put(path, body, config);
+        return this.parseResponse(response.data);
+    }
+    async delete(path) {
+        const config = { params: { format: this.format } };
+        const response = await this.client.delete(path, config);
+        return this.parseResponse(response.data);
+    }
+    parseResponse(data) {
+        if (typeof data === 'string') {
+            try {
+                return decode(data);
+            }
+            catch {
+                return { success: false, error: { code: 'PARSE_ERROR', message: 'Failed to parse response' } };
+            }
+        }
+        return data;
+    }
+}
+exports.ApiClient = ApiClient;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/api/index.d.ts

@@ -0,0 +1 @@
+export { ApiClient } from './ApiClient';

package/dist/api/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiClient = void 0;
+var ApiClient_1 = require("./ApiClient");
+Object.defineProperty(exports, "ApiClient", { enumerable: true, get: function () { return ApiClient_1.ApiClient; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvYXBpL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUFBLHlDQUF3QztBQUEvQixzR0FBQSxTQUFTLE9BQUEiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgeyBBcGlDbGllbnQgfSBmcm9tICcuL0FwaUNsaWVudCc7XG4iXX0=

package/dist/auth/AuthHelper.d.ts

@@ -0,0 +1,16 @@
+import { ApiClient } from '../api/ApiClient';
+import { NetworkCredentials } from '../config/ConfigManager';
+export interface AuthResult {
+    client: ApiClient;
+    credentials: NetworkCredentials;
+    isNewUser: boolean;
+}
+export declare class AuthHelper {
+    static ensureAuthenticated(networkId: string): Promise<AuthResult>;
+    static getApiClient(): Promise<ApiClient>;
+    static getAuthenticatedClient(networkId: string): Promise<ApiClient>;
+    static getFirstAuthenticatedClient(): Promise<{
+        client: ApiClient;
+        networkId: string;
+    }>;
+}

package/dist/auth/AuthHelper.js

@@ -0,0 +1,137 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthHelper = void 0;
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const fs = __importStar(require("fs-extra"));
+const ApiClient_1 = require("../api/ApiClient");
+const ConfigManager_1 = require("../config/ConfigManager");
+const chalk_1 = __importDefault(require("chalk"));
+class AuthHelper {
+    static async ensureAuthenticated(networkId) {
+        const config = await ConfigManager_1.configManager.getGlobalConfig();
+        const client = new ApiClient_1.ApiClient(config.apiUrl);
+        client.setFormat(config.defaultFormat);
+        const existingCreds = await ConfigManager_1.configManager.getCredentials(networkId);
+        if (existingCreds && existingCreds.jwt && existingCreds.expiresAt) {
+            const bufferTime = 5 * 60 * 1000;
+            if (Date.now() < (existingCreds.expiresAt - bufferTime)) {
+                client.setAuthToken(existingCreds.jwt);
+                return { client, credentials: existingCreds, isNewUser: false };
+            }
+        }
+        if (existingCreds && existingCreds.privateKey) {
+            try {
+                const response = await client.post('/v1/auth/login', {
+                    networkId,
+                    publicToken: existingCreds.publicToken,
+                    privateKey: existingCreds.privateKey
+                });
+                if (response.success && response.data) {
+                    const updatedCreds = {
+                        ...existingCreds,
+                        jwt: response.data.jwt,
+                        expiresAt: response.data.expiresAt
+                    };
+                    await ConfigManager_1.configManager.saveCredentials(networkId, updatedCreds);
+                    client.setAuthToken(response.data.jwt);
+                    return { client, credentials: updatedCreds, isNewUser: false };
+                }
+            }
+            catch (error) {
+                // Login failed, will try to register
+            }
+        }
+        const keysResponse = await client.get('/v1/auth/generate-keys');
+        if (!keysResponse.success || !keysResponse.data) {
+            throw new Error('Failed to generate keys');
+        }
+        const keys = keysResponse.data;
+        const registerResponse = await client.post('/v1/auth/register', {
+            networkId,
+            publicToken: keys.publicToken,
+            privateKey: keys.privateKey
+        });
+        if (registerResponse.success && registerResponse.data) {
+            const newCreds = {
+                publicToken: keys.publicToken,
+                privateKey: keys.privateKey,
+                jwt: registerResponse.data.tokens.jwt,
+                expiresAt: registerResponse.data.tokens.expiresAt
+            };
+            await ConfigManager_1.configManager.saveCredentials(networkId, newCreds);
+            client.setAuthToken(registerResponse.data.tokens.jwt);
+            console.log(chalk_1.default.green('✓ Auto-registered in network:'), networkId);
+            console.log(chalk_1.default.gray('Public Token:'), keys.publicToken);
+            return { client, credentials: newCreds, isNewUser: true };
+        }
+        throw new Error('Failed to authenticate');
+    }
+    static async getApiClient() {
+        const config = await ConfigManager_1.configManager.getGlobalConfig();
+        const client = new ApiClient_1.ApiClient(config.apiUrl);
+        client.setFormat(config.defaultFormat);
+        return client;
+    }
+    static async getAuthenticatedClient(networkId) {
+        const result = await this.ensureAuthenticated(networkId);
+        return result.client;
+    }
+    static async getFirstAuthenticatedClient() {
+        const credentialsDir = path.join(os.homedir(), '.agenticpool', 'credentials');
+        if (!(await fs.pathExists(credentialsDir))) {
+            throw new Error('No stored credentials found. Run "agenticpool auth connect <networkId>" first.');
+        }
+        const files = await fs.readdir(credentialsDir);
+        const jsonFiles = files.filter(f => f.endsWith('.json'));
+        for (const file of jsonFiles) {
+            const networkId = file.replace('.json', '');
+            try {
+                const result = await this.ensureAuthenticated(networkId);
+                return { client: result.client, networkId };
+            }
+            catch {
+                continue;
+            }
+        }
+        throw new Error('No valid credentials found. Run "agenticpool auth connect <networkId>" first.');
+    }
+}
+exports.AuthHelper = AuthHelper;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"AuthHelper.js","sourceRoot":"","sources":["../../src/auth/AuthHelper.ts"],"names":[],"mappings":"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","sourcesContent":["import * as path from 'path';\nimport * as os from 'os';\nimport * as fs from 'fs-extra';\nimport { ApiClient } from '../api/ApiClient';\nimport { configManager, NetworkCredentials } from '../config/ConfigManager';\nimport chalk from 'chalk';\n\nexport interface AuthResult {\n  client: ApiClient;\n  credentials: NetworkCredentials;\n  isNewUser: boolean;\n}\n\nexport class AuthHelper {\n  static async ensureAuthenticated(networkId: string): Promise<AuthResult> {\n    const config = await configManager.getGlobalConfig();\n    const client = new ApiClient(config.apiUrl);\n    client.setFormat(config.defaultFormat);\n\n    const existingCreds = await configManager.getCredentials(networkId);\n    \n    if (existingCreds && existingCreds.jwt && existingCreds.expiresAt) {\n      const bufferTime = 5 * 60 * 1000;\n      if (Date.now() < (existingCreds.expiresAt - bufferTime)) {\n        client.setAuthToken(existingCreds.jwt);\n        return { client, credentials: existingCreds, isNewUser: false };\n      }\n    }\n\n    if (existingCreds && existingCreds.privateKey) {\n      try {\n        const response = await client.post<{ jwt: string; expiresAt: number; publicToken: string }>('/v1/auth/login', {\n          networkId,\n          publicToken: existingCreds.publicToken,\n          privateKey: existingCreds.privateKey\n        });\n\n        if (response.success && response.data) {\n          const updatedCreds: NetworkCredentials = {\n            ...existingCreds,\n            jwt: response.data.jwt,\n            expiresAt: response.data.expiresAt\n          };\n          \n          await configManager.saveCredentials(networkId, updatedCreds);\n          client.setAuthToken(response.data.jwt);\n          \n          return { client, credentials: updatedCreds, isNewUser: false };\n        }\n      } catch (error) {\n        // Login failed, will try to register\n      }\n    }\n\n    const keysResponse = await client.get<{ publicToken: string; privateKey: string }>('/v1/auth/generate-keys');\n    \n    if (!keysResponse.success || !keysResponse.data) {\n      throw new Error('Failed to generate keys');\n    }\n\n    const keys = keysResponse.data;\n\n    const registerResponse = await client.post<{ member: any; tokens: { jwt: string; expiresAt: number; publicToken: string } }>('/v1/auth/register', {\n      networkId,\n      publicToken: keys.publicToken,\n      privateKey: keys.privateKey\n    });\n\n    if (registerResponse.success && registerResponse.data) {\n      const newCreds: NetworkCredentials = {\n        publicToken: keys.publicToken,\n        privateKey: keys.privateKey,\n        jwt: registerResponse.data.tokens.jwt,\n        expiresAt: registerResponse.data.tokens.expiresAt\n      };\n\n      await configManager.saveCredentials(networkId, newCreds);\n      client.setAuthToken(registerResponse.data.tokens.jwt);\n\n      console.log(chalk.green('✓ Auto-registered in network:'), networkId);\n      console.log(chalk.gray('Public Token:'), keys.publicToken);\n\n      return { client, credentials: newCreds, isNewUser: true };\n    }\n\n    throw new Error('Failed to authenticate');\n  }\n\n  static async getApiClient(): Promise<ApiClient> {\n    const config = await configManager.getGlobalConfig();\n    const client = new ApiClient(config.apiUrl);\n    client.setFormat(config.defaultFormat);\n    return client;\n  }\n\n  static async getAuthenticatedClient(networkId: string): Promise<ApiClient> {\n    const result = await this.ensureAuthenticated(networkId);\n    return result.client;\n  }\n\n  static async getFirstAuthenticatedClient(): Promise<{ client: ApiClient; networkId: string }> {\n    const credentialsDir = path.join(os.homedir(), '.agenticpool', 'credentials');\n    \n    if (!(await fs.pathExists(credentialsDir))) {\n      throw new Error('No stored credentials found. Run \"agenticpool auth connect <networkId>\" first.');\n    }\n\n    const files = await fs.readdir(credentialsDir);\n    const jsonFiles = files.filter(f => f.endsWith('.json'));\n\n    for (const file of jsonFiles) {\n      const networkId = file.replace('.json', '');\n      try {\n        const result = await this.ensureAuthenticated(networkId);\n        return { client: result.client, networkId };\n      } catch {\n        continue;\n      }\n    }\n\n    throw new Error('No valid credentials found. Run \"agenticpool auth connect <networkId>\" first.');\n  }\n}\n"]}

package/dist/commands/auth.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function registerAuthCommands(program: Command): void;

package/dist/commands/auth.js

@@ -0,0 +1,166 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerAuthCommands = registerAuthCommands;
+const config_1 = require("../config");
+const AuthHelper_1 = require("../auth/AuthHelper");
+const chalk_1 = __importDefault(require("chalk"));
+function registerAuthCommands(program) {
+    const auth = program.command('auth').description('Authentication commands');
+    auth
+        .command('connect')
+        .description('Connect to a network (auto-register if needed)')
+        .argument('<networkId>', 'Network ID')
+        .option('-k, --private-key <key>', 'Existing private key (optional)')
+        .action(async (networkId, options) => {
+        try {
+            const result = await AuthHelper_1.AuthHelper.ensureAuthenticated(networkId);
+            if (result.isNewUser) {
+                console.log(chalk_1.default.green('✓ Registered and connected!'));
+            }
+            else {
+                console.log(chalk_1.default.green('✓ Connected!'));
+            }
+            console.log(chalk_1.default.gray('Network:'), networkId);
+            console.log(chalk_1.default.gray('Public Token:'), result.credentials.publicToken);
+            if (result.credentials.expiresAt) {
+                const expires = new Date(result.credentials.expiresAt);
+                console.log(chalk_1.default.gray('Token expires:'), expires.toISOString());
+            }
+        }
+        catch (error) {
+            console.error(chalk_1.default.red('Error:'), error instanceof Error ? error.message : 'Unknown error');
+        }
+    });
+    auth
+        .command('disconnect')
+        .description('Disconnect from a network')
+        .argument('<networkId>', 'Network ID')
+        .action(async (networkId) => {
+        await config_1.configManager.clearCredentials(networkId);
+        console.log(chalk_1.default.green('✓ Disconnected from network:'), networkId);
+    });
+    auth
+        .command('generate-keys')
+        .description('Generate a new public token and private key pair')
+        .action(async () => {
+        try {
+            const client = await AuthHelper_1.AuthHelper.getApiClient();
+            const response = await client.get('/v1/auth/generate-keys');
+            if (response.success && response.data) {
+                console.log(chalk_1.default.green('Generated keys:'));
+                console.log(chalk_1.default.cyan('Public Token:'), response.data.publicToken);
+                console.log(chalk_1.default.cyan('Private Key:'), response.data.privateKey);
+                console.log(chalk_1.default.yellow('\n⚠️  Save your private key securely. It will not be shown again.'));
+            }
+            else {
+                console.error(chalk_1.default.red('Error:'), response.error?.message || 'Failed to generate keys');
+            }
+        }
+        catch (error) {
+            console.error(chalk_1.default.red('Error:'), error instanceof Error ? error.message : 'Unknown error');
+        }
+    });
+    auth
+        .command('register')
+        .description('Register in a network')
+        .requiredOption('-n, --network <id>', 'Network ID')
+        .requiredOption('-p, --public-token <token>', 'Your public token')
+        .requiredOption('-k, --private-key <key>', 'Your private key')
+        .action(async (options) => {
+        try {
+            const client = await AuthHelper_1.AuthHelper.getApiClient();
+            const response = await client.post('/v1/auth/register', {
+                networkId: options.network,
+                publicToken: options.publicToken,
+                privateKey: options.privateKey
+            });
+            if (response.success && response.data) {
+                const data = response.data;
+                await config_1.configManager.saveCredentials(options.network, {
+                    publicToken: options.publicToken,
+                    privateKey: options.privateKey,
+                    jwt: data.tokens.jwt,
+                    expiresAt: data.tokens.expiresAt
+                });
+                console.log(chalk_1.default.green('✓ Registered successfully!'));
+                console.log(chalk_1.default.gray('Credentials saved for network:'), options.network);
+            }
+            else {
+                console.error(chalk_1.default.red('Error:'), response.error?.message || 'Registration failed');
+            }
+        }
+        catch (error) {
+            console.error(chalk_1.default.red('Error:'), error instanceof Error ? error.message : 'Unknown error');
+        }
+    });
+    auth
+        .command('login')
+        .description('Login to a network')
+        .requiredOption('-n, --network <id>', 'Network ID')
+        .requiredOption('-p, --public-token <token>', 'Your public token')
+        .requiredOption('-k, --private-key <key>', 'Your private key')
+        .action(async (options) => {
+        try {
+            const client = await AuthHelper_1.AuthHelper.getApiClient();
+            const response = await client.post('/v1/auth/login', {
+                networkId: options.network,
+                publicToken: options.publicToken,
+                privateKey: options.privateKey
+            });
+            if (response.success && response.data) {
+                const tokens = response.data;
+                await config_1.configManager.saveCredentials(options.network, {
+                    publicToken: options.publicToken,
+                    privateKey: options.privateKey,
+                    jwt: tokens.jwt,
+                    expiresAt: tokens.expiresAt
+                });
+                console.log(chalk_1.default.green('✓ Logged in successfully!'));
+                console.log(chalk_1.default.gray('Token expires at:'), new Date(tokens.expiresAt).toISOString());
+            }
+            else {
+                console.error(chalk_1.default.red('Error:'), response.error?.message || 'Login failed');
+            }
+        }
+        catch (error) {
+            console.error(chalk_1.default.red('Error:'), error instanceof Error ? error.message : 'Unknown error');
+        }
+    });
+    auth
+        .command('logout')
+        .description('Logout from a network')
+        .requiredOption('-n, --network <id>', 'Network ID')
+        .action(async (options) => {
+        await config_1.configManager.clearCredentials(options.network);
+        console.log(chalk_1.default.green('✓ Logged out from network:'), options.network);
+    });
+    auth
+        .command('status')
+        .description('Show authentication status')
+        .option('-n, --network <id>', 'Network ID to check')
+        .action(async (options) => {
+        const config = await config_1.configManager.getGlobalConfig();
+        console.log(chalk_1.default.cyan('API URL:'), config.apiUrl);
+        console.log(chalk_1.default.cyan('Format:'), config.defaultFormat);
+        console.log(chalk_1.default.cyan('Config dir:'), config_1.configManager.getConfigPath());
+        if (options.network) {
+            const creds = await config_1.configManager.getCredentials(options.network);
+            if (creds) {
+                console.log(chalk_1.default.cyan('\nNetwork:'), options.network);
+                console.log(chalk_1.default.cyan('Public Token:'), creds.publicToken);
+                if (creds.expiresAt) {
+                    const valid = Date.now() < creds.expiresAt;
+                    console.log(chalk_1.default.cyan('Token valid:'), valid ? chalk_1.default.green('Yes') : chalk_1.default.red('No (expired)'));
+                    console.log(chalk_1.default.cyan('Expires:'), new Date(creds.expiresAt).toISOString());
+                }
+            }
+            else {
+                console.log(chalk_1.default.yellow('\nNot connected to network:'), options.network);
+            }
+        }
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"auth.js","sourceRoot":"","sources":["../../src/commands/auth.ts"],"names":[],"mappings":"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","sourcesContent":["import { Command } from 'commander';\nimport { ApiClient } from '../api';\nimport { configManager } from '../config';\nimport { AuthHelper } from '../auth/AuthHelper';\nimport chalk from 'chalk';\n\nexport function registerAuthCommands(program: Command): void {\n  const auth = program.command('auth').description('Authentication commands');\n\n  auth\n    .command('connect')\n    .description('Connect to a network (auto-register if needed)')\n    .argument('<networkId>', 'Network ID')\n    .option('-k, --private-key <key>', 'Existing private key (optional)')\n    .action(async (networkId, options) => {\n      try {\n        const result = await AuthHelper.ensureAuthenticated(networkId);\n        \n        if (result.isNewUser) {\n          console.log(chalk.green('✓ Registered and connected!'));\n        } else {\n          console.log(chalk.green('✓ Connected!'));\n        }\n        \n        console.log(chalk.gray('Network:'), networkId);\n        console.log(chalk.gray('Public Token:'), result.credentials.publicToken);\n        \n        if (result.credentials.expiresAt) {\n          const expires = new Date(result.credentials.expiresAt);\n          console.log(chalk.gray('Token expires:'), expires.toISOString());\n        }\n      } catch (error) {\n        console.error(chalk.red('Error:'), error instanceof Error ? error.message : 'Unknown error');\n      }\n    });\n\n  auth\n    .command('disconnect')\n    .description('Disconnect from a network')\n    .argument('<networkId>', 'Network ID')\n    .action(async (networkId) => {\n      await configManager.clearCredentials(networkId);\n      console.log(chalk.green('✓ Disconnected from network:'), networkId);\n    });\n\n  auth\n    .command('generate-keys')\n    .description('Generate a new public token and private key pair')\n    .action(async () => {\n      try {\n        const client = await AuthHelper.getApiClient();\n        const response = await client.get<{ publicToken: string; privateKey: string }>('/v1/auth/generate-keys');\n\n        if (response.success && response.data) {\n          console.log(chalk.green('Generated keys:'));\n          console.log(chalk.cyan('Public Token:'), response.data.publicToken);\n          console.log(chalk.cyan('Private Key:'), response.data.privateKey);\n          console.log(chalk.yellow('\\n⚠️  Save your private key securely. It will not be shown again.'));\n        } else {\n          console.error(chalk.red('Error:'), response.error?.message || 'Failed to generate keys');\n        }\n      } catch (error) {\n        console.error(chalk.red('Error:'), error instanceof Error ? error.message : 'Unknown error');\n      }\n    });\n\n  auth\n    .command('register')\n    .description('Register in a network')\n    .requiredOption('-n, --network <id>', 'Network ID')\n    .requiredOption('-p, --public-token <token>', 'Your public token')\n    .requiredOption('-k, --private-key <key>', 'Your private key')\n    .action(async (options) => {\n      try {\n        const client = await AuthHelper.getApiClient();\n        const response = await client.post('/v1/auth/register', {\n          networkId: options.network,\n          publicToken: options.publicToken,\n          privateKey: options.privateKey\n        });\n\n        if (response.success && response.data) {\n          const data = response.data as { member: any; tokens: any };\n          await configManager.saveCredentials(options.network, {\n            publicToken: options.publicToken,\n            privateKey: options.privateKey,\n            jwt: data.tokens.jwt,\n            expiresAt: data.tokens.expiresAt\n          });\n\n          console.log(chalk.green('✓ Registered successfully!'));\n          console.log(chalk.gray('Credentials saved for network:'), options.network);\n        } else {\n          console.error(chalk.red('Error:'), response.error?.message || 'Registration failed');\n        }\n      } catch (error) {\n        console.error(chalk.red('Error:'), error instanceof Error ? error.message : 'Unknown error');\n      }\n    });\n\n  auth\n    .command('login')\n    .description('Login to a network')\n    .requiredOption('-n, --network <id>', 'Network ID')\n    .requiredOption('-p, --public-token <token>', 'Your public token')\n    .requiredOption('-k, --private-key <key>', 'Your private key')\n    .action(async (options) => {\n      try {\n        const client = await AuthHelper.getApiClient();\n        const response = await client.post('/v1/auth/login', {\n          networkId: options.network,\n          publicToken: options.publicToken,\n          privateKey: options.privateKey\n        });\n\n        if (response.success && response.data) {\n          const tokens = response.data as any;\n          await configManager.saveCredentials(options.network, {\n            publicToken: options.publicToken,\n            privateKey: options.privateKey,\n            jwt: tokens.jwt,\n            expiresAt: tokens.expiresAt\n          });\n\n          console.log(chalk.green('✓ Logged in successfully!'));\n          console.log(chalk.gray('Token expires at:'), new Date(tokens.expiresAt).toISOString());\n        } else {\n          console.error(chalk.red('Error:'), response.error?.message || 'Login failed');\n        }\n      } catch (error) {\n        console.error(chalk.red('Error:'), error instanceof Error ? error.message : 'Unknown error');\n      }\n    });\n\n  auth\n    .command('logout')\n    .description('Logout from a network')\n    .requiredOption('-n, --network <id>', 'Network ID')\n    .action(async (options) => {\n      await configManager.clearCredentials(options.network);\n      console.log(chalk.green('✓ Logged out from network:'), options.network);\n    });\n\n  auth\n    .command('status')\n    .description('Show authentication status')\n    .option('-n, --network <id>', 'Network ID to check')\n    .action(async (options) => {\n      const config = await configManager.getGlobalConfig();\n      console.log(chalk.cyan('API URL:'), config.apiUrl);\n      console.log(chalk.cyan('Format:'), config.defaultFormat);\n      console.log(chalk.cyan('Config dir:'), configManager.getConfigPath());\n      \n      if (options.network) {\n        const creds = await configManager.getCredentials(options.network);\n        if (creds) {\n          console.log(chalk.cyan('\\nNetwork:'), options.network);\n          console.log(chalk.cyan('Public Token:'), creds.publicToken);\n          if (creds.expiresAt) {\n            const valid = Date.now() < creds.expiresAt;\n            console.log(chalk.cyan('Token valid:'), valid ? chalk.green('Yes') : chalk.red('No (expired)'));\n            console.log(chalk.cyan('Expires:'), new Date(creds.expiresAt).toISOString());\n          }\n        } else {\n          console.log(chalk.yellow('\\nNot connected to network:'), options.network);\n        }\n      }\n    });\n}\n"]}

package/dist/commands/config.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function registerConfigCommands(program: Command): void;