@getmegabrain/cli 0.1.0

package/README.md

@@ -0,0 +1,40 @@
+# @getmegabrain/cli
+
+A thin wrapper around [OpenCode](https://opencode.ai) that signs you into
+MegaBrain and points OpenCode at the MegaBrain Gateway automatically — no
+provider API keys to configure.
+
+## Install
+
+```sh
+npm install -g @getmegabrain/cli
+```
+
+## Usage
+
+```sh
+megabrain            # signs in on first run, then starts OpenCode
+megabrain login      # sign in (or re-sign-in) explicitly
+megabrain whoami      # print the signed-in account's email
+megabrain logout      # forget local credentials
+```
+
+Any arguments after `megabrain` are passed straight through to `opencode`,
+e.g. `megabrain run "fix the failing test"`.
+
+## How it works
+
+- `megabrain login` starts a device-authorization flow: it requests a short
+  code from `getmegabrain.com`, opens your browser to confirm it, and polls
+  until you approve. On approval it receives a MegaBrain Gateway token.
+- That token is written to `~/.config/megabrain/credentials.json` (mode
+  `0600`) and to `~/.config/opencode/opencode.json` as an OpenAI-compatible
+  provider pointed at the MegaBrain Gateway — the same config shape BrainClaw
+  writes server-side for its own sandboxes
+  (`services/kiloclaw/controller/src/opencode-config.ts`).
+- Every other command execs the real `opencode` binary (installed as a
+  dependency of this package), so it behaves exactly like OpenCode — this
+  package only handles auth and gateway wiring.
+
+Override the target deployment for local development with
+`MEGABRAIN_APP_URL` (defaults to `https://getmegabrain.com`).

package/dist/constants.js

@@ -0,0 +1,9 @@
+/**
+ * Base URL of the MegaBrain web app (device-auth + gateway both live here).
+ * Override for local development against a non-production deployment.
+ */
+export const APP_BASE_URL = (process.env.MEGABRAIN_APP_URL ?? 'https://getmegabrain.com').replace(/\/+$/, '');
+/** OpenAI-compatible gateway root; OpenCode's provider appends `/chat/completions`. */
+export const GATEWAY_BASE_URL = `${APP_BASE_URL}/api/gateway/`;
+/** Gateway model id used when the user hasn't picked one. */
+export const DEFAULT_MODEL_ID = 'kilo-auto/balanced';

package/dist/credentials.js

@@ -0,0 +1,26 @@
+import fs from 'node:fs';
+import { CREDENTIALS_FILE, MEGABRAIN_CONFIG_DIR } from './paths.js';
+export function readCredentials() {
+    try {
+        const raw = fs.readFileSync(CREDENTIALS_FILE, 'utf8');
+        const parsed = JSON.parse(raw);
+        if (!parsed.token || !parsed.userId || !parsed.userEmail)
+            return null;
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+}
+export function writeCredentials(credentials) {
+    fs.mkdirSync(MEGABRAIN_CONFIG_DIR, { recursive: true });
+    fs.writeFileSync(CREDENTIALS_FILE, JSON.stringify(credentials, null, 2), { mode: 0o600 });
+}
+export function clearCredentials() {
+    try {
+        fs.rmSync(CREDENTIALS_FILE, { force: true });
+    }
+    catch {
+        // Nothing to remove.
+    }
+}

package/dist/device-auth.js

@@ -0,0 +1,65 @@
+import { spawn } from 'node:child_process';
+import { APP_BASE_URL } from './constants.js';
+async function createDeviceAuthCode() {
+    const res = await fetch(`${APP_BASE_URL}/api/device-auth/codes`, { method: 'POST' });
+    if (!res.ok) {
+        throw new Error(`Could not start sign-in (HTTP ${res.status}). Please try again.`);
+    }
+    return (await res.json());
+}
+async function pollDeviceAuthCode(code) {
+    const res = await fetch(`${APP_BASE_URL}/api/device-auth/codes/${encodeURIComponent(code)}`);
+    return (await res.json());
+}
+/**
+ * Best-effort browser launch; the printed URL is always the fallback.
+ *
+ * `spawn` reports a missing binary via an async `error` event, not a thrown
+ * exception, so a listener is required even though we ignore it — otherwise
+ * an unhandled `error` event crashes the process.
+ */
+function tryOpenBrowser(url) {
+    const platform = process.platform;
+    const command = platform === 'darwin' ? 'open' : platform === 'win32' ? 'start' : 'xdg-open';
+    const args = platform === 'win32' ? ['', url] : [url];
+    try {
+        const child = spawn(command, args, {
+            shell: platform === 'win32',
+            stdio: 'ignore',
+            detached: true,
+        });
+        child.on('error', () => {
+            // Ignore — user can open the URL manually.
+        });
+        child.unref();
+    }
+    catch {
+        // Ignore — user can open the URL manually.
+    }
+}
+const POLL_INTERVAL_MS = 2000;
+export async function login(log = console.log) {
+    const { code, verificationUrl, expiresIn } = await createDeviceAuthCode();
+    log('');
+    log(`  Confirm this code:  ${code}`);
+    log(`  Sign in at:         ${verificationUrl}`);
+    log('');
+    log('  Opening your browser…');
+    tryOpenBrowser(verificationUrl);
+    const deadline = Date.now() + expiresIn * 1000;
+    while (Date.now() < deadline) {
+        await new Promise(resolve => setTimeout(resolve, POLL_INTERVAL_MS));
+        const result = await pollDeviceAuthCode(code);
+        if (result.status === 'approved') {
+            return { token: result.token, userId: result.userId, userEmail: result.userEmail };
+        }
+        if (result.status === 'denied') {
+            throw new Error('Sign-in was denied.');
+        }
+        if (result.status === 'expired') {
+            throw new Error('Sign-in code expired. Run `megabrain login` again.');
+        }
+        // 'pending' — keep polling.
+    }
+    throw new Error('Sign-in timed out. Run `megabrain login` again.');
+}

package/dist/index.js

@@ -0,0 +1,70 @@
+#!/usr/bin/env node
+import { spawn } from 'node:child_process';
+import { login } from './device-auth.js';
+import { readCredentials, writeCredentials, clearCredentials } from './credentials.js';
+import { writeOpenCodeConfig } from './opencode-config.js';
+async function ensureSignedIn() {
+    if (readCredentials())
+        return;
+    console.log('Signing in to MegaBrain…');
+    const { token, userId, userEmail } = await login();
+    writeCredentials({ token, userId, userEmail });
+    writeOpenCodeConfig(token);
+    console.log(`\nSigned in as ${userEmail}.\n`);
+}
+async function runLogin() {
+    console.log('Signing in to MegaBrain…');
+    const { token, userId, userEmail } = await login();
+    writeCredentials({ token, userId, userEmail });
+    writeOpenCodeConfig(token);
+    console.log(`\nSigned in as ${userEmail}. Run \`megabrain\` to start coding.\n`);
+}
+function runLogout() {
+    clearCredentials();
+    console.log('Signed out.');
+}
+function runWhoami() {
+    const credentials = readCredentials();
+    if (!credentials) {
+        console.log('Not signed in. Run `megabrain login`.');
+        return;
+    }
+    console.log(credentials.userEmail);
+}
+function runOpenCode(args) {
+    return new Promise((resolve, reject) => {
+        const child = spawn('opencode', args, { stdio: 'inherit' });
+        child.on('error', err => {
+            if (err.code === 'ENOENT') {
+                reject(new Error('Could not find `opencode` on your PATH. Try reinstalling: npm install -g @getmegabrain/cli'));
+            }
+            else {
+                reject(err);
+            }
+        });
+        child.on('exit', code => resolve(code ?? 0));
+    });
+}
+async function main() {
+    const command = process.argv[2];
+    switch (command) {
+        case 'login':
+            await runLogin();
+            return;
+        case 'logout':
+            runLogout();
+            return;
+        case 'whoami':
+            runWhoami();
+            return;
+        default: {
+            await ensureSignedIn();
+            const exitCode = await runOpenCode(process.argv.slice(2));
+            process.exitCode = exitCode;
+        }
+    }
+}
+main().catch(err => {
+    console.error(`\nError: ${err instanceof Error ? err.message : String(err)}`);
+    process.exitCode = 1;
+});

package/dist/opencode-config.js

@@ -0,0 +1,34 @@
+/**
+ * Writes OpenCode's config so it authenticates against the MegaBrain Gateway
+ * with the token issued during `megabrain login`, instead of requiring the
+ * user to configure a provider by hand.
+ *
+ * Mirrors services/kiloclaw/controller/src/opencode-config.ts (which does the
+ * same thing server-side for BrainClaw sandboxes) — same config shape, same
+ * gateway, adapted to write to the local user's OpenCode config directory
+ * instead of a pinned in-container path.
+ */
+import fs from 'node:fs';
+import { GATEWAY_BASE_URL, DEFAULT_MODEL_ID } from './constants.js';
+import { OPENCODE_CONFIG_DIR, OPENCODE_CONFIG_FILE } from './paths.js';
+const PROVIDER_ID = 'megabrain';
+/** OpenCode's `@ai-sdk/openai-compatible` provider appends `/chat/completions` to `baseURL`. */
+function toOpenCodeBaseUrl(gatewayBaseUrl) {
+    return gatewayBaseUrl.replace(/\/+$/, '') + '/v1';
+}
+export function writeOpenCodeConfig(token, modelId = DEFAULT_MODEL_ID) {
+    const config = {
+        $schema: 'https://opencode.ai/config.json',
+        provider: {
+            [PROVIDER_ID]: {
+                npm: '@ai-sdk/openai-compatible',
+                name: 'MegaBrain Gateway',
+                options: { baseURL: toOpenCodeBaseUrl(GATEWAY_BASE_URL), apiKey: token },
+                models: { [modelId]: { name: modelId } },
+            },
+        },
+        model: `${PROVIDER_ID}/${modelId}`,
+    };
+    fs.mkdirSync(OPENCODE_CONFIG_DIR, { recursive: true });
+    fs.writeFileSync(OPENCODE_CONFIG_FILE, JSON.stringify(config, null, 2), { mode: 0o600 });
+}

package/dist/paths.js

@@ -0,0 +1,11 @@
+import os from 'node:os';
+import path from 'node:path';
+/** XDG_CONFIG_HOME, falling back to the platform default (`~/.config` on macOS/Linux). */
+function configHome() {
+    return process.env.XDG_CONFIG_HOME || path.join(os.homedir(), '.config');
+}
+export const MEGABRAIN_CONFIG_DIR = path.join(configHome(), 'megabrain');
+export const CREDENTIALS_FILE = path.join(MEGABRAIN_CONFIG_DIR, 'credentials.json');
+/** Matches OpenCode's own config resolution (`$XDG_CONFIG_HOME/opencode` / `~/.config/opencode`). */
+export const OPENCODE_CONFIG_DIR = path.join(configHome(), 'opencode');
+export const OPENCODE_CONFIG_FILE = path.join(OPENCODE_CONFIG_DIR, 'opencode.json');

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@getmegabrain/cli",
+  "version": "0.1.0",
+  "description": "MegaBrain CLI — sign in once, then code from your terminal via OpenCode wired to the MegaBrain Gateway.",
+  "license": "MIT",
+  "type": "module",
+  "bin": {
+    "megabrain": "dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "postbuild": "chmod +x dist/index.js",
+    "dev": "tsx src/index.ts",
+    "typecheck": "tsgo --noEmit",
+    "test": "vitest run --passWithNoTests",
+    "test:watch": "vitest",
+    "lint": "pnpm -w exec oxlint --config .oxlintrc.json packages/megabrain-cli/src"
+  },
+  "dependencies": {
+    "opencode-ai": "^1.17.11"
+  },
+  "devDependencies": {
+    "@types/node": "catalog:",
+    "@typescript/native-preview": "catalog:",
+    "tsx": "catalog:",
+    "typescript": "catalog:",
+    "vitest": "catalog:"
+  }
+}