dexterm-cli 0.1.5 → 0.1.7

package/dist/packages/autotrade/src/index.js

@@ -0,0 +1,53 @@
+// @dexterm/autotrade — the autotrade engine (AUTOTRADE-SPEC, task-1503 AT-1). PAPER ONLY.
+//
+// strategy   the dexterm-strategy/1 document, exit profiles 1.0.0..1.2.0, the validator, presets
+// engine     entry rules on the screener grammar, sizing, the clamp, the constant-product fill model
+// monitor    mechanical exits + wake events (no LLM)
+// replay     the recorded tape (MarketTick) read from the recorder DB or a committed fixture
+// session    the decision protocol, dossier/delta text, the stub session (types for the runner card)
+// runner     the run loop (lockstep for backtests, paced for replays, live for `autotrade run`), lock + rendezvous
+// ledger     the hash-chained run ledger, runs/<runId>.jsonl, chain verification (task-1505)
+// sessions   the user's own `claude -p` sessions, day caps + allowance guard, the mcp dossier (task-1505)
+// live-source  Store-fed MarketTicks: the screener pool every 10 s, candidate/held coins every 5 s (task-1505)
+// runner-config / account  runner.json (dexterm-runner/1) and the four Claude account kinds (task-1505)
+// backtest   the report, every-candidate mode, runner recall, held-out split + sweeps
+// store      ~/.dexterm/strategies/<id>.json CRUD + the append-only .journal.jsonl
+// desk-executor   orders through the app's paper desk (armed paper-only mandate, exit plans, quote-sized cost recovery)
+// monitor-daemon  the position monitor process: §5 exits on the desk, one wake message per tick, restart recovery
+// safety     stop / flatten / pause (the control file), the kill switch + dead-man every step, the run audit, session isolation (task-1509)
+// fleet      parallel strategies: N strategies on one feed, each with its own book, ledger, caps and budget, under global caps (task-1529)
+// fleet-config / fleet-control  autotrade.json (dexterm-autotrade/1), per-strategy control files, the fleet status + comparison table
+// paper-accounts  shared paper accounts: many strategies trading from one simulated wallet, one strategy on many (task-1538)
+// trade-ledger  the run ledgers as unified trade ledger drafts (task-1530, read-only)
+// execution-port  where an approved entry goes: the paper port (local single-use proofs) and the live stub (task-1527)
+// chat       Telegram notify, control and approve-to-trade through the user's own bot; chat/ (task-1527)
+// yolo       task-1532: the full-port replay (rugs, loss spread, how often it zeroed the wallet); paper only
+//
+// The screener filter grammar is imported by path from the CLI's screener (one parser for the screen and
+// for strategies); nothing in this package touches a key or a wallet, and nothing places a live order (task-1571). The desk executor
+// trades only through the paper desk (a paper executor, by construction) on a keyless quote.
+export * from "./strategy.js";
+export * from "./engine.js";
+export * from "./monitor.js";
+export * from "./replay.js";
+export * from "./session.js";
+export * from "./runner.js";
+export * from "./ledger.js";
+export * from "./sessions.js";
+export * from "./live-source.js";
+export * from "./runner-config.js";
+export * from "./basis-text.js";
+export * from "./account.js";
+export * from "./backtest.js";
+export * from "./store.js";
+export * from "./desk-executor.js";
+export * from "./monitor-daemon.js";
+export * from "./safety.js";
+export * from "./fleet-config.js";
+export * from "./fleet-control.js";
+export * from "./fleet.js";
+export * from "./paper-accounts.js";
+export * from "./trade-ledger.js";
+export * from "./execution-port.js";
+export * from "./chat/index.js";
+export * from "./yolo.js";

package/dist/packages/autotrade/src/ledger.js

