@getmegabrain/cli 0.1.4 → 0.1.5

package/dist/cloud-fork.js

@@ -0,0 +1,104 @@
+/**
+ * `megabrain --session <id> --cloud-fork` — fork a MegaBrain cloud session
+ * into a local OpenCode session.
+ *
+ * The web UI hands users this command for any cloud session. Flow:
+ *   1. Download the session export from the session-ingest worker
+ *      (`GET /api/session/:id/export`, authenticated with the same Kilo user
+ *      JWT issued by `megabrain login`).
+ *   2. `opencode import <file>` to materialize the session locally.
+ *   3. Launch `opencode --session <id> --fork` so the user continues on a
+ *      fork instead of mutating the imported original.
+ */
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+export const SESSION_INGEST_URL = (process.env.MEGABRAIN_SESSION_INGEST_URL ?? 'https://session-ingest.vasilij-lukin.workers.dev').replace(/\/+$/, '');
+const SESSION_ID_RE = /^ses_[a-z0-9]+$/i;
+export function isValidSessionId(sessionId) {
+    return SESSION_ID_RE.test(sessionId);
+}
+/**
+ * Detects `--cloud-fork` and extracts the `--session <id>` / `--session=<id>`
+ * value from raw argv. `--session` stays in passthroughArgs — it is only
+ * removed together with `--cloud-fork` by the caller when forking.
+ */
+export function parseCloudForkArgs(argv) {
+    let cloudFork = false;
+    let sessionId = null;
+    const passthroughArgs = [];
+    for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i];
+        if (arg === '--cloud-fork') {
+            cloudFork = true;
+            continue;
+        }
+        if (arg === '--session' && i + 1 < argv.length) {
+            sessionId = argv[i + 1];
+            passthroughArgs.push(arg, argv[i + 1]);
+            i++;
+            continue;
+        }
+        if (arg.startsWith('--session=')) {
+            sessionId = arg.slice('--session='.length);
+            passthroughArgs.push(arg);
+            continue;
+        }
+        passthroughArgs.push(arg);
+    }
+    return { cloudFork, sessionId, passthroughArgs };
+}
+/**
+ * Guards against error surfaces served as 200 (e.g. `{"detail":"..."}`):
+ * a valid OpenCode session export always carries `info.id`, and `opencode
+ * import` crashes with a cryptic error when it's missing.
+ */
+export function exportPayloadSessionId(payload) {
+    if (payload === null || typeof payload !== 'object')
+        return null;
+    const info = payload.info;
+    if (info === null || typeof info === 'undefined' || typeof info !== 'object')
+        return null;
+    const id = info.id;
+    return typeof id === 'string' && id.length > 0 ? id : null;
+}
+/**
+ * Downloads the cloud session export to a temp file and returns its path.
+ * The caller owns cleanup.
+ */
+export async function downloadSessionExport(sessionId, token) {
+    const url = `${SESSION_INGEST_URL}/api/session/${encodeURIComponent(sessionId)}/export`;
+    let res;
+    try {
+        res = await fetch(url, {
+            headers: { Authorization: `Bearer ${token}` },
+            signal: AbortSignal.timeout(300_000),
+        });
+    }
+    catch (err) {
+        throw new Error(`Could not reach MegaBrain to download session ${sessionId}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    if (res.status === 404) {
+        throw new Error(`Cloud session ${sessionId} was not found (or does not belong to your account).`);
+    }
+    if (res.status === 401 || res.status === 403) {
+        throw new Error('Your MegaBrain sign-in is no longer valid. Run `megabrain login` and retry.');
+    }
+    if (!res.ok) {
+        throw new Error(`Downloading session ${sessionId} failed (HTTP ${res.status}). Try again.`);
+    }
+    const body = await res.text();
+    let payload;
+    try {
+        payload = JSON.parse(body);
+    }
+    catch {
+        throw new Error(`Session ${sessionId} export is not valid JSON. Try again.`);
+    }
+    if (exportPayloadSessionId(payload) === null) {
+        throw new Error(`Session ${sessionId} export is missing session metadata. Try again.`);
+    }
+    const tmpPath = path.join(fs.mkdtempSync(path.join(os.tmpdir(), 'megabrain-cloud-fork-')), `${sessionId}.json`);
+    fs.writeFileSync(tmpPath, body, { mode: 0o600 });
+    return tmpPath;
+}

package/dist/index.js

@@ -1,10 +1,13 @@
 #!/usr/bin/env node
 import { spawn } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
 import { login } from './device-auth.js';
 import { readCredentials, writeCredentials, clearCredentials } from './credentials.js';
 import { writeOpenCodeConfig } from './opencode-config.js';
 import { fetchGatewayModelIds } from './models.js';
 import { ensureOpencodeBinary } from './opencode.js';
+import { parseCloudForkArgs, isValidSessionId, downloadSessionExport } from './cloud-fork.js';
 async function signIn() {
     console.log('Signing in to MegaBrain…');
     const { token, userId, userEmail } = await login();
@@ -53,6 +56,31 @@ function runOpenCode(args) {
         child.on('exit', code => resolve(code ?? 0));
     });
 }
+/**
+ * Forks a cloud session locally: downloads the session export from the
+ * MegaBrain session-ingest service, imports it into OpenCode, then launches
+ * OpenCode on a fork of the imported session.
+ */
+async function runCloudFork(sessionId) {
+    const credentials = readCredentials();
+    if (!credentials) {
+        throw new Error('Not signed in. Run `megabrain login` and retry.');
+    }
+    console.log(`Downloading cloud session ${sessionId}…`);
+    const exportPath = await downloadSessionExport(sessionId, credentials.token);
+    try {
+        console.log('Importing session into OpenCode…');
+        const importExitCode = await runOpenCode(['import', exportPath]);
+        if (importExitCode !== 0) {
+            throw new Error(`Importing session ${sessionId} failed (opencode exit ${importExitCode}).`);
+        }
+    }
+    finally {
+        fs.rmSync(path.dirname(exportPath), { recursive: true, force: true });
+    }
+    console.log('Starting a fork of the imported session…\n');
+    return runOpenCode(['--session', sessionId, '--fork']);
+}
 async function main() {
     const command = process.argv[2];
     switch (command) {
@@ -66,8 +94,18 @@ async function main() {
             runWhoami();
             return;
         default: {
+            const args = process.argv.slice(2);
+            const { cloudFork, sessionId } = parseCloudForkArgs(args);
+            if (cloudFork) {
+                if (!sessionId || !isValidSessionId(sessionId)) {
+                    throw new Error('Usage: megabrain --session <ses_…> --cloud-fork (a valid cloud session id is required).');
+                }
+                await ensureSignedIn();
+                process.exitCode = await runCloudFork(sessionId);
+                return;
+            }
             await ensureSignedIn();
-            const exitCode = await runOpenCode(process.argv.slice(2));
+            const exitCode = await runOpenCode(args);
             process.exitCode = exitCode;
         }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@getmegabrain/cli",
-  "version": "0.1.4",
+  "version": "0.1.5",
   "description": "MegaBrain CLI — sign in once, then code from your terminal via OpenCode wired to the MegaBrain Gateway.",
   "license": "MIT",
   "type": "module",