repoburg 1.3.163 → 1.3.166

package/platform-cli.js

@@ -5,7 +5,8 @@ const axios = require('axios');
 const path = require('path');
 const fs = require('fs/promises');
 const packageJson = require('./package.json');
-const { spawn } = require('child_process');
+const { spawn, spawnSync } = require('child_process');
+const os = require('os');
 
 const DAEMON_BASE_URL = 'http://localhost:9998';
 
@@ -517,4 +518,266 @@ program
         }
     });
 
+// ===== Tunnel Commands =====
+
+const TUNNEL_CONFIG_DIR = path.join(os.homedir(), '.config', 'tunnel-client');
+const DEFAULT_MCP_URL = 'http://localhost:9998/mcp';
+const TUNNEL_CLIENT_INSTALL_URL = 'https://github.com/openai/tunnel-client/releases/latest';
+
+const getTunnelConfigPath = (profile) => path.join(TUNNEL_CONFIG_DIR, `${profile}.yaml`);
+
+const generateTunnelYaml = (tunnelId, apiKeyRef, mcpUrl) => {
+    return `config_version: 1
+control_plane:
+  base_url: "https://api.openai.com"
+
+  tunnel_id: "${tunnelId}"
+  api_key: "${apiKeyRef}"
+health:
+  listen_addr: "127.0.0.1:8080"
+admin_ui:
+  open_browser: false
+log:
+  level: info
+  format: json
+mcp:
+  server_urls:
+    - channel: main
+      url: "${mcpUrl}"
+`;
+};
+
+/** Checks if the tunnel-client binary is on PATH. */
+const validateTunnelBinary = () => {
+    const result = spawnSync('tunnel-client', ['--version'], { stdio: 'pipe' });
+    return !result.error;
+};
+
+const tunnelCmd = program.command('tunnel').description('Manage MCP tunnel profiles for ChatGPT/OpenAI connectivity.');
+
+tunnelCmd
+    .command('create')
+    .description('Create a new tunnel profile.')
+    .requiredOption('-p, --profile <name>', 'Profile name')
+    .option('-t, --tunnel-id <id>', 'Tunnel ID from OpenAI Platform')
+    .option('-k, --api-key <key>', 'API key (defaults to CONTROL_PLANE_API_KEY env var)')
+    .option('-m, --mcp-url <url>', 'MCP server URL', DEFAULT_MCP_URL)
+    .action(async (options) => {
+        const { default: chalk } = await import('chalk');
+
+        if (!options.tunnelId) {
+            console.error(chalk.red('Missing required option: --tunnel-id.'));
+            console.error(chalk.gray('Get your tunnel ID from https://platform.openai.com/settings/organization/tunnels'));
+            process.exit(1);
+        }
+
+        const apiKeyRef = options.apiKey
+            ? options.apiKey
+            : process.env.CONTROL_PLANE_API_KEY
+                ? 'env:CONTROL_PLANE_API_KEY'
+                : null;
+
+        if (!apiKeyRef) {
+            console.error(chalk.red('Missing API key.'));
+            console.error(chalk.yellow('Set the CONTROL_PLANE_API_KEY env var or use --api-key.'));
+            console.error(chalk.gray('Create a key at https://platform.openai.com/settings/organization/api-keys'));
+            process.exit(1);
+        }
+
+        const configPath = getTunnelConfigPath(options.profile);
+
+        // Warn if overwriting an existing profile.
+        try {
+            await fs.access(configPath);
+            console.log(chalk.yellow(`Warning: Profile '${options.profile}' already exists. Overwriting.`));
+        } catch {
+            // File doesn't exist — fine.
+        }
+
+        await fs.mkdir(TUNNEL_CONFIG_DIR, { recursive: true });
+        const yaml = generateTunnelYaml(options.tunnelId, apiKeyRef, options.mcpUrl);
+        await fs.writeFile(configPath, yaml, 'utf-8');
+
+        console.log(chalk.green(`\u2713 Tunnel profile '${options.profile}' created.`));
+        console.log(chalk.gray(`  Config: ${configPath}`));
+        console.log(chalk.cyan(`  Run with: repoburg tunnel run --profile ${options.profile}`));
+    });
+
+tunnelCmd
+    .command('delete <profile>')
+    .description('Delete a tunnel profile.')
+    .action(async (profile) => {
+        const { default: chalk } = await import('chalk');
+        const configPath = getTunnelConfigPath(profile);
+
+        try {
+            await fs.access(configPath);
+        } catch {
+            console.error(chalk.red(`Tunnel profile '${profile}' not found.`));
+            console.error(chalk.gray(`  Expected at: ${configPath}`));
+            process.exit(1);
+        }
+
+        await fs.unlink(configPath);
+        console.log(chalk.green(`\u2713 Tunnel profile '${profile}' deleted.`));
+    });
+
+tunnelCmd
+    .command('run <profile>')
+    .description('Run a tunnel profile (connects to ChatGPT/OpenAI).')
+    .action(async (profile) => {
+        const { default: chalk } = await import('chalk');
+
+        if (!validateTunnelBinary()) {
+            console.error(chalk.red('tunnel-client not found on PATH.'));
+            console.error(chalk.yellow(`Install it from ${TUNNEL_CLIENT_INSTALL_URL}`));
+            process.exit(1);
+        }
+
+        const configPath = getTunnelConfigPath(profile);
+
+        let configContent;
+        try {
+            configContent = await fs.readFile(configPath, 'utf-8');
+        } catch {
+            console.error(chalk.red(`Tunnel profile '${profile}' not found.`));
+            console.error(chalk.yellow(`Create one with: repoburg tunnel create --profile ${profile} --tunnel-id <id>`));
+            process.exit(1);
+        }
+
+        // Validate tunnel_id is present and non-empty.
+        const tunnelIdMatch = configContent.match(/tunnel_id:\s*"?([^\s"]+)"?/);
+        if (!tunnelIdMatch || !tunnelIdMatch[1]) {
+            console.error(chalk.red(`Config error: tunnel_id is missing or empty in profile '${profile}'.`));
+            console.error(chalk.yellow(`Recreate with: repoburg tunnel create --profile ${profile} --tunnel-id <id>`));
+            process.exit(1);
+        }
+
+        // Validate api_key is present and non-empty.
+        const apiKeyMatch = configContent.match(/api_key:\s*"?([^\s"]+)"?/);
+        if (!apiKeyMatch || !apiKeyMatch[1]) {
+            console.error(chalk.red(`Config error: api_key is missing or empty in profile '${profile}'.`));
+            console.error(chalk.yellow(`Recreate with: repoburg tunnel create --profile ${profile} --tunnel-id <id>`));
+            process.exit(1);
+        }
+
+        // If api_key references an env var, verify it's set.
+        if (apiKeyMatch[1].startsWith('env:')) {
+            const envVarName = apiKeyMatch[1].slice(4);
+            if (!process.env[envVarName]) {
+                console.error(chalk.red(`${envVarName} environment variable is not set.`));
+                console.error(chalk.yellow(`Export it first: export ${envVarName}=sk-...`));
+                process.exit(1);
+            }
+        }
+
+        console.log(chalk.cyan(`Starting tunnel-client with profile '${profile}'...`));
+        console.log(chalk.gray(`  Config: ${configPath}`));
+
+        const child = spawn('tunnel-client', ['run', '--profile', profile], {
+            stdio: 'inherit',
+            shell: true,
+            env: { ...process.env },
+        });
+
+        child.on('error', (error) => {
+            console.error(chalk.red('Failed to start tunnel-client:'), error.message);
+            process.exit(1);
+        });
+
+        child.on('exit', (code) => {
+            if (code !== 0) {
+                console.log(chalk.yellow(`tunnel-client exited with code ${code}`));
+            }
+            process.exit(code || 0);
+        });
+    });
+
+tunnelCmd
+    .command('list')
+    .description('List all tunnel profiles.')
+    .action(async () => {
+        const { default: chalk } = await import('chalk');
+        const Table = require('cli-table3');
+
+        let files;
+        try {
+            files = await fs.readdir(TUNNEL_CONFIG_DIR);
+        } catch {
+            console.log(chalk.yellow('No tunnel profiles found.'));
+            console.log(chalk.gray('Create one with: repoburg tunnel create --profile <name> --tunnel-id <id>'));
+            return;
+        }
+
+        const yamlFiles = files.filter(f => f.endsWith('.yaml'));
+        if (yamlFiles.length === 0) {
+            console.log(chalk.yellow('No tunnel profiles found.'));
+            console.log(chalk.gray('Create one with: repoburg tunnel create --profile <name> --tunnel-id <id>'));
+            return;
+        }
+
+        const table = new Table({
+            head: ['PROFILE', 'TUNNEL_ID', 'MCP_URL'].map(h => chalk.cyan(h)),
+            colWidths: [20, 35, 40]
+        });
+
+        for (const file of yamlFiles) {
+            const profileName = file.replace(/\.yaml$/, '');
+            const configPath = path.join(TUNNEL_CONFIG_DIR, file);
+            try {
+                const content = await fs.readFile(configPath, 'utf-8');
+                const tunnelIdMatch = content.match(/(?:^|\s)tunnel_id:\s*"?([^\s"]+)"?/);
+                const urlMatch = content.match(/(?:^|\s)url:\s*"?([^\s"]+)"?/);
+                table.push([
+                    profileName,
+                    tunnelIdMatch ? tunnelIdMatch[1] : chalk.gray('(missing)'),
+                    urlMatch ? urlMatch[1] : chalk.gray('(missing)'),
+                ]);
+            } catch {
+                table.push([profileName, chalk.red('(read error)'), '-']);
+            }
+        }
+
+        console.log(table.toString());
+    });
+
+tunnelCmd
+    .command('doctor <profile>')
+    .description('Run tunnel-client doctor on a profile.')
+    .action(async (profile) => {
+        const { default: chalk } = await import('chalk');
+
+        if (!validateTunnelBinary()) {
+            console.error(chalk.red('tunnel-client not found on PATH.'));
+            console.error(chalk.yellow(`Install it from ${TUNNEL_CLIENT_INSTALL_URL}`));
+            process.exit(1);
+        }
+
+        const configPath = getTunnelConfigPath(profile);
+        try {
+            await fs.access(configPath);
+        } catch {
+            console.error(chalk.red(`Tunnel profile '${profile}' not found.`));
+            console.error(chalk.yellow(`Create one with: repoburg tunnel create --profile ${profile} --tunnel-id <id>`));
+            process.exit(1);
+        }
+
+        console.log(chalk.cyan(`Running tunnel-client doctor for profile '${profile}'...`));
+
+        const child = spawn('tunnel-client', ['doctor', '--profile', profile, '--explain'], {
+            stdio: 'inherit',
+            shell: true,
+            env: { ...process.env },
+        });
+
+        child.on('error', (error) => {
+            console.error(chalk.red('Failed to run tunnel-client doctor:'), error.message);
+            process.exit(1);
+        });
+
+        child.on('exit', (code) => {
+            process.exit(code || 0);
+        });
+    });
+
 program.parse(process.argv);