@loicngr/kobo 2.1.29 → 2.1.30

package/dist/server/services/agent/engines/mistral-vibe/options-builder.js

@@ -0,0 +1,35 @@
+import { resolve } from 'node:path';
+import { buildKoboLaunchInstructions, getKoboPromptCapabilities, } from '../../../../../shared/launch-instructions.js';
+import { assertMistralSelection, MISTRAL_MODES } from './configuration.js';
+export function buildMistralOptions(options) {
+    if (options.resumeFromEngineSessionId !== undefined && !options.resumeFromEngineSessionId.trim())
+        throw new Error('Mistral Vibe requires a nonempty saved session identity');
+    const permissionMode = options.agentPermissionMode ?? 'interactive';
+    const capabilities = getKoboPromptCapabilities(options.mcpServers?.find((server) => server.name === 'kobo-tasks')?.env);
+    if (permissionMode === 'plan' || options.readOnly || capabilities.handoff)
+        throw new Error('Mistral Vibe does not support Plan or read-only launches');
+    assertMistralSelection(options.model, 'model');
+    assertMistralSelection(options.effort, 'thinking');
+    if (!Object.hasOwn(MISTRAL_MODES, permissionMode))
+        throw new Error('Unsupported Mistral Vibe permission mode');
+    const modeId = MISTRAL_MODES[permissionMode];
+    const koboInstructions = buildKoboLaunchInstructions({
+        engine: 'mistral-vibe',
+        permissionMode,
+        autoLoop: options.autoLoop,
+        ...capabilities,
+    });
+    return {
+        cwd: resolve(options.workingDir),
+        modeId,
+        koboInstructions,
+        mcpServers: (options.mcpServers ?? []).map((server) => ({
+            name: server.name,
+            command: server.command,
+            args: [...server.args],
+            env: Object.entries(server.env).map(([name, value]) => ({ name, value })),
+        })),
+        prompt: [{ type: 'text', text: `${koboInstructions.promptPrefix}\n\n${options.prompt}` }],
+        env: { ...process.env, ...options.env },
+    };
+}

package/dist/server/services/agent/engines/mistral-vibe/server-requests.js

