agent-rev 0.1.0

package/dist/api/qwen.d.ts

@@ -0,0 +1,12 @@
+interface QwenMessage {
+    role: 'system' | 'user' | 'assistant';
+    content: string;
+}
+export declare function qwenLogin(): Promise<boolean>;
+export declare function qwenAuthStatus(): Promise<{
+    authenticated: boolean;
+    email?: string;
+}>;
+export declare function qwenChat(messages: QwenMessage[], model?: string): Promise<string>;
+export declare function qwenAsk(prompt: string, model?: string): Promise<string>;
+export {};

package/dist/api/qwen.js

@@ -0,0 +1,150 @@
+import axios from 'axios';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import * as os from 'os';
+import open from 'open';
+const QWEN_API_BASE = 'https://dashscope-intl.aliyuncs.com/api/v1';
+const QWEN_AUTH_URL = 'https://oauth.aliyun.com/v1/oauth/authorize';
+const CLIENT_ID = 'your_client_id'; // Reemplazar con el client ID real de Qwen
+const REDIRECT_URI = 'http://localhost:3000/callback';
+let tokenCache = null;
+async function getTokenPath() {
+    const homeDir = os.homedir();
+    const dir = path.join(homeDir, '.agent');
+    await fs.mkdir(dir, { recursive: true });
+    return path.join(dir, 'qwen-token.json');
+}
+async function loadToken() {
+    try {
+        const tokenPath = await getTokenPath();
+        const content = await fs.readFile(tokenPath, 'utf-8');
+        const token = JSON.parse(content);
+        if (token.expiresAt > Date.now()) {
+            return token;
+        }
+        // Token expirado, intentar refresh
+        if (token.refreshToken) {
+            return refreshAccessToken(token.refreshToken);
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+async function saveToken(token) {
+    const tokenPath = await getTokenPath();
+    await fs.writeFile(tokenPath, JSON.stringify(token, null, 2), 'utf-8');
+}
+async function refreshAccessToken(refreshToken) {
+    try {
+        const response = await axios.post('https://oauth.aliyun.com/v1/oauth/token', new URLSearchParams({
+            grant_type: 'refresh_token',
+            refresh_token: refreshToken,
+            client_id: CLIENT_ID,
+        }), {
+            headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+        });
+        const token = {
+            accessToken: response.data.access_token,
+            refreshToken: response.data.refresh_token || refreshToken,
+            expiresAt: Date.now() + (response.data.expires_in || 3600) * 1000,
+        };
+        await saveToken(token);
+        return token;
+    }
+    catch (error) {
+        console.error('Error refreshing token:', error);
+        return null;
+    }
+}
+export async function qwenLogin() {
+    const authUrl = `${QWEN_AUTH_URL}?client_id=${CLIENT_ID}&redirect_uri=${encodeURIComponent(REDIRECT_URI)}&response_type=code&scope=api`;
+    console.log('Abriendo navegador para autenticación con Qwen...');
+    console.log('URL:', authUrl);
+    await open(authUrl);
+    console.log('');
+    console.log('Por favor completá la autenticación en el navegador.');
+    console.log('Cuando obtengas el código de autorización, ingresalo abajo:');
+    return new Promise((resolve) => {
+        const readline = await import('readline');
+        const rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout,
+        });
+        rl.question('Código de autorización: ', async (code) => {
+            try {
+                const response = await axios.post('https://oauth.aliyun.com/v1/oauth/token', new URLSearchParams({
+                    grant_type: 'authorization_code',
+                    code,
+                    redirect_uri: REDIRECT_URI,
+                    client_id: CLIENT_ID,
+                }), {
+                    headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+                });
+                const token = {
+                    accessToken: response.data.access_token,
+                    refreshToken: response.data.refresh_token,
+                    expiresAt: Date.now() + (response.data.expires_in || 3600) * 1000,
+                };
+                await saveToken(token);
+                console.log('¡Autenticación exitosa!');
+                rl.close();
+                resolve(true);
+            }
+            catch (error) {
+                console.error('Error en autenticación:', error);
+                rl.close();
+                resolve(false);
+            }
+        });
+    });
+}
+export async function qwenAuthStatus() {
+    const token = await loadToken();
+    if (token) {
+        return { authenticated: true };
+    }
+    return { authenticated: false };
+}
+export async function qwenChat(messages, model = 'qwen-coder') {
+    const token = await loadToken();
+    if (!token) {
+        throw new Error('No hay token de Qwen. Ejecutá /qwen-login primero.');
+    }
+    try {
+        const response = await axios.post(`${QWEN_API_BASE}/services/aigc/text-generation/generation`, {
+            model,
+            input: {
+                messages,
+            },
+            parameters: {
+                result_format: 'text',
+            },
+        }, {
+            headers: {
+                'Authorization': `Bearer ${token.accessToken}`,
+                'Content-Type': 'application/json',
+            },
+        });
+        return response.data.output.text;
+    }
+    catch (error) {
+        if (error.response?.status === 401) {
+            // Token inválido, intentar refresh
+            const newToken = token.refreshToken ? await refreshAccessToken(token.refreshToken) : null;
+            if (newToken) {
+                // Reintentar con el nuevo token
+                return qwenChat(messages, model);
+            }
+        }
+        throw error;
+    }
+}
+export async function qwenAsk(prompt, model = 'qwen-coder') {
+    const messages = [
+        { role: 'system', content: 'Sos un asistente útil de programación.' },
+        { role: 'user', content: prompt },
+    ];
+    return qwenChat(messages, model);
+}

package/dist/commands/auth.d.ts

@@ -0,0 +1,31 @@
+import { Command } from 'commander';
+declare const CONFIG_DIR: string;
+declare const CONFIG_FILE: string;
+interface AuthEntry {
+    provider: string;
+    method: 'oauth' | 'apikey';
+    accessToken?: string;
+    refreshToken?: string;
+    expiresAt?: number;
+    apiKey?: string;
+    email?: string;
+}
+interface AuthStore {
+    entries: AuthEntry[];
+    activeProvider?: string;
+}
+interface CliConfig {
+    roles: Record<string, {
+        provider: string;
+        model: string;
+    }>;
+    deliberation: {
+        enabled: boolean;
+        max_rounds: number;
+    };
+}
+declare function loadAuth(): Promise<AuthStore>;
+declare function loadCliConfig(): Promise<CliConfig>;
+declare function saveCliConfig(cfg: CliConfig): Promise<void>;
+export declare function authCommand(program: Command): void;
+export { loadAuth, loadCliConfig, saveCliConfig, CONFIG_DIR, CONFIG_FILE };

package/dist/commands/auth.js

@@ -0,0 +1,255 @@
+import * as readline from 'readline';
+import * as path from 'path';
+import * as fs from 'fs/promises';
+import { createServer } from 'http';
+import { createHash, randomBytes } from 'crypto';
+import open from 'open';
+import chalk from 'chalk';
+import { writeJson, ensureDir } from '../utils/fs.js';
+const CONFIG_DIR = path.join(process.env.HOME || process.env.USERPROFILE || '', '.agent-cli');
+const AUTH_FILE = path.join(CONFIG_DIR, 'auth.json');
+const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
+// ── OAuth providers ────────────────────────────────────────────────────────
+const OAUTH_PROVIDERS = {
+    opencode: {
+        authorizeUrl: 'https://accounts.opencode.ai/oauth2/auth',
+        tokenUrl: 'https://accounts.opencode.ai/oauth2/token',
+        clientId: 'claw_code',
+        scopes: 'openid email profile offline_access',
+        name: 'Opencode',
+    },
+    google: {
+        authorizeUrl: 'https://accounts.google.com/o/oauth2/v2/auth',
+        tokenUrl: 'https://oauth2.googleapis.com/token',
+        clientId: '',
+        scopes: 'openid email profile',
+        name: 'Google',
+    },
+};
+async function loadAuth() {
+    try {
+        const content = await fs.readFile(AUTH_FILE, 'utf-8');
+        return JSON.parse(content);
+    }
+    catch {
+        return { entries: [] };
+    }
+}
+async function saveAuth(auth) {
+    await ensureDir(CONFIG_DIR);
+    await writeJson(AUTH_FILE, auth);
+}
+async function loadCliConfig() {
+    try {
+        const content = await fs.readFile(CONFIG_FILE, 'utf-8');
+        return JSON.parse(content);
+    }
+    catch {
+        return { roles: {}, deliberation: { enabled: false, max_rounds: 4 } };
+    }
+}
+async function saveCliConfig(cfg) {
+    await ensureDir(CONFIG_DIR);
+    await writeJson(CONFIG_FILE, cfg);
+}
+function base64url(buf) {
+    return buf.toString('base64').replace(/\+/g, '-').replace(/\//g, '_').replace(/=/g, '');
+}
+async function oauthFlow(providerId) {
+    const provider = OAUTH_PROVIDERS[providerId];
+    if (!provider)
+        throw new Error(`Unknown OAuth provider: ${providerId}`);
+    const port = 9800 + Math.floor(Math.random() * 1000);
+    const state = base64url(randomBytes(32));
+    const codeVerifier = base64url(randomBytes(32));
+    const codeChallenge = base64url(createHash('sha256').update(codeVerifier).digest());
+    const redirectUri = `http://127.0.0.1:${port}/callback`;
+    const authUrl = new URL(provider.authorizeUrl);
+    authUrl.searchParams.set('response_type', 'code');
+    authUrl.searchParams.set('client_id', provider.clientId);
+    authUrl.searchParams.set('redirect_uri', redirectUri);
+    authUrl.searchParams.set('scope', provider.scopes);
+    authUrl.searchParams.set('state', state);
+    authUrl.searchParams.set('code_challenge', codeChallenge);
+    authUrl.searchParams.set('code_challenge_method', 'S256');
+    console.log(chalk.dim(`  Opening browser for ${provider.name} login...`));
+    await open(authUrl.toString());
+    return new Promise((resolve, reject) => {
+        const server = createServer((req, res) => {
+            const url = new URL(req.url, `http://127.0.0.1:${port}`);
+            if (url.pathname !== '/callback') {
+                res.writeHead(404);
+                res.end();
+                return;
+            }
+            const returnedState = url.searchParams.get('state');
+            const code = url.searchParams.get('code');
+            const error = url.searchParams.get('error');
+            if (error) {
+                res.writeHead(400, { 'Content-Type': 'text/html' });
+                res.end(`<h1>Login failed</h1><p>${error}</p>`);
+                server.close();
+                reject(new Error(`OAuth error: ${error}`));
+                return;
+            }
+            if (returnedState !== state) {
+                res.writeHead(400, { 'Content-Type': 'text/html' });
+                res.end('<h1>Invalid state</h1>');
+                server.close();
+                reject(new Error('State mismatch'));
+                return;
+            }
+            if (!code) {
+                res.writeHead(400, { 'Content-Type': 'text/html' });
+                res.end('<h1>No code</h1>');
+                server.close();
+                reject(new Error('No authorization code'));
+                return;
+            }
+            res.writeHead(200, { 'Content-Type': 'text/html' });
+            res.end(`
+        <html><body style="font-family:system-ui;text-align:center;padding:60px">
+          <h1 style="color:#06b6d4">✓ Login successful</h1>
+          <p>You can close this tab and return to the terminal.</p>
+        </body></html>
+      `);
+            server.close();
+            // Exchange code for tokens
+            exchangeToken(provider, code, redirectUri, codeVerifier).then(resolve).catch(reject);
+        });
+        server.listen(port, '127.0.0.1', () => {
+            console.log(chalk.blue(`  → Waiting for callback on port ${port}...`));
+        });
+        server.on('error', (err) => {
+            if (err.code === 'EADDRINUSE') {
+                reject(new Error(`Port ${port} is in use. Try again.`));
+            }
+            else {
+                reject(err);
+            }
+        });
+    });
+}
+async function exchangeToken(provider, code, redirectUri, codeVerifier) {
+    const params = new URLSearchParams({
+        grant_type: 'authorization_code',
+        client_id: provider.clientId,
+        code,
+        redirect_uri: redirectUri,
+        code_verifier: codeVerifier,
+    });
+    const res = await fetch(provider.tokenUrl, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+        body: params.toString(),
+    });
+    if (!res.ok) {
+        const text = await res.text();
+        throw new Error(`Token exchange failed (${res.status}): ${text}`);
+    }
+    const data = await res.json();
+    // Decode email from id_token if available
+    let email;
+    if (data.id_token) {
+        try {
+            const payload = JSON.parse(Buffer.from(data.id_token.split('.')[1], 'base64').toString());
+            email = payload.email;
+        }
+        catch { }
+    }
+    return {
+        provider: 'opencode',
+        method: 'oauth',
+        accessToken: data.access_token,
+        refreshToken: data.refresh_token,
+        expiresAt: data.expires_in ? Date.now() + data.expires_in * 1000 : undefined,
+        email,
+    };
+}
+function ask(rl, q) {
+    return new Promise((resolve) => rl.question(q, resolve));
+}
+export function authCommand(program) {
+    const auth = program.command('auth')
+        .description('Manage authentication');
+    auth
+        .command('login')
+        .description('Login to a provider (opens browser)')
+        .option('-p, --provider <name>', 'Provider name (opencode)')
+        .action(async (opts) => {
+        const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+        console.log(chalk.bold.cyan('\n  Agent CLI — Login\n'));
+        let providerId = opts.provider;
+        if (!providerId) {
+            console.log(chalk.dim('  Available providers:'));
+            for (const [id, p] of Object.entries(OAUTH_PROVIDERS)) {
+                console.log(chalk.dim(`    ${id} — ${p.name}`));
+            }
+            providerId = await ask(rl, '\n  Provider: ');
+        }
+        providerId = providerId.trim();
+        try {
+            const entry = await oauthFlow(providerId);
+            const auth = await loadAuth();
+            // Remove existing entry for same provider
+            auth.entries = auth.entries.filter((e) => e.provider !== entry.provider);
+            auth.entries.push(entry);
+            auth.activeProvider = entry.provider;
+            await saveAuth(auth);
+            console.log(chalk.green(`\n  ✓ Logged in as ${entry.email || 'user'} via ${entry.provider}`));
+            console.log(chalk.dim('  Auth saved to ~/.agent-cli/auth.json'));
+        }
+        catch (err) {
+            console.log(chalk.red(`\n  ✗ Login failed: ${err.message}`));
+        }
+        rl.close();
+    });
+    auth
+        .command('logout')
+        .description('Logout from current provider')
+        .action(async () => {
+        const auth = await loadAuth();
+        if (!auth.activeProvider || auth.entries.length === 0) {
+            console.log(chalk.yellow('  Not logged in'));
+            return;
+        }
+        auth.entries = auth.entries.filter((e) => e.provider !== auth.activeProvider);
+        auth.activeProvider = undefined;
+        await saveAuth(auth);
+        console.log(chalk.green('  ✓ Logged out'));
+    });
+    auth
+        .command('status')
+        .description('Show current auth status')
+        .action(async () => {
+        const auth = await loadAuth();
+        console.log(chalk.bold('\n  Auth Status'));
+        console.log(chalk.dim('  ──────────────────────────'));
+        if (auth.entries.length === 0) {
+            console.log(chalk.yellow('  Not logged in to any provider'));
+        }
+        else {
+            for (const entry of auth.entries) {
+                const active = entry.provider === auth.activeProvider ? chalk.green(' (active)') : '';
+                const email = entry.email ? ` — ${entry.email}` : '';
+                const expired = entry.expiresAt && entry.expiresAt < Date.now() ? chalk.red(' (expired)') : '';
+                console.log(`  ${entry.provider} (${entry.method})${email}${active}${expired}`);
+            }
+        }
+        console.log('');
+    });
+    auth
+        .command('apikey')
+        .description('Set API key for a provider')
+        .argument('<provider>', 'Provider name')
+        .argument('<key>', 'API key')
+        .action(async (provider, key) => {
+        const auth = await loadAuth();
+        auth.entries = auth.entries.filter((e) => e.provider !== provider);
+        auth.entries.push({ provider, method: 'apikey', apiKey: key });
+        auth.activeProvider = provider;
+        await saveAuth(auth);
+        console.log(chalk.green(`  ✓ API key saved for ${provider}`));
+    });
+}
+export { loadAuth, loadCliConfig, saveCliConfig, CONFIG_DIR, CONFIG_FILE };

package/dist/commands/config.d.ts

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

package/dist/commands/config.js

@@ -0,0 +1,42 @@
+import chalk from 'chalk';
+import { loadCliConfig, saveCliConfig } from '../utils/config.js';
+export function configCommand(program) {
+    program
+        .command('config')
+        .description('View or edit CLI configuration')
+        .option('--show', 'Show current configuration')
+        .option('--set <key=value>', 'Set a config value')
+        .action(async (opts) => {
+        const config = await loadCliConfig();
+        if (opts.show) {
+            console.log(chalk.bold('\n  Agent CLI Configuration'));
+            console.log(chalk.dim('  ──────────────────────────'));
+            console.log(chalk.yellow('  Providers:'), Object.keys(config.apiKeys).join(', ') || 'none');
+            for (const [role, r] of Object.entries(config.roles)) {
+                if (r)
+                    console.log(chalk.yellow(`  ${role}:`), `${r.provider}/${r.model}`);
+            }
+            if (config.deliberation?.enabled) {
+                console.log(chalk.yellow('  Deliberation:'), `enabled (${config.deliberation.max_rounds} rounds)`);
+            }
+            console.log('');
+            return;
+        }
+        if (opts.set) {
+            const [key, ...valParts] = opts.set.split('=');
+            const value = valParts.join('=');
+            const parts = key.split('.');
+            let obj = config;
+            for (let i = 0; i < parts.length - 1; i++) {
+                if (!obj[parts[i]])
+                    obj[parts[i]] = {};
+                obj = obj[parts[i]];
+            }
+            obj[parts[parts.length - 1]] = value;
+            await saveCliConfig(config);
+            console.log(chalk.green(`  ✓ Set ${key} = ${value}`));
+            return;
+        }
+        console.log('Use --show or --set key=value');
+    });
+}

package/dist/commands/models.d.ts

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

package/dist/commands/models.js

@@ -0,0 +1,27 @@
+import chalk from 'chalk';
+const MODELS = {
+    openai: ['gpt-4o', 'gpt-4o-mini', 'gpt-4-turbo', 'o1', 'o3-mini', 'o4-mini'],
+    anthropic: ['claude-sonnet-4-20250514', 'claude-opus-4-20250514', 'claude-haiku-4-20250514'],
+    google: ['gemini-2.5-pro', 'gemini-2.5-flash', 'gemini-2.0-flash'],
+};
+export function modelsCommand(program) {
+    program
+        .command('models')
+        .description('List available models by provider')
+        .argument('[provider]', 'Filter by provider')
+        .action((provider) => {
+        const providers = provider ? [provider] : Object.keys(MODELS);
+        for (const p of providers) {
+            const models = MODELS[p];
+            if (!models) {
+                console.log(chalk.yellow(`  Unknown: ${p}`));
+                continue;
+            }
+            console.log(chalk.bold(`\n  ${p}`));
+            console.log(chalk.dim('  ' + '-'.repeat(30)));
+            for (const m of models)
+                console.log(`    ${p}/${m}`);
+        }
+        console.log('');
+    });
+}

package/dist/commands/repl.d.ts

@@ -0,0 +1,29 @@
+import * as readline from 'readline';
+import { CliInfo } from '../types.js';
+import { Session } from '../utils/sessions.js';
+/**
+ * Shared coordinator setup: detect CLIs, pick coordinator, check auth.
+ * Returns { coordinatorCmd, activeCli, installed, rl } or null if setup failed.
+ */
+export declare function initCoordinator(): Promise<{
+    coordinatorCmd: string;
+    activeCli: {
+        name: string;
+        info: CliInfo;
+        path: string;
+    };
+    installed: Array<{
+        name: string;
+        info: CliInfo;
+        path: string;
+    }>;
+    rl: readline.Interface;
+} | null>;
+/** REPL mode — interactive loop */
+export declare function runRepl(resumeSession?: Session): Promise<void>;
+/**
+ * Direct role execution — agent-mp MISMO actúa como rol.
+ * NO spawnea CLIs externos. Usa la conexión OAuth de qwen directamente.
+ * Prompt estricto: cada rol solo hace lo que debe, sin extras.
+ */
+export declare function runRole(role: string, arg: string): Promise<void>;