dexterm-cli 0.1.6 → 0.1.7

package/dist/packages/mcp/src/backtest-requests.js

@@ -0,0 +1,71 @@
+// @dexterm/mcp — BACKTEST REQUESTS (task-1530): an agent PROPOSES a longer backtest; the user runs it.
+//
+// `strategy_backtest` (task-1507) runs at most 14 days inline and is rate-limited per server. A bigger question
+// ("run moonbag over the last 45 days, every candidate") is the user's machine time, so the agent only files a
+// request: `backtest_request` writes `$DEXTERM_HOME/autotrade/requests/<br_…>.json` (status pending). Nothing runs
+// until the user types `dexterm autotrade requests run <requestId>` (or dismisses it); the result line is then
+// written back into the same file, where `backtest_requests` lets the agent read it.
+//
+// A request can name only a stored strategy id and a day count. It can never change a strategy, a cap or a mode,
+// and the run is the ordinary read-only backtest on the recorder history.
+import { existsSync, mkdirSync, readFileSync, readdirSync, renameSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { randomBytes } from 'node:crypto';
+export const BACKTEST_REQUEST_SCHEMA = 'dexterm-backtest-request/1';
+export const REQUEST_MAX_DAYS = 60;
+export const MAX_PENDING_REQUESTS = 10;
+/** Requests per hour per server process (a request is cheap, the run is not). */
+export const REQUEST_RATE_PER_HOUR = 6;
+export const isRequestId = (x) => typeof x === 'string' && /^br_[0-9a-f]{12}$/.test(x);
+export const requestsDir = (home) => join(home, 'autotrade', 'requests');
+export class BacktestRequests {
+    home;
+    constructor(home) { this.home = home; }
+    dir() { return requestsDir(this.home); }
+    path(id) { return join(this.dir(), `${id}.json`); }
+    get(id) {
+        if (!isRequestId(id) || !existsSync(this.path(id)))
+            return null;
+        try {
+            const r = JSON.parse(readFileSync(this.path(id), 'utf8'));
+            return r && r.schema === BACKTEST_REQUEST_SCHEMA && r.requestId === id ? r : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    /** Newest first. */
+    list(o = {}) {
+        if (!existsSync(this.dir()))
+            return [];
+        const out = [];
+        for (const f of readdirSync(this.dir())) {
+            const m = /^(br_[0-9a-f]{12})\.json$/.exec(f);
+            const r = m ? this.get(m[1]) : null;
+            if (r && (!o.status || r.status === o.status))
+                out.push(r);
+        }
+        return out.sort((a, b) => b.createdAt - a.createdAt || a.requestId.localeCompare(b.requestId));
+    }
+    create(r) {
+        mkdirSync(this.dir(), { recursive: true, mode: 0o700 });
+        const rec = { schema: BACKTEST_REQUEST_SCHEMA, requestId: `br_${randomBytes(6).toString('hex')}`, status: 'pending', ...r };
+        this.write(rec);
+        return rec;
+    }
+    /** The user's side only (`dexterm autotrade requests run|dismiss`): mark a request done / failed / dismissed. */
+    resolve(id, status, result, now = Date.now()) {
+        const r = this.get(id);
+        if (!r)
+            return null;
+        const next = { ...r, status, resolvedAt: now, ...(result ? { result: result.slice(0, 400) } : {}) };
+        this.write(next);
+        return next;
+    }
+    write(r) {
+        const p = this.path(r.requestId);
+        const tmp = `${p}.${process.pid}.tmp`;
+        writeFileSync(tmp, `${JSON.stringify(r, null, 2)}\n`, { mode: 0o600 });
+        renameSync(tmp, p);
+    }
+}

package/dist/packages/mcp/src/engine/config.js

@@ -0,0 +1,159 @@
+// dexterm local engine: the AI engine settings file, $DEXTERM_HOME/ai.json (task-1543).
+//
+//   { "schema": "dexterm.ai/1",
+//     "provider": "auto" | "claude" | "codex" | "ollama",          the global engine
+//     "surfaces": { "analyst": …, "autotrade": …, "packs": …, "agent": … },   per-surface overrides
+//     "restrictions": "observe" | "propose" | "paper" | "full",      the local-engine profile
+//     "full": { "model": "<model>", "confirmedAt": "<iso>" } | null, the typed --full confirmation
+//     "ollama": { "host": "http://127.0.0.1:11434", "model": "<model>", "numCtx": 16384 } }
+//
+// Only the user writes it, with `dexterm ai …` (or by hand). No MCP tool, chat message, Telegram command or model
+// output reaches this file. `full` counts only with a confirmation recorded for the SAME model; otherwise the
+// profile falls back to `paper` and every surface says why. The environment can lower the profile
+// (DEXTERM_AI_RESTRICTIONS), never raise it.
+import fs from 'node:fs';
+import path from 'node:path';
+import { dextermHome } from "../user-content.js";
+import { DEFAULT_OLLAMA_HOST, parseOllamaHost } from "./ollama.js";
+import { DEFAULT_RESTRICTION, isRestriction, lowerOf, SURFACES } from "./restrictions.js";
+export const AI_CONFIG_SCHEMA = 'dexterm.ai/1';
+export const ENGINES = ['claude', 'codex', 'ollama'];
+export const ENGINE_CHOICES = ['auto', ...ENGINES];
+/** The phrase `dexterm ai engine ollama --full` asks the user to type. */
+export const FULL_CONFIRM_PHRASE = 'ENABLE FULL';
+/** Room for the analyst system prompt, the tool catalog, the live context and a few tool results (the probe clamps it to the model). */
+export const DEFAULT_NUM_CTX = 32768;
+export function defaultAiConfig() {
+    return { schema: AI_CONFIG_SCHEMA, provider: 'auto', surfaces: {}, restrictions: DEFAULT_RESTRICTION, full: null, ollama: { host: DEFAULT_OLLAMA_HOST, model: null, numCtx: DEFAULT_NUM_CTX } };
+}
+export const aiConfigPath = (env = process.env) => path.join(dextermHome(env), 'ai.json');
+export function parseEngineChoice(v) {
+    const s = typeof v === 'string' ? v.trim().toLowerCase() : '';
+    return ENGINE_CHOICES.includes(s) ? s : null;
+}
+/** An Ollama model name as `ollama pull` takes it (name[:tag], optional namespace/host path). */
+export const MODEL_NAME = /^[a-z0-9][a-z0-9._\-/]{0,120}(:[a-z0-9._-]{1,64})?$/i;
+export function loadAiConfig(env = process.env) {
+    const p = aiConfigPath(env);
+    const c = defaultAiConfig();
+    const errors = [];
+    let raw;
+    try {
+        raw = JSON.parse(fs.readFileSync(p, 'utf8'));
+    }
+    catch (e) {
+        if (e.code === 'ENOENT')
+            return { config: c, exists: false, path: p, errors };
+        return { config: c, exists: true, path: p, errors: [`${p} is not valid JSON; using the defaults`] };
+    }
+    const o = (raw && typeof raw === 'object' && !Array.isArray(raw) ? raw : {});
+    if (o.provider !== undefined) {
+        const v = parseEngineChoice(o.provider);
+        if (v)
+            c.provider = v;
+        else
+            errors.push('provider must be auto|claude|codex|ollama');
+    }
+    if (o.surfaces && typeof o.surfaces === 'object') {
+        for (const [k, v] of Object.entries(o.surfaces)) {
+            const e = parseEngineChoice(v);
+            if (SURFACES.includes(k) && e)
+                c.surfaces[k] = e;
+            else
+                errors.push(`surfaces.${k.slice(0, 24)} is not a surface (${SURFACES.join('|')}) with an engine`);
+        }
+    }
+    if (o.restrictions !== undefined) {
+        if (isRestriction(o.restrictions))
+            c.restrictions = o.restrictions;
+        else
+            errors.push('restrictions must be observe|propose|paper|full');
+    }
+    const full = o.full;
+    if (full && typeof full === 'object' && typeof full.model === 'string' && typeof full.confirmedAt === 'string')
+        c.full = { model: full.model, confirmedAt: full.confirmedAt };
+    const ol = o.ollama;
+    if (ol && typeof ol === 'object') {
+        if (typeof ol.host === 'string') {
+            const h = parseOllamaHost(ol.host);
+            if ('error' in h)
+                errors.push(`ollama.host: ${h.error}`);
+            else
+                c.ollama.host = h.url;
+        }
+        if (typeof ol.model === 'string' && MODEL_NAME.test(ol.model))
+            c.ollama.model = ol.model;
+        else if (ol.model !== undefined && ol.model !== null)
+            errors.push('ollama.model is not a model name');
+        if (typeof ol.numCtx === 'number' && Number.isInteger(ol.numCtx) && ol.numCtx >= 2048 && ol.numCtx <= 1_048_576)
+            c.ollama.numCtx = ol.numCtx;
+        else if (ol.numCtx !== undefined)
+            errors.push('ollama.numCtx must be an integer 2048..1048576');
+    }
+    return { config: c, exists: true, path: p, errors };
+}
+/** Write ai.json (0600, atomic). Only the `dexterm ai` command calls this. */
+export function saveAiConfig(c, env = process.env) {
+    const p = aiConfigPath(env);
+    fs.mkdirSync(path.dirname(p), { recursive: true, mode: 0o700 });
+    const tmp = `${p}.${process.pid}.tmp`;
+    fs.writeFileSync(tmp, JSON.stringify(c, null, 2) + '\n', { mode: 0o600 });
+    fs.renameSync(tmp, p);
+    return p;
+}
+/**
+ * The profile that applies now. `full` needs a confirmation for the same model; the env may only lower it.
+ */
+export function effectiveRestriction(c, model, env = process.env) {
+    let level = c.restrictions;
+    let note = null;
+    if (level === 'full' && (!c.full || !model || c.full.model !== model)) {
+        level = 'paper';
+        note = c.full && model && c.full.model !== model
+            ? `full was confirmed for ${c.full.model}, not ${model}: running at paper until you confirm again (dexterm ai engine ollama --full)`
+            : 'full needs the typed confirmation (dexterm ai engine ollama --full): running at paper';
+    }
+    const lower = env.DEXTERM_AI_RESTRICTIONS;
+    if (isRestriction(lower) && lowerOf(lower, level) !== level) {
+        level = lower;
+        note = `DEXTERM_AI_RESTRICTIONS lowers the profile to ${lower}`;
+    }
+    return { level, note };
+}
+/** Host / model / context, with the env overrides (DEXTERM_OLLAMA_HOST, DEXTERM_OLLAMA_MODEL). */
+export function ollamaSettings(c, env = process.env) {
+    let hostError = null;
+    let host = parseOllamaHost(env.DEXTERM_OLLAMA_HOST || c.ollama.host);
+    if ('error' in host) {
+        hostError = `DEXTERM_OLLAMA_HOST: ${host.error}`;
+        host = parseOllamaHost(DEFAULT_OLLAMA_HOST);
+    }
+    const envModel = env.DEXTERM_OLLAMA_MODEL && MODEL_NAME.test(env.DEXTERM_OLLAMA_MODEL) ? env.DEXTERM_OLLAMA_MODEL : null;
+    return { host, model: envModel ?? c.ollama.model, numCtx: c.ollama.numCtx, hostError };
+}
+/**
+ * The engine CHOICE for a surface: DEXTERM_AI_PROVIDER, then the per-surface override, then the global provider.
+ * (The analyst's own flag / DEXTERM_ANALYST_ENGINE / config analyst.engine still win for the analyst; main.ts.)
+ */
+export function engineChoiceFor(surface, c, env = process.env) {
+    return parseEngineChoice(env.DEXTERM_AI_PROVIDER) ?? c.surfaces[surface] ?? c.provider;
+}
+/** Is a local Ollama setup configured (a model chosen)? `auto` uses it only then, after claude and codex. */
+export function ollamaConfigured(c, env = process.env) {
+    return !!ollamaSettings(c, env).model;
+}
+/**
+ * Resolve a choice to an engine. `auto`: claude when installed, else codex, else ollama when a model is set up,
+ * else claude (whose missing-CLI error explains how to set up an AI backend).
+ */
+export function resolveEngineChoice(choice, has) {
+    if (choice !== 'auto')
+        return choice;
+    if (has('claude'))
+        return 'claude';
+    if (has('codex'))
+        return 'codex';
+    if (has('ollama'))
+        return 'ollama';
+    return 'claude';
+}

package/dist/packages/mcp/src/engine/index.js

@@ -0,0 +1,10 @@
+// @dexterm/mcp/engine — the local AI engine (Ollama) behind the same tools and limits as the claude path (task-1543).
+// It never builds, signs or sends a transaction: it reads, proposes, and (by the user's profile) requests paper or
+// live orders that the engine-independent caps, mandates, kill switch and live gating decide.
+export { DEFAULT_OLLAMA_HOST, DEFAULT_OLLAMA_PORT, OllamaClient, OllamaError, REDIRECT_REFUSED, isLoopbackHost, parseOllamaHost, remoteHostWarning, stripThink } from "./ollama.js";
+export { RESTRICTION_LEVELS, RESTRICTION_RANK, RESTRICTION_HELP, DEFAULT_RESTRICTION, CAPABILITY_LEVEL, NEVER_TOOL, SURFACES, ENGINE_PARITY, isRestriction, atLeast, lowerOf, allows, engineToolAllowlist, requiredLevel } from "./restrictions.js";
+export { AI_CONFIG_SCHEMA, ENGINES, ENGINE_CHOICES, FULL_CONFIRM_PHRASE, DEFAULT_NUM_CTX, MODEL_NAME, aiConfigPath, defaultAiConfig, loadAiConfig, saveAiConfig, effectiveRestriction, ollamaSettings, engineChoiceFor, ollamaConfigured, parseEngineChoice, resolveEngineChoice } from "./config.js";
+export { McpStdioClient, toOllamaTools } from "./mcp-client.js";
+export { runToolLoop, structuredAnswer, DEFAULT_MAX_STEPS, DEFAULT_MAX_REFUSALS } from "./loop.js";
+export { probeModel, belowBar, pickModel, BAR, SUGGESTED_MODELS } from "./probe.js";
+export { ollamaReasonRunner } from "./reason.js";

package/dist/packages/mcp/src/engine/loop.js

@@ -0,0 +1,101 @@
+// dexterm local engine: the tool loop (task-1543).
+//
+// The claude CLI runs its own agent loop; on a local engine dexterm runs it: send the conversation and the
+// allowlisted tools to Ollama, execute each tool call the model asks for through the dexterm MCP server, feed
+// the results back, repeat until the model answers without a tool call (or a step cap is hit).
+//
+// A call to a tool outside the allowlist is NEVER executed: the model gets "refused" back and the attempt is
+// counted; after `maxRefusals` the turn stops (the codex path's tripwire, softened because small local models
+// often invent tool names). Tool results are the MCP server's output, already firewalled.
+import { OllamaError, stripThink } from "./ollama.js";
+export const DEFAULT_MAX_STEPS = 8;
+export const DEFAULT_MAX_REFUSALS = 3;
+export const DEFAULT_MAX_TOOL_RESULT = 24_000;
+export async function runToolLoop(o) {
+    const maxSteps = o.maxSteps ?? DEFAULT_MAX_STEPS;
+    const maxRefusals = o.maxRefusals ?? DEFAULT_MAX_REFUSALS;
+    const cap = o.maxToolResultChars ?? DEFAULT_MAX_TOOL_RESULT;
+    const allowed = new Set(o.allowed);
+    const tools = o.tools && o.tools.length ? o.tools : undefined;
+    const res = { text: '', steps: 0, toolCalls: 0, refusals: 0, promptTokens: 0, evalTokens: 0, model: null, stopped: null };
+    const options = o.numCtx ? { num_ctx: o.numCtx } : undefined;
+    for (;;) {
+        if (o.signal?.aborted)
+            throw new OllamaError('aborted', 'cancelled');
+        const lastStep = res.steps >= maxSteps;
+        res.steps++;
+        // A think block streams as content on some models: hold it back from the user, show only the answer.
+        let shown = 0;
+        let raw = '';
+        const onDelta = o.onText ? (d) => {
+            raw += d;
+            const visible = stripThink(raw);
+            if (raw.includes('<think>') && !/<\/think>/.test(raw))
+                return;
+            if (visible.length > shown) {
+                o.onText(visible.slice(shown));
+                shown = visible.length;
+            }
+        } : undefined;
+        const r = await o.client.chat({ model: o.model, messages: o.messages, ...(tools && !lastStep ? { tools } : {}), ...(options ? { options } : {}) }, { onDelta, signal: o.signal });
+        res.promptTokens += r.promptTokens;
+        res.evalTokens += r.evalTokens;
+        res.model = r.model ?? res.model;
+        const content = stripThink(r.content).trim();
+        const calls = tools && !lastStep ? r.toolCalls : [];
+        o.messages.push({ role: 'assistant', content: r.content, ...(calls.length ? { tool_calls: calls } : {}) });
+        if (!calls.length) {
+            res.text = content;
+            if (lastStep && r.toolCalls.length)
+                res.stopped = 'steps';
+            return res;
+        }
+        for (const c of calls) {
+            const name = c.function.name;
+            if (!allowed.has(name)) {
+                res.refusals++;
+                o.onRefused?.(name);
+                o.messages.push({ role: 'tool', tool_name: name, content: JSON.stringify({ error: `refused: ${name.slice(0, 64)} is not a tool you have in this session` }) });
+                continue;
+            }
+            res.toolCalls++;
+            o.onToolCall?.(name, c.function.arguments);
+            let text;
+            try {
+                text = await o.callTool(name, c.function.arguments);
+            }
+            catch (e) {
+                text = JSON.stringify({ error: e.message.slice(0, 300) });
+            }
+            o.onToolResult?.(name, text);
+            o.messages.push({ role: 'tool', tool_name: name, content: text.length > cap ? `${text.slice(0, cap)}…(truncated)` : text });
+        }
+        if (res.refusals >= maxRefusals) {
+            res.stopped = 'refusals';
+            res.text = content;
+            return res;
+        }
+        // At the step cap the next round is the last one: no tools, answer with what you have.
+        if (res.steps >= maxSteps)
+            o.messages.push({ role: 'user', content: 'Tool budget reached for this turn. Answer now from the tool results above; do not call another tool.' });
+    }
+}
+/**
+ * Ask for the final answer as JSON matching a schema (Ollama structured outputs), after a tool loop. Returns the
+ * parsed object, or null when the model did not produce valid JSON.
+ */
+export async function structuredAnswer(o) {
+    o.messages.push({ role: 'user', content: o.instruction ?? 'Now return ONLY the final JSON object that the output schema requires, filled from the tool results and the context above. No prose.' });
+    const r = await o.client.chat({ model: o.model, messages: o.messages, format: o.schema, ...(o.numCtx ? { options: { num_ctx: o.numCtx } } : {}) }, { signal: o.signal });
+    const raw = stripThink(r.content).trim();
+    o.messages.push({ role: 'assistant', content: r.content });
+    let value = null;
+    try {
+        const v = JSON.parse(raw.replace(/^```(?:json)?\s*|\s*```$/g, ''));
+        value = v && typeof v === 'object' && !Array.isArray(v) ? v : null;
+    }
+    catch {
+        value = null;
+    }
+    return { value, raw, promptTokens: r.promptTokens, evalTokens: r.evalTokens };
+}

package/dist/packages/mcp/src/engine/mcp-client.js

@@ -0,0 +1,123 @@
+// dexterm local engine: a small MCP client over stdio (task-1543).
+//
+// A local engine has no MCP client of its own, so dexterm is the client: it starts the SAME read-only dexterm
+// MCP server the claude path starts (same binary, same env: screen state, the authenticated UI-action channel,
+// the user's DEXTERM_HOME), lists its tools and calls them on the model's behalf. The server's own checks (the
+// prompt firewall on every token/social string, the UI-action validator, the paper desk gate) therefore apply
+// to both engines byte for byte.
+import { spawn } from 'node:child_process';
+import readline from 'node:readline';
+export class McpStdioClient {
+    child;
+    pending = new Map();
+    seq = 0;
+    closed = false;
+    stderr = '';
+    constructor(child) {
+        this.child = child;
+        const rl = readline.createInterface({ input: child.stdout });
+        rl.on('line', (line) => {
+            if (!line.trim())
+                return;
+            let msg;
+            try {
+                msg = JSON.parse(line);
+            }
+            catch {
+                return;
+            }
+            if (typeof msg.id !== 'number')
+                return;
+            const p = this.pending.get(msg.id);
+            if (!p)
+                return;
+            this.pending.delete(msg.id);
+            if (msg.error)
+                p.reject(new Error(String(msg.error.message ?? 'MCP error')));
+            else
+                p.resolve(msg.result ?? {});
+        });
+        child.stderr?.on('data', (d) => { this.stderr = (this.stderr + d.toString()).slice(-4000); });
+        child.stdin?.on('error', () => { });
+        const die = (why) => {
+            this.closed = true;
+            for (const p of this.pending.values())
+                p.reject(new Error(`${why}${this.stderr ? ` · ${this.stderr.trim().split('\n').slice(-2).join(' ').slice(0, 200)}` : ''}`));
+            this.pending.clear();
+        };
+        child.on('exit', (code) => die(`the dexterm MCP server exited (${code})`));
+        child.on('error', (e) => die(`could not start the dexterm MCP server (${e.message})`));
+    }
+    static async start(o) {
+        const child = (o.spawnImpl ?? spawn)(o.command, o.args, { cwd: o.cwd, env: o.env, stdio: ['pipe', 'pipe', 'pipe'] });
+        const c = new McpStdioClient(child);
+        const timer = setTimeout(() => c.close(), o.timeoutMs ?? 30_000);
+        timer.unref?.();
+        try {
+            await c.request('initialize', { protocolVersion: '2025-06-18', capabilities: {}, clientInfo: { name: 'dexterm-local-engine', version: '1' } });
+            c.notify('notifications/initialized');
+            return c;
+        }
+        catch (e) {
+            c.close();
+            throw e;
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+    request(method, params) {
+        if (this.closed)
+            return Promise.reject(new Error('the dexterm MCP server is not running'));
+        const id = ++this.seq;
+        return new Promise((resolve, reject) => {
+            this.pending.set(id, { resolve, reject });
+            this.child.stdin.write(JSON.stringify({ jsonrpc: '2.0', id, method, ...(params ? { params } : {}) }) + '\n');
+        });
+    }
+    notify(method) {
+        if (!this.closed)
+            this.child.stdin.write(JSON.stringify({ jsonrpc: '2.0', method }) + '\n');
+    }
+    async listTools() {
+        const r = await this.request('tools/list');
+        const tools = Array.isArray(r.tools) ? r.tools : [];
+        return tools.map((t) => ({ name: String(t.name), description: String(t.description ?? ''), inputSchema: (t.inputSchema && typeof t.inputSchema === 'object' ? t.inputSchema : { type: 'object', properties: {} }) }));
+    }
+    /** Call a tool; returns its text content (the dexterm server answers with one JSON text block). */
+    async callTool(name, args) {
+        const r = await this.request('tools/call', { name, arguments: args });
+        const content = Array.isArray(r.content) ? r.content : [];
+        return content.filter((c) => c.type === 'text').map((c) => String(c.text ?? '')).join('');
+    }
+    close() {
+        if (this.closed)
+            return;
+        this.closed = true;
+        try {
+            this.child.stdin?.end();
+        }
+        catch { /* ignore */ }
+        try {
+            this.child.kill('SIGTERM');
+        }
+        catch { /* ignore */ }
+        try {
+            this.child.stdout?.destroy();
+        }
+        catch { /* ignore */ }
+        try {
+            this.child.stderr?.destroy();
+        }
+        catch { /* ignore */ }
+        try {
+            this.child.unref();
+        }
+        catch { /* ignore */ }
+    }
+}
+/** MCP tool definitions as Ollama function tools, limited to the allowlist (order kept). */
+export function toOllamaTools(defs, allowed) {
+    const ok = new Set(allowed);
+    return defs.filter((d) => ok.has(d.name)).map((d) => ({ type: 'function', function: { name: d.name, description: d.description.slice(0, 400), parameters: d.inputSchema } }));
+}