openthrottle 0.1.4 → 0.1.6

package/dist/init.js

@@ -0,0 +1,486 @@
+// =============================================================================
+// openthrottle init — Set up Open Throttle in any Node.js project.
+//
+// Detects the project, prompts for config, generates .openthrottle.yml +
+// wake-sandbox.yml, creates a Daytona snapshot, and prints next steps.
+// =============================================================================
+import { readFileSync, writeFileSync, existsSync, mkdirSync, readdirSync, statSync } from 'node:fs';
+import { join, relative } from 'node:path';
+import { execFileSync } from 'node:child_process';
+import prompts from 'prompts';
+import { stringify } from 'yaml';
+import { getErrorMessage } from './types.js';
+const cwd = process.cwd();
+// ---------------------------------------------------------------------------
+// 1. Detect project
+// ---------------------------------------------------------------------------
+function detectProject() {
+    const pkgPath = join(cwd, 'package.json');
+    if (!existsSync(pkgPath)) {
+        console.error('No package.json found. openthrottle init currently supports Node.js projects only.');
+        process.exit(1);
+    }
+    let pkg;
+    try {
+        pkg = JSON.parse(readFileSync(pkgPath, 'utf8'));
+    }
+    catch {
+        console.error('Could not parse package.json. Is it valid JSON?');
+        process.exit(1);
+    }
+    const scripts = pkg.scripts || {};
+    const rawName = pkg.name?.replace(/^@[^/]+\//, '') || 'project';
+    const name = rawName.toLowerCase().replace(/[^a-z0-9-]/g, '-').replace(/-+/g, '-');
+    // Detect package manager
+    let pm = 'npm';
+    if (pkg.packageManager?.startsWith('pnpm'))
+        pm = 'pnpm';
+    else if (pkg.packageManager?.startsWith('yarn'))
+        pm = 'yarn';
+    else if (existsSync(join(cwd, 'pnpm-lock.yaml')))
+        pm = 'pnpm';
+    else if (existsSync(join(cwd, 'yarn.lock')))
+        pm = 'yarn';
+    else if (existsSync(join(cwd, 'package-lock.json')))
+        pm = 'npm';
+    // Detect base branch
+    let baseBranch = 'main';
+    try {
+        const head = execFileSync('git', ['remote', 'show', 'origin'], { encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'] });
+        const match = head.match(/HEAD branch:\s*(\S+)/);
+        if (match?.[1])
+            baseBranch = match[1];
+    }
+    catch {
+        // Not a git repo or no remote — default to main
+    }
+    return {
+        name,
+        pm,
+        baseBranch,
+        test: scripts.test ? `${pm} test` : '',
+        build: scripts.build ? `${pm} build` : '',
+        lint: scripts.lint ? `${pm} lint` : '',
+        format: scripts.format ? `${pm} run format` : (pkg.devDependencies?.prettier ? 'npx prettier --write .' : ''),
+        dev: scripts.dev ? `${pm} dev --port 8080 --hostname 0.0.0.0` : '',
+    };
+}
+// ---------------------------------------------------------------------------
+// 1b. Detect .env files and extract key names
+// ---------------------------------------------------------------------------
+function detectEnvFiles() {
+    const envFiles = {};
+    const seen = new Set();
+    function scan(dir) {
+        let entries;
+        try {
+            entries = readdirSync(dir);
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            if (entry === 'node_modules' || entry === '.git' || entry === '.next' || entry === 'dist')
+                continue;
+            const full = join(dir, entry);
+            let stat;
+            try {
+                stat = statSync(full);
+            }
+            catch {
+                continue;
+            }
+            if (stat.isDirectory()) {
+                scan(full);
+                continue;
+            }
+            if (!entry.startsWith('.env'))
+                continue;
+            // Skip .env.example, .env.sample, .env.template
+            if (/\.(example|sample|template)$/i.test(entry))
+                continue;
+            const relPath = relative(cwd, full);
+            const keys = [];
+            try {
+                const content = readFileSync(full, 'utf8');
+                for (const line of content.split('\n')) {
+                    const trimmed = line.trim();
+                    if (!trimmed || trimmed.startsWith('#'))
+                        continue;
+                    const match = trimmed.replace(/^export\s+/, '').match(/^([a-zA-Z_][a-zA-Z0-9_]*)=/);
+                    if (match?.[1])
+                        keys.push(match[1]);
+                }
+            }
+            catch (err) {
+                console.error(`warning: could not read ${relPath}: ${getErrorMessage(err)}`);
+                continue;
+            }
+            if (keys.length > 0) {
+                envFiles[relPath] = keys;
+                keys.forEach(k => seen.add(k));
+            }
+        }
+    }
+    scan(cwd);
+    return { envFiles, allKeys: [...seen].sort() };
+}
+// ---------------------------------------------------------------------------
+// 2. Prompt for config
+// ---------------------------------------------------------------------------
+async function promptConfig(detected) {
+    console.log(`\n  Detected: package.json (${detected.pm})\n`);
+    const response = await prompts([
+        { type: 'text', name: 'baseBranch', message: 'Base branch', initial: detected.baseBranch },
+        { type: 'text', name: 'test', message: 'Test command', initial: detected.test },
+        { type: 'text', name: 'build', message: 'Build command', initial: detected.build },
+        { type: 'text', name: 'lint', message: 'Lint command', initial: detected.lint },
+        { type: 'text', name: 'format', message: 'Format command', initial: detected.format },
+        { type: 'text', name: 'dev', message: 'Dev command', initial: detected.dev },
+        { type: 'text', name: 'postBootstrap', message: 'Post-bootstrap command', initial: `${detected.pm} install` },
+        {
+            type: 'select', name: 'agent', message: 'Agent runtime',
+            choices: [
+                { title: 'Claude', value: 'claude' },
+                { title: 'Codex', value: 'codex' },
+                { title: 'Aider', value: 'aider' },
+            ],
+            initial: 0,
+        },
+        {
+            type: 'select', name: 'notifications', message: 'Notifications',
+            choices: [
+                { title: 'Telegram', value: 'telegram' },
+                { title: 'None', value: 'none' },
+            ],
+            initial: 0,
+        },
+        { type: 'number', name: 'maxTurns', message: 'Max turns per agent run', initial: 200, min: 1 },
+        { type: 'number', name: 'maxBudgetUsd', message: 'Max budget per run in USD (API only)', initial: 5, min: 0 },
+        { type: 'confirm', name: 'reviewEnabled', message: 'Enable automated PR review?', initial: true },
+        {
+            type: (prev) => prev ? 'number' : null,
+            name: 'maxRounds', message: 'Max review rounds', initial: 3, min: 1, max: 10,
+        },
+        { type: 'text', name: 'snapshotName', message: 'Daytona snapshot name', initial: 'openthrottle' },
+    ], { onCancel: () => { console.log('\nCancelled.'); process.exit(0); } });
+    const { baseBranch, test, build, lint, format, dev, postBootstrap, agent, notifications, maxTurns, maxBudgetUsd, reviewEnabled, maxRounds, snapshotName } = response;
+    return {
+        ...detected,
+        baseBranch: baseBranch || detected.baseBranch,
+        test: test ?? detected.test,
+        build: build ?? detected.build,
+        lint: lint ?? detected.lint,
+        format: format ?? detected.format,
+        dev: dev ?? detected.dev,
+        postBootstrap: postBootstrap,
+        agent: agent,
+        notifications: notifications,
+        maxTurns: maxTurns,
+        maxBudgetUsd: maxBudgetUsd,
+        reviewEnabled: reviewEnabled,
+        maxRounds: maxRounds,
+        snapshotName: snapshotName,
+        envFiles: {},
+        envAllKeys: [],
+    };
+}
+// ---------------------------------------------------------------------------
+// 3. Generate .openthrottle.yml
+// ---------------------------------------------------------------------------
+function generateConfig(config) {
+    const doc = {
+        base_branch: config.baseBranch,
+        test: config.test || undefined,
+        dev: config.dev || undefined,
+        format: config.format || undefined,
+        lint: config.lint || undefined,
+        build: config.build || undefined,
+        notifications: config.notifications === 'none' ? undefined : config.notifications,
+        agent: config.agent,
+        snapshot: config.snapshotName || 'openthrottle',
+        post_bootstrap: [config.postBootstrap],
+        mcp_servers: {},
+        env_files: config.envFiles && Object.keys(config.envFiles).length > 0
+            ? config.envFiles
+            : undefined,
+        limits: {
+            max_turns: config.maxTurns ?? 200,
+            max_budget_usd: config.maxBudgetUsd ?? 5,
+        },
+        review: {
+            enabled: config.reviewEnabled,
+            max_rounds: config.maxRounds ?? 3,
+        },
+    };
+    // Remove undefined fields
+    for (const key of Object.keys(doc)) {
+        if (doc[key] === undefined)
+            delete doc[key];
+    }
+    const header = [
+        '# openthrottle.yml — project config for Open Throttle (Daytona runtime)',
+        '# Generated by openthrottle init. Committed to the repo so the',
+        '# sandbox knows how to work with this project.',
+        '',
+    ].join('\n');
+    return header + stringify(doc);
+}
+// ---------------------------------------------------------------------------
+// 4. Copy wake-sandbox.yml
+// ---------------------------------------------------------------------------
+function copyWorkflow(config) {
+    const src = new URL('../templates/wake-sandbox.yml', import.meta.url);
+    const destDir = join(cwd, '.github', 'workflows');
+    const dest = join(destDir, 'wake-sandbox.yml');
+    mkdirSync(destDir, { recursive: true });
+    let content = readFileSync(src, 'utf8');
+    // Inject project-specific secrets into the workflow
+    const allKeys = config.envAllKeys || [];
+    if (allKeys.length > 0) {
+        // Add env: entries for secrets
+        const envSecrets = allKeys
+            .map(k => `          ${k}: \${{ secrets.${k} }}`)
+            .join('\n');
+        content = content.replace(/          # @@ENV_SECRETS@@ — scaffolder inserts project-specific secrets here/, envSecrets);
+        // Add --env flags for daytona create
+        const envFlags = allKeys
+            .map(k => `            --env ${k}=\${${k}} \\`)
+            .join('\n');
+        content = content.replace(/            # @@ENV_FLAGS@@ — scaffolder inserts --env flags for project secrets here/, envFlags);
+    }
+    else {
+        // No project secrets — remove the placeholder comments
+        content = content.replace(/          # @@ENV_SECRETS@@ — scaffolder inserts project-specific secrets here\n/, '');
+        content = content.replace(/            # @@ENV_FLAGS@@ — scaffolder inserts --env flags for project secrets here\n/, '');
+    }
+    writeFileSync(dest, content);
+    return dest;
+}
+// ---------------------------------------------------------------------------
+// 5. Create Daytona snapshot from pre-built image
+// ---------------------------------------------------------------------------
+function setupDaytona(config) {
+    const snapshotName = config.snapshotName || 'openthrottle';
+    const image = 'knoxgraeme/openthrottle:v1';
+    // Check daytona CLI is available
+    try {
+        execFileSync('daytona', ['--version'], { stdio: 'pipe' });
+    }
+    catch {
+        console.log(`\n  daytona CLI not found. Install it, then run:`);
+        console.log(`    daytona snapshot create ${snapshotName} --image ${image} --cpu 2 --memory 4 --disk 10\n`);
+        return;
+    }
+    // Create snapshot from pre-built image
+    try {
+        execFileSync('daytona', [
+            'snapshot', 'create', snapshotName,
+            '--image', image,
+            '--cpu', '2', '--memory', '4', '--disk', '10',
+        ], { stdio: ['pipe', 'pipe', 'pipe'], encoding: 'utf8' });
+        console.log(`  Created Daytona snapshot: ${snapshotName}`);
+    }
+    catch (err) {
+        const execErr = err;
+        if (execErr.stderr?.toString().includes('already exists')) {
+            console.log(`  Snapshot already exists: ${snapshotName}`);
+        }
+        else {
+            const detail = getErrorMessage(err);
+            console.log(`  Snapshot creation failed: ${detail}`);
+            console.log(`  You can create it manually:`);
+            console.log(`    daytona snapshot create ${snapshotName} --image ${image} --cpu 2 --memory 4 --disk 10`);
+        }
+    }
+}
+// ---------------------------------------------------------------------------
+// 6. Push .env secrets to GitHub repo secrets
+// ---------------------------------------------------------------------------
+async function pushSecrets(config) {
+    const envFiles = config.envFiles || {};
+    const paths = Object.keys(envFiles);
+    if (paths.length === 0)
+        return;
+    // Check gh is available and authenticated
+    try {
+        execFileSync('gh', ['auth', 'status'], { stdio: 'pipe' });
+    }
+    catch (err) {
+        const detail = getErrorMessage(err);
+        console.log(`\n  gh CLI check failed: ${detail}`);
+        console.log('  Skipping secret push. Run "gh auth login" then set secrets manually.\n');
+        return;
+    }
+    // Detect repo
+    let repo;
+    try {
+        repo = execFileSync('gh', ['repo', 'view', '--json', 'nameWithOwner', '--jq', '.nameWithOwner'], {
+            encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'],
+        }).trim();
+    }
+    catch (err) {
+        console.log(`\n  Could not detect GitHub repo: ${getErrorMessage(err)}`);
+        console.log('  Skipping secret push.\n');
+        return;
+    }
+    // Show what we'd push
+    console.log(`\n  Push .env secrets to GitHub repo secrets? (${repo})`);
+    console.log('  Values are encrypted at rest — not readable after upload.\n');
+    for (const [path, keys] of Object.entries(envFiles)) {
+        console.log(`    ${path} (${keys.length} keys): ${keys.join(', ')}`);
+    }
+    console.log('');
+    const { confirm } = await prompts({
+        type: 'confirm', name: 'confirm',
+        message: `Push ${config.envAllKeys.length} secret(s) to ${repo}?`, initial: false,
+    }, { onCancel: () => { } });
+    if (!confirm) {
+        console.log('  Skipped secret push.');
+        return;
+    }
+    let pushed = 0;
+    let failed = 0;
+    for (const [path, keys] of Object.entries(envFiles)) {
+        const fullPath = join(cwd, path);
+        let content;
+        try {
+            content = readFileSync(fullPath, 'utf8');
+        }
+        catch {
+            console.log(`  Could not read ${path} — skipping`);
+            failed += keys.length;
+            continue;
+        }
+        // Parse key=value pairs
+        for (const line of content.split('\n')) {
+            const trimmed = line.trim();
+            if (!trimmed || trimmed.startsWith('#'))
+                continue;
+            const cleaned = trimmed.replace(/^export\s+/, '');
+            const eqIdx = cleaned.indexOf('=');
+            if (eqIdx === -1)
+                continue;
+            const key = cleaned.slice(0, eqIdx);
+            let value = cleaned.slice(eqIdx + 1);
+            // Strip surrounding quotes
+            if ((value.startsWith('"') && value.endsWith('"')) || (value.startsWith("'") && value.endsWith("'"))) {
+                value = value.slice(1, -1);
+            }
+            if (!keys.includes(key))
+                continue;
+            try {
+                execFileSync('gh', ['secret', 'set', key, '--repo', repo], {
+                    input: value,
+                    stdio: ['pipe', 'pipe', 'pipe'],
+                });
+                pushed++;
+            }
+            catch (err) {
+                console.log(`  Failed to set ${key}: ${getErrorMessage(err)}`);
+                failed++;
+            }
+        }
+    }
+    console.log(`  Pushed ${pushed} secret(s) to ${repo}${failed > 0 ? ` (${failed} failed)` : ''}`);
+}
+// ---------------------------------------------------------------------------
+// 7. Print next steps
+// ---------------------------------------------------------------------------
+function printNextSteps(config) {
+    const agentSecret = config.agent === 'claude'
+        ? '     ANTHROPIC_API_KEY            <- option a: pay-per-use API key\n     CLAUDE_CODE_OAUTH_TOKEN      <- option b: subscription token (claude setup-token)'
+        : config.agent === 'codex'
+            ? '     OPENAI_API_KEY               <- required for Codex'
+            : '     OPENAI_API_KEY               <- or ANTHROPIC_API_KEY (depends on your Aider model)';
+    const secrets = [
+        '     DAYTONA_API_KEY              <- required',
+        agentSecret,
+    ];
+    // Project-specific secrets from env_files
+    const projectKeys = config.envAllKeys || [];
+    const projectSecrets = projectKeys.length > 0
+        ? '\n\n     Project secrets (from .env files):\n' +
+            projectKeys.map(k => `     ${k}`).join('\n')
+        : '';
+    console.log(`
+  Next steps:
+
+  1. Set GitHub repo secrets:
+${secrets.join('\n')}
+     TELEGRAM_BOT_TOKEN            <- optional (notifications)
+     TELEGRAM_CHAT_ID              <- optional (notifications)${projectSecrets}
+
+  2. Commit and push:
+     git add .openthrottle.yml .github/workflows/wake-sandbox.yml
+     git commit -m "feat: add openthrottle config"
+     git push
+
+  3. Ship your first prompt:
+     npx openthrottle ship docs/prds/my-feature.md
+`);
+}
+// ---------------------------------------------------------------------------
+// Main (exported for use by index.ts)
+// ---------------------------------------------------------------------------
+export default async function init() {
+    console.log('\n  openthrottle init\n');
+    // Step 1: Detect
+    const detected = detectProject();
+    const { envFiles, allKeys: envAllKeys } = detectEnvFiles();
+    if (Object.keys(envFiles).length > 0) {
+        console.log(`  Found ${Object.keys(envFiles).length} .env file(s):`);
+        for (const [path, keys] of Object.entries(envFiles)) {
+            console.log(`    ${path} (${keys.length} keys)`);
+        }
+        console.log('');
+    }
+    // Step 2: Prompt
+    const config = await promptConfig(detected);
+    config.envFiles = envFiles;
+    config.envAllKeys = envAllKeys;
+    // Step 3: Generate config
+    const configPath = join(cwd, '.openthrottle.yml');
+    if (existsSync(configPath)) {
+        const { overwrite } = await prompts({
+            type: 'confirm', name: 'overwrite',
+            message: '.openthrottle.yml already exists. Overwrite?', initial: false,
+        }, { onCancel: () => { console.log('\nCancelled.'); process.exit(0); } });
+        if (!overwrite) {
+            console.log('  Skipped .openthrottle.yml');
+        }
+        else {
+            writeFileSync(configPath, generateConfig(config));
+            console.log('  Generated .openthrottle.yml');
+        }
+    }
+    else {
+        writeFileSync(configPath, generateConfig(config));
+        console.log('  Generated .openthrottle.yml');
+    }
+    // Step 4: Copy workflow
+    const workflowPath = join(cwd, '.github', 'workflows', 'wake-sandbox.yml');
+    if (existsSync(workflowPath)) {
+        const { overwrite } = await prompts({
+            type: 'confirm', name: 'overwrite',
+            message: 'wake-sandbox.yml already exists. Overwrite?', initial: false,
+        }, { onCancel: () => { console.log('\nCancelled.'); process.exit(0); } });
+        if (!overwrite) {
+            console.log('  Skipped wake-sandbox.yml');
+        }
+        else {
+            copyWorkflow(config);
+            console.log('  Copied .github/workflows/wake-sandbox.yml');
+        }
+    }
+    else {
+        copyWorkflow(config);
+        console.log('  Copied .github/workflows/wake-sandbox.yml');
+    }
+    // Step 5: Create Daytona snapshot
+    setupDaytona(config);
+    // Step 6: Push secrets
+    await pushSecrets(config);
+    // Step 7: Next steps
+    printNextSteps(config);
+}

package/dist/types.js

@@ -0,0 +1,8 @@
+export function getErrorMessage(err) {
+    if (err instanceof Error) {
+        const execErr = err;
+        const stderr = execErr.stderr?.toString().trim();
+        return stderr || execErr.message;
+    }
+    return String(err);
+}

package/package.json

@@ -1,16 +1,19 @@
 {
   "name": "openthrottle",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "description": "CLI for Open Throttle — ship prompts to Daytona sandboxes.",
   "type": "module",
   "bin": {
-    "openthrottle": "./index.mjs"
+    "openthrottle": "./dist/index.js"
   },
   "files": [
-    "index.mjs",
-    "init.mjs",
+    "dist/",
     "templates/"
   ],
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build"
+  },
   "dependencies": {
     "prompts": "^2.4.2",
     "yaml": "^2.4.0"
@@ -28,5 +31,10 @@
     "daytona",
     "agent",
     "cli"
-  ]
+  ],
+  "devDependencies": {
+    "@types/node": "^25.5.0",
+    "@types/prompts": "^2.4.9",
+    "typescript": "^5.9.3"
+  }
 }