@@ -0,0 +1,278 @@
+import { isOperationApprovalAvailable } from '../../../workspace-permission-policy-service.js';
+import { PendingUserInputValidationError } from '../types.js';
+function record(value) {
+    return !!value && typeof value === 'object' && !Array.isArray(value);
+}
+function onlyKeys(value, keys) {
+    return Object.keys(value).every((key) => keys.includes(key));
+}
+function text(value, max = 4000) {
+    return typeof value === 'string' && value.length <= max;
+}
+function bound(value, fallback, ceiling) {
+    if (value == null)
+        return fallback;
+    return typeof value === 'number' && Number.isSafeInteger(value) && value >= 0 && value <= ceiling ? value : undefined;
+}
+function choices(schema, titledKey) {
+    if (schema.enum != null && schema[titledKey] != null)
+        return undefined;
+    let options;
+    if (Array.isArray(schema.enum) && schema.enum.every((value) => text(value, 2000))) {
+        options = schema.enum.map((label) => ({ label }));
+    }
+    else if (Array.isArray(schema[titledKey])) {
+        const values = schema[titledKey];
+        if (!values.every((v) => record(v) &&
+            onlyKeys(v, ['const', 'title', 'description', '_meta']) &&
+            text(v.const, 2000) &&
+            text(v.title, 2000) &&
+            (v.description == null || text(v.description))))
+            return undefined;
+        options = values.map((v) => ({ label: v.const, description: (v.description ?? v.title) }));
+    }
+    else
+        return undefined;
+    if (!options.length || options.length > 32 || new Set(options.map((o) => o.label)).size !== options.length)
+        return undefined;
+    return options;
+}
+function formFields(schema) {
+    if (!record(schema) ||
+        !onlyKeys(schema, ['type', 'title', 'description', 'properties', 'required', '_meta']) ||
+        (schema.type != null && schema.type !== 'object') ||
+        !record(schema.properties))
+        return undefined;
+    const entries = Object.entries(schema.properties);
+    if (!entries.length || entries.length > 20)
+        return undefined;
+    const required = schema.required ?? [];
+    if (!Array.isArray(required) ||
+        required.some((key) => typeof key !== 'string' || !Object.hasOwn(schema.properties, key)) ||
+        new Set(required).size !== required.length)
+        return undefined;
+    const fields = [];
+    for (const [id, property] of entries) {
+        if (!id ||
+            !text(id, 200) ||
+            !record(property) ||
+            (property.title != null && !text(property.title)) ||
+            (property.description != null && !text(property.description)))
+            return undefined;
+        const multiSelect = property.type === 'array';
+        if (property.type !== 'string' && !multiSelect)
+            return undefined;
+        if (!onlyKeys(property, multiSelect
+            ? ['type', 'title', 'description', 'items', 'minItems', 'maxItems', 'default', '_meta']
+            : [
+                'type',
+                'title',
+                'description',
+                'minLength',
+                'maxLength',
+                'enum',
+                'oneOf',
+                'default',
+                'pattern',
+                'format',
+                '_meta',
+            ]))
+            return undefined;
+        // Pattern/format constraints need native validation support before they can be rendered safely.
+        if (property.pattern != null || property.format != null)
+            return undefined;
+        let options = [];
+        if (multiSelect) {
+            if (!record(property.items) ||
+                !onlyKeys(property.items, ['type', 'enum', 'anyOf', '_meta']) ||
+                (property.items.type != null && property.items.type !== 'string'))
+                return undefined;
+            const parsed = choices(property.items, 'anyOf');
+            if (!parsed)
+                return undefined;
+            options = parsed;
+        }
+        else if (property.enum != null || property.oneOf != null) {
+            const parsed = choices(property, 'oneOf');
+            if (!parsed)
+                return undefined;
+            options = parsed;
+        }
+        const min = bound(multiSelect ? property.minItems : property.minLength, 0, multiSelect ? options.length : 10000);
+        const max = bound(multiSelect ? property.maxItems : property.maxLength, multiSelect ? options.length : 10000, multiSelect ? options.length : 10000);
+        if (min === undefined || max === undefined || min > max)
+            return undefined;
+        fields.push({
+            id,
+            question: (property.description ?? property.title ?? id),
+            ...(property.title ? { header: property.title } : {}),
+            options,
+            required: required.includes(id),
+            freeText: !multiSelect && !options.length,
+            multiSelect,
+            isOther: false,
+            min,
+            max,
+        });
+    }
+    return fields;
+}
+function formAnswer(fields, response) {
+    if (!record(response.answers) || (response.selections !== undefined && !record(response.selections)))
+        return undefined;
+    if (Object.keys(response.answers).some((id) => !fields.some((field) => field.id === id)) ||
+        Object.keys(response.selections ?? {}).some((id) => !fields.some((field) => field.id === id && field.multiSelect)))
+        return undefined;
+    const content = [];
+    for (const field of fields) {
+        const source = field.multiSelect ? response.selections : response.answers;
+        if (!source || !Object.hasOwn(source, field.id)) {
+            if (field.required || Object.hasOwn(response.answers, field.id))
+                return undefined;
+            continue;
+        }
+        const value = source[field.id];
+        if (field.multiSelect) {
+            if (!Array.isArray(value) ||
+                value.length < field.min ||
+                value.length > field.max ||
+                new Set(value).size !== value.length ||
+                value.some((v) => !text(v, 2000) || !field.options.some((o) => o.label === v)))
+                return undefined;
+            content.push([field.id, [...value]]);
+        }
+        else {
+            if (!text(value, field.max) ||
+                value.length < field.min ||
+                (!field.freeText && !field.options.some((o) => o.label === value)))
+                return undefined;
+            content.push([field.id, value]);
+        }
+    }
+    return { action: 'accept', content: Object.fromEntries(content) };
+}
+export function createMistralServerRequests(args) {
+    const pending = new Map();
+    const seen = new Set();
+    let closed = false;
+    function wait(key, signal, cancelled, answer, event) {
+        return new Promise((resolve) => {
+            function settle(result) {
+                if (!pending.delete(key))
+                    return;
+                signal.removeEventListener('abort', cancel);
+                resolve(result);
+                args.onPendingChange?.(pending.size);
+            }
+            const cancel = () => settle(cancelled);
+            pending.set(key, {
+                cancel,
+                answer: (response) => {
+                    const result = answer(response);
+                    if (result === undefined)
+                        throw new PendingUserInputValidationError();
+                    settle(result);
+                    return true;
+                },
+            });
+            seen.add(key);
+            signal.addEventListener('abort', cancel, { once: true });
+            args.onPendingChange?.(pending.size);
+            if (pending.has(key))
+                args.emit(event);
+        });
+    }
+    function unavailable(key, signal) {
+        return closed || signal.aborted || seen.has(key) || pending.size >= 32 || seen.size >= 4096;
+    }
+    return {
+        requestPermission({ params, signal }) {
+            const cancelled = { outcome: { outcome: 'cancelled' } };
+            if (closed || signal.aborted || args.readOnly || params.sessionId !== args.sessionId)
+                return cancelled;
+            const tool = args.getTool(params.toolCall.toolCallId);
+            const toolName = tool?._meta?.tool_name;
+            if (!tool || typeof toolName !== 'string' || !toolName.trim() || toolName.length > 200)
+                return cancelled;
+            const key = args.canonicalToolCallId(params.toolCall.toolCallId);
+            if (unavailable(key, signal))
+                return cancelled;
+            const offered = params.options;
+            if (!offered.length ||
+                offered.some((option) => !option.optionId) ||
+                new Set(offered.map((option) => option.optionId)).size !== offered.length)
+                return cancelled;
+            const allow = offered.find((option) => option.kind === 'allow_once');
+            const deny = offered.find((option) => option.kind === 'reject_once');
+            if (!allow || !deny)
+                return cancelled;
+            const payload = {
+                rawInput: tool.rawInput ?? null,
+                effectKind: tool._meta?.effect_kind ?? null,
+                kind: tool.kind ?? null,
+                operationApprovalAvailable: false,
+            };
+            payload.operationApprovalAvailable = isOperationApprovalAvailable({
+                engine: 'mistral-vibe',
+                toolName,
+                payload: { ...payload, operationApprovalAvailable: true },
+            });
+            const selected = (optionId) => ({ outcome: { outcome: 'selected', optionId } });
+            const approved = args.autoApprove?.(toolName, payload);
+            if (closed || signal.aborted)
+                return cancelled;
+            if (approved) {
+                seen.add(key);
+                return selected(allow.optionId);
+            }
+            return wait(key, signal, cancelled, (response) => response.kind === 'permission-allow'
+                ? selected(allow.optionId)
+                : response.kind === 'permission-deny'
+                    ? selected(deny.optionId)
+                    : undefined, { kind: 'session:user-input-requested', requestKind: 'permission', toolCallId: key, toolName, payload });
+        },
+        createElicitation({ params, signal, requestId }) {
+            if (closed || signal.aborted || args.readOnly)
+                return { action: 'cancel' };
+            if (params.mode !== 'form' ||
+                !('sessionId' in params) ||
+                params.sessionId !== args.sessionId ||
+                !text(params.message))
+                return { action: 'decline' };
+            const fields = formFields(params.requestedSchema);
+            if (!fields)
+                return { action: 'decline' };
+            const nativeId = typeof params.toolCallId === 'string' ? params.toolCallId : '';
+            const key = `${args.canonicalToolCallId(nativeId)}:elicitation:${typeof requestId}:${encodeURIComponent(String(requestId))}`;
+            if (unavailable(key, signal))
+                return { action: 'decline' };
+            return wait(key, signal, { action: 'cancel' }, (response) => response.kind === 'question-cancel'
+                ? { action: 'cancel' }
+                : response.kind === 'question'
+                    ? formAnswer(fields, response)
+                    : undefined, {
+                kind: 'session:user-input-requested',
+                requestKind: 'question',
+                toolCallId: key,
+                toolName: 'AskUserQuestion',
+                payload: {
+                    questions: fields.map(({ min, max, ...field }) => ({
+                        ...field,
+                        ...(field.multiSelect ? { minItems: min, maxItems: max } : { minLength: min, maxLength: max }),
+                    })),
+                },
+            });
+        },
+        hasPendingUserInput(toolCallId) {
+            return pending.has(toolCallId);
+        },
+        resolvePendingUserInput(toolCallId, response) {
+            return pending.get(toolCallId)?.answer(response) ?? false;
+        },
+        cancelAll() {
+            closed = true;
+            for (const entry of pending.values())
+                entry.cancel();
+        },
+    };
+}

