@beunec/rivine 0.2.1 → 0.3.1

package/dist/protocol/runner.js

@@ -8,7 +8,7 @@
  * accompanying it; it is not open source and is not licensed for
  * redistribution or derivative works.
  */
-import { closeSession, openTurn, postFsResult, resumeTurn } from '../api/workspace.js';
+import { cancelTurn, closeSession, getTurnStatus, openTurn, postFsResult, resumeTurn } from '../api/workspace.js';
 import { apiUrl } from '../config.js';
 import { accessToken } from '../auth/session.js';
 import { classify, execute } from './fsExecutor.js';
@@ -16,7 +16,21 @@ import { isSealedEnvelope, SessionKey } from './sessionKey.js';
 import { permissionModeToRate } from './permissions.js';
 import { selectRelevantTools } from '../mcp/relevance.js';
 import { readTurnStream } from './stream.js';
+import { displayStage } from '../ui/render.js';
 const PENDING_POLL_MS = 1200;
+const FOLLOW_POLL_MS = Number(process.env.RIVINE_FOLLOW_POLL_MS) || 3000;
+export function writtenPaths(request) {
+    const args = (request.args ?? {});
+    let paths = [];
+    if (request.op === 'write' || request.op === 'edit')
+        paths = [String(args.file_path ?? args.path ?? '')];
+    else if (request.op === 'upload')
+        paths = (args.files ?? []).map((f) => String(f?.path ?? ''));
+    return paths.filter((p) => p && !/(^|\/)\.rivine\//.test(p));
+}
+function isFollowSignal(value) {
+    return value.follow === true;
+}
 export class TurnRunner {
     ctx;
     cb;
@@ -26,6 +40,8 @@ export class TurnRunner {
     approvalChain = Promise.resolve();
     inFlight = new Set();
     stopped = false;
+    turnActive = false;
+    following = false;
     pollTimer = null;
     constructor(ctx, cb, mcp) {
         this.ctx = ctx;
@@ -72,7 +88,16 @@ export class TurnRunner {
         this.ctx.mcpTools = tools;
     }
     async run(message, snapshot) {
+        if (!this.ctx.codeMode) {
+            return {
+                answer: '',
+                cancelled: false,
+                error: 'No Mode selected. Pick one with /mode — Frontend Only, Backend Only, ' +
+                    'Full Stack, Plan/Ask Only, or Security Scan/Fix.',
+            };
+        }
         this.stopped = false;
+        this.turnActive = true;
         this.startPolling();
         const selection = selectRelevantTools(message, this.ctx.mcpTools ?? []);
         if (selection.servers.length) {
@@ -99,6 +124,8 @@ export class TurnRunner {
             return await this.consume(response);
         }
         finally {
+            this.turnActive = false;
+            this.following = false;
             this.stopPolling();
             await Promise.allSettled([...this.inFlight]);
         }
@@ -106,15 +133,19 @@ export class TurnRunner {
     async consume(response) {
         let answer = '';
         let pendingHitl = null;
+        let continuing = false;
         for await (const event of readTurnStream(response)) {
             switch (event.type) {
                 case 'token':
                     answer += event.content ?? '';
                     this.cb.onToken(event.content ?? '');
                     break;
-                case 'stage':
-                    this.cb.onStage(String(event.label ?? ''));
+                case 'stage': {
+                    const label = displayStage(String(event.label ?? ''));
+                    if (label)
+                        this.cb.onStage(label);
                     break;
+                }
                 case 'tool_call_start': {
                     const e = event;
                     const detail = e.args?.command ?? e.args?.filename ?? '';
@@ -158,12 +189,16 @@ export class TurnRunner {
                         options: extractOptions(e),
                         multi: Boolean(e.ui_schema?.multi ?? e.args?.multi),
                         threadId: String(e.thread_id ?? `${this.ctx.workspaceId}_${this.ctx.chatSpaceId}`),
+                        kind: hitlKind(e.hitl_type, e.args),
                     };
                     break;
                 }
                 case 'final_answer':
                     answer = String(event.content ?? answer);
                     break;
+                case 'turn_continuing':
+                    continuing = true;
+                    break;
                 case 'error': {
                     const e = event;
                     return { answer, cancelled: Boolean(e.cancelled), error: String(e.content ?? 'Unknown error') };
@@ -175,27 +210,107 @@ export class TurnRunner {
             }
         }
         if (pendingHitl) {
-            return { answer: await this.settleHitl(pendingHitl), cancelled: false };
+            const settled = await this.settleHitl(pendingHitl, answer);
+            if (isFollowSignal(settled))
+                return this.follow(settled.answer);
+            return settled;
+        }
+        if (continuing) {
+            return this.follow(answer);
         }
         return { answer, cancelled: false };
     }
-    async settleHitl(first) {
+    async follow(partial) {
+        this.following = true;
+        let lastSlice = -1;
+        this.cb.onStage('Still working — continuing on the server…');
+        try {
+            while (!this.stopped) {
+                await new Promise((r) => setTimeout(r, FOLLOW_POLL_MS));
+                let status;
+                try {
+                    status = await getTurnStatus(this.ctx.workspaceId, this.ctx.chatSpaceId);
+                }
+                catch {
+                    continue;
+                }
+                if (typeof status.slice === 'number' && status.slice !== lastSlice) {
+                    lastSlice = status.slice;
+                    this.cb.onStage(`Still working — part ${status.slice + 1}`);
+                }
+                if (status.status === 'done') {
+                    return { answer: String(status.content ?? partial), cancelled: false };
+                }
+                if (status.status === 'error') {
+                    return { answer: partial, cancelled: false, error: String(status.error ?? 'The turn failed.') };
+                }
+                if (status.status === 'cancelled') {
+                    return { answer: partial, cancelled: true };
+                }
+                if (status.status === 'paused') {
+                    if (String(status.hitl_type ?? '') === 'time_slice') {
+                        this.cb.onStage('Still working — continuing on the server…');
+                        continue;
+                    }
+                    const settled = await this.settleHitl({
+                        message: String(status.hitl_prompt ?? 'Approval required.'),
+                        tool: status.hitl_tool ? String(status.hitl_tool) : undefined,
+                        options: extractOptions({ ui_schema: status.hitl_ui_schema, args: status.hitl_args }),
+                        multi: Boolean(status.hitl_ui_schema?.multi),
+                        threadId: `${this.ctx.workspaceId}_${this.ctx.chatSpaceId}`,
+                        kind: hitlKind(status.hitl_type, status.hitl_args),
+                    }, partial);
+                    if (isFollowSignal(settled)) {
+                        partial = settled.answer;
+                        this.cb.onStage('Still working — continuing on the server…');
+                        continue;
+                    }
+                    return settled;
+                }
+                if (status.status === 'idle') {
+                    return { answer: partial, cancelled: false, error: 'The turn ended without a result.' };
+                }
+            }
+            return { answer: partial, cancelled: true };
+        }
+        finally {
+            this.following = false;
+        }
+    }
+    async settleHitl(first, priorAnswer = '') {
         let current = first;
-        let answer = '';
+        let answer = priorAnswer;
         for (let round = 0; current && round < 25; round += 1) {
             const decision = await this.enqueuePrompt(() => this.cb.requestDecision(current));
-            const body = (await resumeTurn({
-                workspaceId: this.ctx.workspaceId,
-                chatSpaceId: this.ctx.chatSpaceId,
-                threadId: current.threadId,
-                sessionId: this.ctx.sessionId,
-                sessionKey: this.key.toBase64(),
-                approved: decision.approved,
-                feedback: decision.feedback,
-                modifiedArgs: decision.modifiedArgs,
-            }));
+            if (decision.codeMode)
+                this.setCodeMode(decision.codeMode);
+            let body;
+            try {
+                body = await resumeTurn({
+                    workspaceId: this.ctx.workspaceId,
+                    chatSpaceId: this.ctx.chatSpaceId,
+                    threadId: current.threadId,
+                    sessionId: this.ctx.sessionId,
+                    sessionKey: this.key.toBase64(),
+                    approved: decision.approved,
+                    feedback: decision.feedback,
+                    modifiedArgs: decision.modifiedArgs,
+                    codeMode: decision.codeMode ?? null,
+                    codeRate: decision.codeMode ? permissionModeToRate(this.ctx.mode) : null,
+                });
+            }
+            catch (err) {
+                const detail = String(err.message ?? '');
+                if (/still running|background/i.test(detail)) {
+                    return this.continueAfterHitl(answer);
+                }
+                throw err;
+            }
             answer = String(body.response ?? answer);
             const meta = body.context_metadata ?? {};
+            if (meta.continuing) {
+                return this.continueAfterHitl(answer);
+            }
             current = meta.paused
                 ? {
                     message: String(meta.hitl_prompt ?? body.response ?? 'Approval required.'),
@@ -203,10 +318,43 @@ export class TurnRunner {
                     options: extractOptions({ ui_schema: meta.hitl_ui_schema, args: meta.hitl_args }),
                     multi: Boolean(meta.hitl_ui_schema?.multi),
                     threadId: String(meta.thread_id ?? current.threadId),
+                    kind: hitlKind(meta.hitl_type, meta.hitl_args),
                 }
                 : null;
         }
-        return answer;
+        try {
+            const status = await getTurnStatus(this.ctx.workspaceId, this.ctx.chatSpaceId);
+            if (status.status === 'running' || status.continuing) {
+                return this.continueAfterHitl(answer);
+            }
+            if (status.status === 'paused' && String(status.hitl_type ?? '') !== 'time_slice') {
+                return this.settleHitl({
+                    message: String(status.hitl_prompt ?? 'Approval required.'),
+                    tool: status.hitl_tool ? String(status.hitl_tool) : undefined,
+                    options: extractOptions({ ui_schema: status.hitl_ui_schema, args: status.hitl_args }),
+                    multi: Boolean(status.hitl_ui_schema?.multi),
+                    threadId: `${this.ctx.workspaceId}_${this.ctx.chatSpaceId}`,
+                    kind: hitlKind(status.hitl_type, status.hitl_args),
+                }, answer);
+            }
+            if (status.status === 'error') {
+                return { answer, cancelled: false, error: String(status.error ?? 'The turn failed.') };
+            }
+            if (status.status === 'cancelled') {
+                return { answer, cancelled: true };
+            }
+            if (status.status === 'done' && status.content) {
+                return { answer: String(status.content), cancelled: false };
+            }
+        }
+        catch {
+        }
+        return { answer, cancelled: false };
+    }
+    async continueAfterHitl(answer) {
+        if (this.following)
+            return { follow: true, answer };
+        return this.follow(answer);
     }
     dispatch(request) {
         if (this.stopped || this.seen.has(request.request_id))
@@ -218,6 +366,10 @@ export class TurnRunner {
                 this.seen.add(id);
         }
         this.seen.add(request.request_id);
+        if (this.following && request.op !== 'ask') {
+            const args = (request.args ?? {});
+            this.cb.onTool(String(request.op), String(args.command ?? args.path ?? args.file_path ?? ''));
+        }
         const task = (async () => {
             let outcome;
             try {
@@ -267,6 +419,10 @@ export class TurnRunner {
             catch (err) {
                 outcome = { ok: false, error: err.message };
             }
+            if (this.following && outcome.ok) {
+                for (const path of writtenPaths(request))
+                    this.cb.onFileTouched(path, 'written');
+            }
             try {
                 await postFsResult(this.ctx.sessionId, request.request_id, outcome, this.key);
             }
@@ -334,14 +490,34 @@ export class TurnRunner {
         }
     }
     async shutdown() {
+        const wasActive = this.turnActive;
         this.stopped = true;
         this.stopPolling();
+        if (wasActive)
+            await cancelTurn(this.ctx.workspaceId, this.ctx.chatSpaceId);
         await closeSession(this.ctx.sessionId);
     }
 }
-function extractOptions(event) {
+export function hitlKind(hitlType, args) {
+    const field = args && typeof args === 'object' ? String(args.field ?? '') : '';
+    return String(hitlType ?? '') === 'code_clarification' && field === 'mode'
+        ? 'code_mode'
+        : 'other';
+}
+export function extractOptions(event) {
+    const schemaEnum = (() => {
+        const props = event?.ui_schema?.properties;
+        if (!props || typeof props !== 'object')
+            return undefined;
+        for (const value of Object.values(props)) {
+            if (Array.isArray(value?.enum) && value.enum.length)
+                return value.enum;
+        }
+        return undefined;
+    })();
     const raw = event?.ui_schema?.options ??
         event?.ui_schema?.choices ??
+        schemaEnum ??
         event?.args?.options ??
         event?.options;
     if (!Array.isArray(raw) || raw.length === 0)

package/dist/protocol/shell.js

@@ -104,6 +104,9 @@ function shellInvocation(command) {
     }
     return { file: process.env.SHELL || '/bin/sh', args: ['-c', command] };
 }
+function agentEnv() {
+    return { ...process.env, GIT_PAGER: 'cat', PAGER: 'cat', GIT_TERMINAL_PROMPT: '0' };
+}
 function runWithPty(pty, command, options) {
     const { file, args } = shellInvocation(command);
     const tail = new Tail(MAX_OUTPUT_CHARS);
@@ -112,7 +115,7 @@ function runWithPty(pty, command, options) {
         cols: options.cols ?? 120,
         rows: options.rows ?? 30,
         cwd: options.cwd,
-        env: process.env,
+        env: agentEnv(),
     });
     let settled = false;
     let timedOut = false;
@@ -189,7 +192,7 @@ function runWithPipes(command, options) {
     const tail = new Tail(MAX_OUTPUT_CHARS);
     const child = spawn(file, args, {
         cwd: options.cwd,
-        env: process.env,
+        env: agentEnv(),
         stdio: ['pipe', 'pipe', 'pipe'],
     });
     let settled = false;

package/dist/runHeadless.js

@@ -11,6 +11,7 @@
 import { InsufficientCredits } from './api/workspace.js';
 import { siteUrl } from './config.js';
 import { TurnRunner } from './protocol/runner.js';
+import { permissionModeToRate } from './protocol/permissions.js';
 import { creditShortfall, startSession } from './session.js';
 import { HeadlessRenderer, installTeardown } from './ui/headless.js';
 export async function runHeadless(options) {
@@ -84,7 +85,9 @@ export async function runHeadless(options) {
             },
             requestDecision: async (request) => {
                 out.endAnswer();
-                out.line('notice', `Approval needed but no terminal to ask on: ${request.message}`);
+                out.line('notice', request.kind === 'code_mode'
+                    ? 'No Mode selected. Pass -m frontend|backend|fullstack|simple|security.'
+                    : `Approval needed but no terminal to ask on: ${request.message}`);
                 return { approved: false, feedback: 'No interactive terminal available.' };
             },
             askQuestion: async (question) => {
@@ -102,6 +105,11 @@ export async function runHeadless(options) {
         answer = result.answer ?? '';
         if (result.error) {
             out.line('error', result.error);
+            if (/credit|insufficient/i.test(result.error)) {
+                out.line('notice', `Top up at ${siteUrl()}/credits`);
+                emit(false, 2, result.error);
+                return 2;
+            }
             emit(false, 1, result.error);
             return 1;
         }
@@ -111,7 +119,7 @@ export async function runHeadless(options) {
         if (out.refusalCount > 0) {
             const advice = options.mode === 'plan'
                 ? 'plan mode makes no changes — re-run without --plan'
-                : `re-run with -m acceptEdits, or --bypass in CI (mode was ${options.mode})`;
+                : `re-run with --rate bypass (Rate was ${permissionModeToRate(options.mode)})`;
             const message = `${out.refusalCount} operation(s) were skipped because there is no terminal ` +
                 `to approve them: ${advice}.`;
             out.line('error', message);

package/dist/session.js

@@ -8,12 +8,25 @@
  * accompanying it; it is not open source and is not licensed for
  * redistribution or derivative works.
  */
+import { readFileSync } from 'node:fs';
 import { stat } from 'node:fs/promises';
-import { basename, join } from 'node:path';
-import { bootstrap, fetchCredits } from './api/workspace.js';
+import { basename, dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { bootstrap, fetchCredits, OnboardingRequired } from './api/workspace.js';
+import { openBrowser } from './auth/pkce.js';
 import { isSignedIn, login } from './auth/session.js';
 import { McpManager } from './mcp/manager.js';
 import { buildSnapshot } from './protocol/snapshot.js';
+export function packageVersion() {
+    try {
+        const here = dirname(fileURLToPath(import.meta.url));
+        const pkg = JSON.parse(readFileSync(join(here, '..', 'package.json'), 'utf8'));
+        return String(pkg.version ?? '0.0.0');
+    }
+    catch {
+        return '0.0.0';
+    }
+}
 async function localMemoryPresent(cwd) {
     try {
         const info = await stat(join(cwd, '.rivine', 'local_memory.md'));
@@ -23,6 +36,30 @@ async function localMemoryPresent(cwd) {
         return false;
     }
 }
+const ONBOARDING_POLL_MS = 5_000;
+const ONBOARDING_WAIT_MS = 20 * 60_000;
+async function bootstrapAfterOnboarding(cwd, project, options) {
+    let waitingSince = 0;
+    for (;;) {
+        try {
+            return await bootstrap(cwd, project);
+        }
+        catch (err) {
+            if (!(err instanceof OnboardingRequired))
+                throw err;
+            if (!waitingSince) {
+                waitingSince = Date.now();
+                options.onNotice?.(`${err.message} Opening ${err.url} — choose your cloudhandle there, then come back. Rivine Code continues by itself.`);
+                options.onLoginUrl?.(err.url);
+                openBrowser(err.url);
+            }
+            else if (Date.now() - waitingSince > ONBOARDING_WAIT_MS) {
+                throw new Error(`Your Aselius account is not set up yet. Finish it at ${err.url}, then run \`rivine\` again.`);
+            }
+            await new Promise((r) => setTimeout(r, ONBOARDING_POLL_MS));
+        }
+    }
+}
 export async function startSession(options) {
     const { cwd } = options;
     if (!(await isSignedIn())) {
@@ -33,7 +70,10 @@ export async function startSession(options) {
         });
     }
     const project = basename(cwd) || 'project';
-    const result = await bootstrap(cwd, project);
+    const result = await bootstrapAfterOnboarding(cwd, project, options);
+    for (const notice of continuationNotices(result, packageVersion())) {
+        options.onNotice?.(notice);
+    }
     const mcp = new McpManager();
     const mcpReady = mcp.connectAll(cwd).catch(() => []);
     return {
@@ -55,3 +95,29 @@ export function creditShortfall(balance, minimums) {
         return null;
     return balance < floor ? floor : null;
 }
+export function compareSemver(a, b) {
+    const parts = (v) => String(v || '0')
+        .replace(/^v/i, '')
+        .split(/[.+-]/)
+        .map((p) => parseInt(p, 10) || 0);
+    const aa = parts(a);
+    const bb = parts(b);
+    const n = Math.max(aa.length, bb.length);
+    for (let i = 0; i < n; i += 1) {
+        const d = (aa[i] ?? 0) - (bb[i] ?? 0);
+        if (d)
+            return d < 0 ? -1 : 1;
+    }
+    return 0;
+}
+export function continuationNotices(bootstrap, localVersion) {
+    const out = [];
+    const min = bootstrap.min_cli_version;
+    if (min && compareSemver(localVersion, min) < 0) {
+        out.push(`This CLI is ${localVersion}; long turns need >= ${min}. Upgrade: npm install -g @beunec/rivine@latest`);
+    }
+    if (bootstrap.continuation_enabled === false) {
+        out.push('This Workspace has turn continuation off — long Rivine Code builds may stop at the server time limit.');
+    }
+    return out;
+}