@@ -0,0 +1,108 @@
+// dexterm autotrade — the run ledger (task-1505 AT-3, AUTOTRADE-SPEC §4, §6.4).
+//
+// Every step of a run is one hash-chained event: the tick, the message text sent, the raw reply, the parsed
+// decision, the clamp request and result, fills, wakes, no-answers, halts and session costs. Each event's hash
+// covers the previous hash plus the canonical event, so editing, dropping or reordering any line breaks the chain
+// from that line on (`verifyChain`).
+//
+// A real run (`dexterm autotrade run`) appends each event as one JSON line to
+// $DEXTERM_HOME/autotrade/runs/<runId>.jsonl (0600) as it happens, and writes <runId>.summary.json at the end
+// (and on every heartbeat, so a crash leaves a current summary). Backtests keep the ledger in memory.
+//
+// What never goes in: keys, tokens, environment variables. The session layer logs the names of the account kind
+// and of the init event's apiKeySource only; account.ts hands a token to `claude` on a file descriptor and to
+// nothing else.
+import { createHash, randomBytes } from 'node:crypto';
+import { appendFileSync, closeSync, existsSync, mkdirSync, openSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { canonical } from "./strategy.js";
+export const GENESIS = '0'.repeat(16);
+/** The chain step (exported for the chat audit chain, task-1527, which uses the same rule). */
+export function chainHash(prev, e) {
+    // canonical() drops `hash` keys and undefined values, so the stored line (JSON drops undefined too) re-hashes
+    // to the same value; `prev` is added after hashing and excluded here.
+    const { prev: _p, ...body } = e;
+    return createHash('sha256').update(prev + canonical(body)).digest('hex').slice(0, 16);
+}
+export class Ledger {
+    events = [];
+    prev = GENESIS;
+    sink;
+    constructor(sink) { this.sink = sink; }
+    add(t, kind, data = {}) {
+        // seq / t / kind are the engine's: a data field of the same name can never overwrite them (task-1498 found a
+        // `kind` field in a session payload replacing the ledger kind).
+        const e = { ...data, seq: this.events.length + 1, t, kind };
+        delete e.prev;
+        delete e.hash;
+        const h = chainHash(this.prev, e);
+        e.prev = this.prev;
+        e.hash = h;
+        this.prev = h;
+        this.events.push(e);
+        this.sink?.(e, JSON.stringify(e));
+        return e;
+    }
+    head() { return this.prev; }
+}
+/** Recompute the chain: every event's prev is the previous hash, every hash matches its content, seq runs 1..n. */
+export function verifyChain(events) {
+    let prev = GENESIS;
+    for (let i = 0; i < events.length; i++) {
+        const e = events[i];
+        if (e.seq !== i + 1)
+            return { ok: false, events: events.length, at: i + 1, error: `seq ${String(e.seq)} where ${i + 1} was expected` };
+        if (e.prev !== prev)
+            return { ok: false, events: events.length, at: i + 1, error: 'prev does not match the previous hash (a line was removed, added or reordered)' };
+        const want = chainHash(prev, { ...e, hash: undefined });
+        if (e.hash !== want)
+            return { ok: false, events: events.length, at: i + 1, error: 'hash does not match the content (the line was edited)' };
+        prev = want;
+    }
+    return { ok: true, events: events.length, head: prev };
+}
+// ───────────────────────────── files ─────────────────────────────
+export const runsDir = (home) => join(home, 'autotrade', 'runs');
+/** `20261021T055501Z-moonbag-3fa2`: sortable by start time, unique per start. */
+export function newRunId(strategyId, now = Date.now(), rand = randomBytes(2).toString('hex')) {
+    const ts = new Date(now).toISOString().replace(/[-:]/g, '').replace(/\.\d{3}/, '');
+    return `${ts}-${strategyId}-${rand}`;
+}
+export function runFiles(home, runId) {
+    if (!/^[0-9TZ]+-[a-z][a-z0-9-]{1,31}-[0-9a-f]{4}$/.test(runId))
+        throw new Error(`not a run id: ${JSON.stringify(runId)}`);
+    const dir = runsDir(home);
+    return { runId, ledger: join(dir, `${runId}.jsonl`), summary: join(dir, `${runId}.summary.json`) };
+}
+/**
+ * A Ledger whose every event is appended to runs/<runId>.jsonl as it happens (0600, the directory 0700). `tap` sees
+ * each event after it is written (task-1527: the chat notify bus); a tap that throws never stops the ledger.
+ */
+export function fileLedger(home, runId, tap) {
+    const files = runFiles(home, runId);
+    mkdirSync(runsDir(home), { recursive: true, mode: 0o700 });
+    if (existsSync(files.ledger))
+        throw new Error(`run ledger ${files.ledger} already exists`);
+    closeSync(openSync(files.ledger, 'a', 0o600));
+    const ledger = new Ledger((e, line) => { appendFileSync(files.ledger, `${line}\n`); if (tap) {
+        try {
+            tap(e);
+        }
+        catch { /* never the ledger's problem */ }
+    } });
+    return { ledger, files };
+}
+export function readLedgerFile(path) {
+    const out = [];
+    for (const line of readFileSync(path, 'utf8').split('\n'))
+        if (line.trim())
+            out.push(JSON.parse(line));
+    return out;
+}
+export const RUN_SUMMARY_SCHEMA = 'dexterm-autotrade-run-summary/1';
+/** Atomic write (tmp + rename) of a JSON document, 0600. */
+export function writeJsonAtomic(path, doc) {
+    const tmp = `${path}.${process.pid}.tmp`;
+    writeFileSync(tmp, `${JSON.stringify(doc, null, 2)}\n`, { mode: 0o600 });
+    renameSync(tmp, path);
+}

package/dist/packages/autotrade/src/live-source.js

@@ -0,0 +1,182 @@
+// dexterm autotrade — Store-fed MarketTicks for a live paper run (task-1505 AT-3, AUTOTRADE-SPEC §4 "Daemon").
+//
+// The same data layer as the TUI, so the runner screens exactly what the screener shows:
+//   pool       Store.discover(preset, …, {max}) every `discoverEveryMs` (60 s; the feeds are list calls, keyless
+//              pacing applies), then Store.enrich(pool) every `refreshMs` (10 s). Enrich serves DexScreener pairs from
+//              the shared cache (TTL 10 s) and Jupiter records from the cache only, so a refresh never queues behind the
+//              keyless Jupiter bucket.
+//   fast lane  candidate and held coins every `fastMs` (5 s) straight from DexScreener `tokens/v1`, batches of 30
+//              (never per-coin Jupiter calls: keyless Jupiter allows about 5 per 10 s per IP), under a daily call
+//              ceiling. The slow fields a pair does not carry (holders, top 10, dev share, authorities, organic score)
+//              are carried from the coin's last pool row, the way the recorder's tick lane does.
+//
+// Every row becomes the MarketTick a recorded tape would hold for it (same fields, same nulls), in time order. A row
+// whose data did not change since the last tick of that coin (same fetch) is not emitted twice.
+const fin = (v) => (typeof v === 'number' && Number.isFinite(v) ? v : null);
+const bool = (v) => (v === null || v === undefined ? null : Boolean(v));
+/** Display-safe symbol (control, bidi and zero-width code points dropped, 16 chars); the firewall still wraps it for a model. */
+export function cleanSymbol(s) {
+    let out = '';
+    for (const ch of String(s ?? '').normalize('NFC')) {
+        const cp = ch.codePointAt(0);
+        if (cp < 0x20 || (cp >= 0x7f && cp <= 0x9f) || cp === 0x200b || cp === 0x200c || cp === 0x200d || cp === 0x2060 || cp === 0xfeff)
+            continue;
+        if ((cp >= 0x200e && cp <= 0x200f) || (cp >= 0x202a && cp <= 0x202e) || (cp >= 0x2066 && cp <= 0x2069))
+            continue;
+        out += ch;
+    }
+    out = out.replace(/\s+/g, ' ').trim();
+    return out.length > 16 ? `${out.slice(0, 16)}…` : out;
+}
+/** A screener row as a tape tick (`t` = the newest fetch among its parts). */
+export function tickFromRow(r, now = Date.now()) {
+    const { token, pair, stats, audit } = r;
+    const t = Math.max(token.fetchedAt || 0, pair.fetchedAt || 0, stats?.fetchedAt ?? 0, audit?.fetchedAt ?? 0) || now;
+    return {
+        mint: r.mint, t, kind: 'live',
+        symbol: cleanSymbol(token.symbol), launchpad: (token.launchpad ?? 'unknown'),
+        createdAt: fin(token.createdAt ?? pair.createdAt),
+        price: fin(pair.priceUsd), mcap: fin(pair.mcap), mcapResolved: fin(r.mcap?.value), mcapFlagged: !!r.mcap?.flagged,
+        liq: fin(pair.liquidityUsd), vol5m: fin(pair.volume.m5), vol1h: fin(pair.volume.h1), vol24: fin(pair.volume.h24),
+        buys5m: fin(pair.txns.m5?.buys), sells5m: fin(pair.txns.m5?.sells), buys24: fin(pair.txns.h24?.buys), sells24: fin(pair.txns.h24?.sells),
+        chg5m: fin(pair.priceChange.m5), chg1h: fin(pair.priceChange.h1), chg6h: fin(pair.priceChange.h6), chg24h: fin(pair.priceChange.h24),
+        holders: fin(stats?.holderCount), top10: fin(audit?.top10Pct), dev: fin(audit?.devPct),
+        mintAuth: bool(audit?.mintAuthority), freezeAuth: bool(audit?.freezeAuthority), org: fin(stats?.organicScore),
+    };
+}
+/** A fast-lane DexScreener view on top of the coin's last pool tick (slow fields carried, mcap re-resolved by the price move). */
+export function tickFromDs(v, base, now = Date.now()) {
+    const p = v.pair;
+    const price = fin(p.priceUsd);
+    const scaled = base?.mcapResolved !== null && base?.mcapResolved !== undefined && base.price && price !== null ? base.mcapResolved * (price / base.price) : fin(p.mcap);
+    return {
+        mint: v.token.mint, t: p.fetchedAt || now, kind: 'live',
+        symbol: base?.symbol ?? cleanSymbol(v.token.symbol), launchpad: base?.launchpad ?? (v.token.launchpad ?? 'unknown'),
+        createdAt: base?.createdAt ?? fin(v.token.createdAt ?? p.createdAt),
+        price, mcap: fin(p.mcap), mcapResolved: scaled, mcapFlagged: base?.mcapFlagged ?? false,
+        liq: fin(p.liquidityUsd), vol5m: fin(p.volume.m5), vol1h: fin(p.volume.h1), vol24: fin(p.volume.h24) ?? base?.vol24 ?? null,
+        buys5m: fin(p.txns.m5?.buys), sells5m: fin(p.txns.m5?.sells), buys24: fin(p.txns.h24?.buys) ?? base?.buys24 ?? null, sells24: fin(p.txns.h24?.sells) ?? base?.sells24 ?? null,
+        chg5m: fin(p.priceChange.m5), chg1h: fin(p.priceChange.h1), chg6h: fin(p.priceChange.h6) ?? base?.chg6h ?? null, chg24h: fin(p.priceChange.h24) ?? base?.chg24h ?? null,
+        holders: base?.holders ?? null, top10: base?.top10 ?? null, dev: base?.dev ?? null,
+        mintAuth: base?.mintAuth ?? null, freezeAuth: base?.freezeAuth ?? null, org: base?.org ?? null,
+    };
+}
+export const LIVE_DEFAULTS = { presets: ['trending', 'recent'], poolMax: 150, discoverEveryMs: 60_000, refreshMs: 10_000, fastMs: 5_000, batch: 30, maxFastCallsPerDay: 17_280 };
+export class LiveSource {
+    deps;
+    o;
+    focus = [];
+    pool = [];
+    last = new Map();
+    stopped = false;
+    wake = null;
+    fastDay = '';
+    stats = { discovers: 0, refreshes: 0, fastCalls: 0, fastCallsToday: 0, ticks: 0, errors: 0, fastSkippedCeiling: 0 };
+    constructor(deps, opts = {}) {
+        this.deps = deps;
+        this.o = {
+            ...LIVE_DEFAULTS, ...Object.fromEntries(Object.entries(opts).filter(([, v]) => v !== undefined)),
+            now: opts.now ?? Date.now,
+            sleep: opts.sleep ?? ((ms) => new Promise((r) => { const t = setTimeout(r, ms); this.wake = () => { clearTimeout(t); r(); }; })),
+            onLog: opts.onLog ?? (() => { }),
+        };
+    }
+    /** The runner's candidate + held coins (the fast lane). */
+    setFocus(marks) { this.focus = marks.slice(0, 60); }
+    stop() { this.stopped = true; this.wake?.(); }
+    emitNew(ticks, out) {
+        for (const k of ticks) {
+            const prev = this.last.get(k.mint);
+            if (prev && k.t <= prev.t)
+                continue;
+            this.last.set(k.mint, k);
+            out.push(k);
+        }
+    }
+    /** One fast-lane pass over the focus coins; returns the new ticks. Respects the daily ceiling. */
+    async fastPass() {
+        const mints = [...new Set(this.focus.map((f) => f.mint))];
+        if (!mints.length)
+            return [];
+        const day = new Date(this.o.now()).toISOString().slice(0, 10);
+        if (day !== this.fastDay) {
+            this.fastDay = day;
+            this.stats.fastCallsToday = 0;
+        }
+        const out = [];
+        for (let i = 0; i < mints.length; i += this.o.batch) {
+            if (this.stats.fastCallsToday >= this.o.maxFastCallsPerDay) {
+                this.stats.fastSkippedCeiling++;
+                break;
+            }
+            const batch = mints.slice(i, i + this.o.batch);
+            this.stats.fastCalls++;
+            this.stats.fastCallsToday++;
+            try {
+                const views = await this.deps.dexscreener.tokens(batch);
+                const now = this.o.now();
+                this.emitNew(batch.map((m) => views.get(m)).filter((v) => !!v).map((v) => tickFromDs(v, this.last.get(v.token.mint), now)), out);
+            }
+            catch (e) {
+                this.stats.errors++;
+                this.o.onLog(`fast lane: ${e.message}`);
+            }
+        }
+        return out;
+    }
+    /** One pool pass: discover when due, then enrich the pool. */
+    async poolPass(discover) {
+        const out = [];
+        try {
+            if (discover || !this.pool.length) {
+                const seen = new Set();
+                for (const p of this.o.presets)
+                    for (const m of (await this.deps.store.discover(p, 30, { max: this.o.poolMax })).mints)
+                        seen.add(m);
+                this.pool = [...seen].slice(0, this.o.poolMax);
+                this.stats.discovers++;
+            }
+            const { rows } = await this.deps.store.enrich(this.pool, { jup: 'cache' });
+            this.stats.refreshes++;
+            const now = this.o.now();
+            this.emitNew(rows.filter((r) => r.mint && r.pair).map((r) => tickFromRow(r, now)), out);
+        }
+        catch (e) {
+            this.stats.errors++;
+            this.o.onLog(`pool refresh: ${e.message}`);
+        }
+        return out;
+    }
+    /** The tick stream: pool every refreshMs, fast lane every fastMs, in time order within each pass. Ends on stop(). */
+    async *ticks() {
+        let lastPool = -Infinity;
+        let lastDiscover = -Infinity;
+        let lastT = 0;
+        while (!this.stopped) {
+            const t = this.o.now();
+            const batch = [];
+            if (t - lastPool >= this.o.refreshMs) {
+                const disc = t - lastDiscover >= this.o.discoverEveryMs;
+                batch.push(...await this.poolPass(disc));
+                lastPool = t;
+                if (disc)
+                    lastDiscover = t;
+            }
+            batch.push(...await this.fastPass());
+            batch.sort((a, b) => a.t - b.t || (a.mint < b.mint ? -1 : 1));
+            // The run clock never goes backwards: a cached row fetched before the last tick is stamped at that tick.
+            for (const k of batch) {
+                if (k.t < lastT)
+                    k.t = lastT;
+                lastT = k.t;
+                this.stats.ticks++;
+                yield k;
+                if (this.stopped)
+                    return;
+            }
+            if (this.stopped)
+                return;
+            await this.o.sleep(Math.max(250, this.o.fastMs - (this.o.now() - t)));
+        }
+    }
+}