package/dist/server/services/agent/engines/mistral-vibe/spawn.js

@@ -0,0 +1,176 @@
+import { spawn } from 'node:child_process';
+import { groupIsLive } from '../../../../utils/bounded-process.js';
+export function spawnVibeAcp(options) {
+    const child = spawn('vibe-acp', [], { ...options, detached: true, stdio: ['pipe', 'pipe', 'pipe'] });
+    let resolveClosed;
+    const closed = new Promise((resolve) => {
+        resolveClosed = resolve;
+    });
+    let exited = false;
+    let confirmed = false;
+    let abnormal = false;
+    let groupGone = false;
+    let checking = false;
+    let warned = false;
+    let spawnFailure;
+    let stopPromise;
+    let rejectStop;
+    let stderr = Buffer.alloc(0);
+    let poll;
+    const timers = new Set();
+    const diagnostic = (reason) => {
+        if (warned)
+            return;
+        warned = true;
+        // Native stderr may contain credentials. Only fixed classifications leave this module.
+        const hint = /missing api key|authentication failed/i.test(stderr.toString('utf8'))
+            ? '; check the native Vibe authentication configuration'
+            : '';
+        console.error(`[mistral-vibe] ${reason}${hint}; retaining runtime ownership`);
+    };
+    const schedule = (callback, ms) => {
+        const timer = setTimeout(() => {
+            timers.delete(timer);
+            callback();
+        }, ms);
+        timers.add(timer);
+        return timer;
+    };
+    const finish = () => {
+        confirmed = true;
+        clearTimeout(poll);
+        for (const timer of timers)
+            clearTimeout(timer);
+        timers.clear();
+        stderr = Buffer.alloc(0);
+        resolveClosed();
+    };
+    const confirm = async () => {
+        if (confirmed || checking || (!exited && !abnormal))
+            return;
+        checking = true;
+        try {
+            if (!child.pid || !(await groupIsLive(child.pid))) {
+                groupGone = true;
+                if (!exited)
+                    return;
+                if (abnormal) {
+                    diagnostic('Native process did not close cleanly');
+                    rejectStop?.(new Error('Vibe ACP closed abnormally; retaining runtime ownership'));
+                }
+                else
+                    finish();
+                return;
+            }
+        }
+        catch {
+            diagnostic('Cannot inspect the native process group');
+        }
+        finally {
+            checking = false;
+        }
+        if (!confirmed)
+            poll = setTimeout(() => {
+                void confirm();
+            }, 250).unref();
+    };
+    const signal = (requested) => {
+        if (groupGone)
+            return;
+        try {
+            if (child.pid) {
+                process.kill(-child.pid, requested);
+                abnormal = true;
+            }
+        }
+        catch (error) {
+            if (error.code !== 'ESRCH') {
+                abnormal = true;
+                diagnostic('Cannot signal the native process group');
+            }
+        }
+        void confirm();
+    };
+    child.stderr?.on('data', (chunk) => {
+        stderr = Buffer.from(Buffer.concat([stderr, chunk.subarray(-8192)]).subarray(-8192));
+    });
+    // A failed write is also reported by the SDK; never let a pipe error crash the server.
+    child.stdin?.on('error', () => { });
+    child.once('error', (error) => {
+        spawnFailure = new Error(error.code === 'ENOENT'
+            ? 'vibe-acp not found on PATH'
+            : 'Cannot start vibe-acp; check its executable and working directory');
+        if (!child.pid)
+            finish();
+        else {
+            abnormal = true;
+            diagnostic('Native process error');
+        }
+    });
+    child.once('close', (code, exitSignal) => {
+        exited = true;
+        abnormal ||= code !== 0 || exitSignal !== null;
+        void confirm();
+    });
+    const stop = (cooperate) => {
+        if (stopPromise)
+            return stopPromise;
+        stopPromise = (async () => {
+            if (spawnFailure)
+                throw spawnFailure;
+            if (confirmed)
+                return;
+            if (groupGone && abnormal)
+                throw new Error('Vibe ACP closed abnormally; retaining runtime ownership');
+            if (cooperate && !exited) {
+                let closeTimer;
+                try {
+                    // A stalled close ACK must not consume the subsequent EOF cleanup allowance.
+                    await Promise.race([
+                        cooperate(),
+                        closed,
+                        new Promise((resolve) => {
+                            closeTimer = schedule(resolve, 5000);
+                        }),
+                    ]);
+                }
+                catch {
+                    // EOF is the native shared-host cleanup path even if cancel/close failed.
+                }
+                finally {
+                    clearTimeout(closeTimer);
+                    if (closeTimer)
+                        timers.delete(closeTimer);
+                }
+            }
+            if (spawnFailure)
+                throw spawnFailure;
+            if (confirmed)
+                return;
+            child.stdin?.end();
+            child.stdout?.resume();
+            schedule(() => {
+                if (!confirmed)
+                    signal('SIGTERM');
+            }, 15000);
+            schedule(() => {
+                if (!confirmed)
+                    signal('SIGKILL');
+            }, 20000);
+            await Promise.race([
+                closed,
+                new Promise((_resolve, reject) => {
+                    rejectStop = reject;
+                    schedule(() => {
+                        diagnostic('Native shutdown could not be confirmed');
+                        reject(new Error('Vibe ACP shutdown unconfirmed; retaining runtime ownership'));
+                    }, 25000);
+                }),
+            ]);
+            if (spawnFailure)
+                throw spawnFailure;
+        })();
+        return stopPromise;
+    };
+    return { child, closed, stop };
+}

package/dist/server/services/agent/engines/registry.js

@@ -1,8 +1,10 @@
 import { createClaudeCodeEngine } from './claude-code/engine.js';
 import { createCodexEngine } from './codex/engine.js';
+import { createMistralVibeEngine } from './mistral-vibe/engine.js';
 const ENGINES = {
     'claude-code': createClaudeCodeEngine(),
     codex: createCodexEngine(),
+    'mistral-vibe': createMistralVibeEngine(),
 };
 export function listEngines() {
     return Object.values(ENGINES);

package/dist/server/services/agent/engines/types.js

@@ -11,6 +11,12 @@
  * anchor; it is not itself part of the `AgentEngine` interface.
  */
 export const AGENT_NO_LONGER_RUNNING_TEXT = 'agent is no longer running';
+export class PendingUserInputValidationError extends Error {
+    constructor() {
+        super('Invalid response for pending user input');
+        this.name = 'PendingUserInputValidationError';
+    }
+}
 /** Every AgentEvent kind, as a const for exhaustive iteration in tests. */
 export const ALL_AGENT_EVENT_KINDS = [
     'session:started',