desic-okx-agent 0.2.0 → 0.3.0

package/dist/tui/execute.js

@@ -0,0 +1,664 @@
+import fs from "node:fs";
+import path from "node:path";
+import { publicError } from "../core/errors.js";
+import { TEMPLATE_NAMES, isTemplateName, template } from "../strategy/templates.js";
+import { DEFAULT_BUDGET } from "../strategy/parameter-space.js";
+import { describeEnvironment, formatCoverageDetail, formatInstrumentTable, formatSyncReport } from "../cli/data-render.js";
+import { formatComparison, formatEquitySparkline, formatOptimizationReport, formatRunDetail, formatRunTable, formatTradeTable, formatValidation } from "../cli/strategy-render.js";
+import { formatCommandDetail, formatCommandList, commandByName, suggest } from "./commands.js";
+import { entry } from "./entries.js";
+import { padEndDisplay } from "../cli/width.js";
+import { openInBrowser, writeComparison, writeReport } from "../report/open.js";
+import { describeRange, parseRangeArgument } from "../cli/range.js";
+import { loadConfig, saveConfig } from "../config/loader.js";
+import { CONFIG_PATH } from "../config/paths.js";
+import { collectComparison, collectReport } from "../report/fetch.js";
+import { formatProfileTable, formatSignalTable } from "../cli/live-render.js";
+import { buildComparison, MAX_COMPARED_RUNS, MIN_COMPARED_RUNS } from "../report/compare.js";
+import { activeLocale, activeMessages, saveLocale } from "../i18n/locale.js";
+import { LOCALES, isLocale } from "../i18n/messages.js";
+const DEFAULT_INSTRUMENT = "BTC-USDT-SWAP";
+const DEFAULT_DAYS = 30;
+/**
+ * Longer than a backtest's default because the window is split 70/30. Thirty days
+ * would leave nine to validate against, which is too short to contradict the
+ * searched segment.
+ */
+const DEFAULT_OPTIMIZE_DAYS = 90;
+const DEFAULT_SPACE_FILE = "space.json";
+/**
+ * Runs one parsed command and returns the entries to append.
+ *
+ * Every command returns text rather than rendering: the shell owns presentation,
+ * and this stays testable without a terminal.
+ */
+export async function execute(name, args, context) {
+    try {
+        switch (name) {
+            case "help":
+                return { entries: [helpEntry(args[0])] };
+            case "clear":
+                return { entries: [], effect: "clear" };
+            case "exit":
+            case "quit":
+                return { entries: [], effect: "exit" };
+            case "data":
+                return { entries: [await dataEntry(context)] };
+            case "download":
+                return { entries: await downloadEntries(args, context) };
+            case "new":
+                return { entries: [newStrategyEntry(args)] };
+            case "validate":
+                return { entries: [await validateEntry(args, context)] };
+            case "backtest":
+                return { entries: await backtestEntries(args, context) };
+            case "optimize":
+                return { entries: await optimizeEntries(args, context) };
+            case "compare":
+                return { entries: await compareEntries(args, context) };
+            case "market":
+                return marketResult(args, context.configPath);
+            case "live":
+                return { entries: await liveEntries(args, context) };
+            case "runs":
+                return { entries: [await runsEntry(args, context)] };
+            case "report":
+                return { entries: await reportEntries(args, context) };
+            case "cancel":
+                return { entries: [await cancelEntry(args, context)] };
+            case "coverage":
+                return { entries: [await coverageEntry(args, context)] };
+            case "delete":
+                return { entries: [await deleteEntry(args, context)] };
+            case "env":
+                return { entries: [await envEntry(args, context)] };
+            case "status":
+                return { entries: [await statusEntry(context)] };
+            case "settings":
+                // Handled by the shell, which opens the form; reaching here means the
+                // caller was not the shell.
+                return { entries: [entry("note", `  ${activeMessages().settingsHintCommand}`)] };
+            case "lang":
+            case "language":
+                return langResult(args);
+            default: {
+                const text = activeMessages();
+                const closest = suggest(name);
+                const hint = closest ? text.didYouMean(closest) : text.seeHelp;
+                return { entries: [entry("error", `  ${text.unknownCommand(name)}${hint}`)] };
+            }
+        }
+    }
+    catch (error) {
+        const detail = publicError(error);
+        return { entries: [entry("error", `  ${String(detail.message)}`)] };
+    }
+    finally {
+        context.onActivity(null);
+    }
+}
+function helpEntry(topic) {
+    const text = activeMessages();
+    if (!topic) {
+        return entry("output", `${formatCommandList()}\n\n  ${text.argumentsAsked}`);
+    }
+    const spec = commandByName(topic.replace(/^\//, ""));
+    if (!spec)
+        return entry("error", `  ${text.noCommandNamed(topic)}`);
+    return entry("output", formatCommandDetail(spec));
+}
+/**
+ * Lists live profiles, reads their decisions, or stops one.
+ *
+ * Read-only apart from stopping. Creating and starting stay in the CLI: they are the two
+ * actions that commit money to a strategy, and a shell where one keystroke could begin
+ * trading is not a shell anyone should trust.
+ */
+async function liveEntries(args, context) {
+    const text = activeMessages();
+    const action = (args[0] ?? "").toLowerCase();
+    if (!action) {
+        context.onActivity(text.readingRuns);
+        const result = (await context.client.call("live_list_profiles", {}));
+        return [entry("output", indent(formatProfileTable(result.data)))];
+    }
+    if (action === "signals") {
+        const profileId = args[1];
+        if (!profileId)
+            return [entry("error", `  ${text.giveRunId("live signals")}`)];
+        context.onActivity(text.readingRun(profileId));
+        const result = (await context.client.call("live_signals", { profileId, limit: 30 }));
+        return [entry("output", indent(formatSignalTable(result.data)))];
+    }
+    if (action === "stop") {
+        const profileId = args[1];
+        if (!profileId)
+            return [entry("error", `  ${text.giveRunId("live stop")}`)];
+        const result = (await context.client.call("live_stop", { profileId }));
+        return [entry("success", `  ${text.liveProfileStopped(result.data.name)}`)];
+    }
+    return [entry("error", `  ${text.argLiveAction}`)];
+}
+function indent(text) {
+    return text
+        .split("\n")
+        .map((line) => `  ${line}`)
+        .join("\n");
+}
+/**
+ * Shows or switches the market data environment.
+ *
+ * The switch is a config write, so it cannot take effect in this session — the runtime
+ * holds its sockets open and reads this once at startup. Reporting success without
+ * saying that would leave someone believing the shell in front of them had changed
+ * venue when it had not.
+ */
+function marketResult(args, configPath = CONFIG_PATH) {
+    const text = activeMessages();
+    const config = loadConfig(configPath);
+    const current = config.market.environment;
+    const requested = (args[0] ?? "").trim().toLowerCase();
+    if (!requested) {
+        const lines = [`  ${text.marketEnvironmentLabel} ${describeEnvironment(current) ?? current}`];
+        if (current === "demo")
+            lines.push(`  ${text.demoDataWarning}`);
+        lines.push(`  ${text.environmentUsageShell}`);
+        return { entries: [entry("output", lines.join("\n"))] };
+    }
+    if (requested !== "demo" && requested !== "live") {
+        // The shell's own syntax, not the CLI's: telling someone at a `/` prompt to run a
+        // `desic-okx` command is an instruction they cannot follow where they are.
+        return { entries: [entry("error", `  ${text.environmentUsageShell}`)] };
+    }
+    if (requested === current) {
+        return { entries: [entry("note", `  ${text.environmentAlready(requested)}`)] };
+    }
+    saveConfig({ ...config, market: { ...config.market, environment: requested } }, configPath);
+    const lines = [
+        `  ${text.environmentSwitched(describeEnvironment(requested) ?? requested)}`,
+        `  ${text.environmentRestartHint}`
+    ];
+    if (requested === "demo")
+        lines.push(`  ${text.demoDataWarning}`);
+    return { entries: [entry("success", lines.join("\n"))] };
+}
+/**
+ * Changes the display language and remembers it.
+ *
+ * The preference is written to disk rather than kept per session: a user who
+ * chose a language should not have to choose again on every start.
+ */
+function langResult(args) {
+    const text = activeMessages();
+    const requested = (args[0] ?? "").toLowerCase();
+    if (!requested) {
+        return { entries: [entry("output", `  ${text.languageCurrent(activeLocale())}\n  ${text.languageUsage}`)] };
+    }
+    if (!isLocale(requested)) {
+        return {
+            entries: [entry("error", `  ${text.languageUsage}  (${LOCALES.join(", ")})`)]
+        };
+    }
+    saveLocale(requested);
+    // Read the bundle again so the confirmation is already in the new language.
+    return { entries: [entry("success", `  ${activeMessages().languageChanged(requested)}`)] };
+}
+async function dataEntry(context) {
+    const text = activeMessages();
+    context.onActivity(text.readingCoverage);
+    const result = (await context.client.call("data_list_instruments", {}));
+    const rows = result.data;
+    const environment = describeEnvironment(result.meta?.environment);
+    if (rows.length === 0) {
+        return entry("note", `  ${text.noLocalHistory}\n  ${text.tryDownload}`);
+    }
+    return entry("output", formatInstrumentTable(rows, environment)
+        .split("\n")
+        .map((line) => `  ${line}`)
+        .join("\n"));
+}
+async function downloadEntries(args, context) {
+    const text = activeMessages();
+    const instId = (args[0] ?? DEFAULT_INSTRUMENT).toUpperCase();
+    let range;
+    try {
+        range = parseRangeArgument(args[1] ?? String(DEFAULT_DAYS));
+    }
+    catch (failure) {
+        return [entry("error", `  ${failure instanceof Error ? failure.message : String(failure)}`)];
+    }
+    context.onActivity(text.requestingWindow(instId, describeRange(range)));
+    // The download call holds one request open for its whole duration, so progress
+    // is polled from the runtime rather than streamed back on that request.
+    const startedAt = Date.now();
+    const poll = setInterval(() => {
+        void context.client
+            .call("data_download_progress", { instId })
+            .then((value) => {
+            const state = value.data;
+            if (!state || !state.active)
+                return;
+            context.onProgress?.({
+                label: `${instId}  ${text.requestingWindow(instId, describeRange(range))}`,
+                done: state.present,
+                total: state.expected,
+                startedAt
+            });
+        })
+            .catch(() => undefined);
+    }, 250);
+    try {
+        const result = (await context.client.call("data_download", { instId, ...range }));
+        const report = result.data;
+        return [
+            entry(report.status === "completed" ? "success" : "note", formatSyncReport(report)
+                .split("\n")
+                .map((line) => `  ${line}`)
+                .join("\n"))
+        ];
+    }
+    finally {
+        clearInterval(poll);
+        context.onProgress?.(null);
+    }
+}
+function newStrategyEntry(args) {
+    const text = activeMessages();
+    const file = args[0];
+    if (!file)
+        return entry("error", `  ${text.giveFileNew} (${TEMPLATE_NAMES.join(", ")})`);
+    const name = args[1] ?? "ema-trend";
+    if (!isTemplateName(name)) {
+        return entry("error", `  ${text.unknownTemplate(name, TEMPLATE_NAMES.join(", "))}`);
+    }
+    if (fs.existsSync(file)) {
+        return entry("error", `  ${text.fileExists(file)}`);
+    }
+    fs.writeFileSync(file, template(name), "utf8");
+    return entry("success", `  ${text.wroteTemplate(name, file)}\n  ${text.nextValidate(file)}`);
+}
+async function validateEntry(args, context) {
+    const text = activeMessages();
+    const file = args[0];
+    if (!file)
+        return entry("error", `  ${text.giveFileValidate}`);
+    if (!fs.existsSync(file))
+        return entry("error", `  ${text.fileMissing(file)}`);
+    context.onActivity(text.validating(path.basename(file)));
+    const source = fs.readFileSync(file, "utf8");
+    const result = (await context.client.call("strategy_validate_source", { source }));
+    const rendered = formatValidation(result.data, file)
+        .split("\n")
+        .map((line) => `  ${line}`)
+        .join("\n");
+    return entry(result.data.valid ? "success" : "error", rendered);
+}
+async function backtestEntries(args, context) {
+    const text = activeMessages();
+    const file = args[0];
+    if (!file)
+        return [entry("error", `  ${text.giveFileBacktest}`)];
+    if (!fs.existsSync(file))
+        return [entry("error", `  ${text.fileMissing(file)}`)];
+    const instId = (args[1] ?? DEFAULT_INSTRUMENT).toUpperCase();
+    // Accepts a day count or an explicit range; the same question at different
+    // precision, so it is one argument rather than two.
+    let range;
+    try {
+        range = parseRangeArgument(args[2] ?? String(DEFAULT_DAYS));
+    }
+    catch (failure) {
+        return [entry("error", `  ${failure instanceof Error ? failure.message : String(failure)}`)];
+    }
+    // Read the real settings rather than printing a fixed string: the old line
+    // claimed "10,000 USDT · 10x · 120 preload bars" no matter what a run used.
+    const settings = (await context.client.call("strategy_settings", {})).data;
+    const entries = [
+        entry("note", `  ${text.backtestWindow(path.basename(file), instId, describeRange(range))}  ·  ${text.backtestSettings(settings.initialEquityUsdt.toLocaleString("en-US"), settings.leverage, settings.preloadBars)}\n  ${text.settingsHintCommand}`)
+    ];
+    context.onActivity(text.queuing(instId));
+    const source = fs.readFileSync(file, "utf8");
+    // No preloadBars override: the service already applies the saved setting, and
+    // sending a literal here would use a different value than the line above just
+    // reported — the same mismatch the hardcoded config string used to cause.
+    const queued = (await context.client.call("strategy_run_backtest", {
+        instId,
+        source,
+        strategyName: path.basename(file, ".py"),
+        ...range
+    }));
+    const runId = queued.data.runId;
+    const startedAt = Date.now();
+    const run = await waitForRun(context, runId, (summary) => {
+        if (summary.barCount > 0) {
+            // The engine reports a bar count, so the remaining work is measurable and
+            // a bar is more useful than a spinner.
+            context.onProgress?.({
+                label: `${runId}  ${summary.instId}`,
+                done: Math.round((summary.progressPct / 100) * summary.barCount),
+                total: summary.barCount,
+                startedAt,
+                detail: `${summary.barCount.toLocaleString("en-US")} ${text.barsColumn.toLowerCase()}`
+            });
+        }
+        else {
+            context.onActivity(`${runId}  ${summary.status}`);
+        }
+    });
+    context.onProgress?.(null);
+    if (run.status !== "completed") {
+        entries.push(entry("error", `  ${runId}  ${run.status}\n  ${run.error ?? "-"}`));
+        return entries;
+    }
+    entries.push(entry("success", formatRunDetail(run)
+        .split("\n")
+        .map((line) => `  ${line}`)
+        .join("\n") + `\n\n  ${text.forCurveAndTrades(runId)}`));
+    return entries;
+}
+/**
+ * Queues a parameter search, or reprints a finished one.
+ *
+ * The default window is longer than a backtest's: the window is split 70/30, so a
+ * 30-day request would leave nine days to validate against, which is too few to
+ * disagree with the searched segment about anything.
+ */
+async function optimizeEntries(args, context) {
+    const text = activeMessages();
+    const positional = args.filter((item) => !item.startsWith("-"));
+    const first = positional[0];
+    if (!first)
+        return [entry("error", `  ${text.giveFileOptimize}`)];
+    if (first.toLowerCase() === "report") {
+        return optimizeReportEntries(positional.slice(1), args, context);
+    }
+    if (!fs.existsSync(first))
+        return [entry("error", `  ${text.fileMissing(first)}`)];
+    const instId = (positional[1] ?? DEFAULT_INSTRUMENT).toUpperCase();
+    let range;
+    try {
+        range = parseRangeArgument(positional[2] ?? String(DEFAULT_OPTIMIZE_DAYS));
+    }
+    catch (failure) {
+        return [entry("error", `  ${failure instanceof Error ? failure.message : String(failure)}`)];
+    }
+    const spaceFile = positional[3] ?? DEFAULT_SPACE_FILE;
+    if (!fs.existsSync(spaceFile))
+        return [entry("error", `  ${text.spaceFileMissing(spaceFile)}`)];
+    let space;
+    try {
+        space = JSON.parse(fs.readFileSync(spaceFile, "utf8"));
+    }
+    catch {
+        return [entry("error", `  ${text.spaceFileInvalid(spaceFile)}`)];
+    }
+    const budget = Number(positional[4] ?? DEFAULT_BUDGET);
+    if (!Number.isInteger(budget) || budget < 2) {
+        return [entry("error", `  ${text.giveSpaceFile}`)];
+    }
+    // A parameters file beside the strategy supplies the defaults the space is
+    // checked against, so a range naming an unread parameter is caught here.
+    const params = readParamsBeside(first);
+    const entries = [
+        entry("note", `  ${text.optimizeWindow(path.basename(first), instId, describeRange(range))}`)
+    ];
+    context.onActivity(text.queuing(instId));
+    const queued = (await context.client.call("strategy_run_optimize", {
+        instId,
+        source: fs.readFileSync(first, "utf8"),
+        strategyName: path.basename(first, ".py"),
+        space,
+        budget,
+        ...(params ? { params } : {}),
+        ...range
+    }));
+    const runId = queued.data.runId;
+    const startedAt = Date.now();
+    const run = await waitForRun(context, runId, (summary) => {
+        const evaluated = Number(summary.metrics?.candidatesEvaluated ?? 0);
+        context.onProgress?.({
+            label: `${runId}  ${summary.instId}`,
+            // Progress is measured in candidate-segments, which the run reports as a
+            // percentage; scaling it onto the budget keeps the bar in candidate units.
+            done: Math.round((summary.progressPct / 100) * budget),
+            total: budget,
+            startedAt,
+            detail: `${evaluated > 0 ? `${evaluated} done · ` : ""}${budget} candidates`
+        });
+    });
+    context.onProgress?.(null);
+    if (run.status !== "completed") {
+        entries.push(entry("error", `  ${runId}  ${run.status}\n  ${run.error ?? "-"}`));
+        return entries;
+    }
+    const report = (await context.client.call("strategy_get_optimization", { runId, top: 20 }));
+    entries.push(entry("success", formatOptimizationReport(report.data)
+        .split("\n")
+        .map((line) => `  ${line}`)
+        .join("\n") + `\n\n  ${text.forCandidateTable(runId)}`));
+    return entries;
+}
+async function optimizeReportEntries(positional, args, context) {
+    const text = activeMessages();
+    const runId = positional[0];
+    if (!runId)
+        return [entry("error", `  ${text.giveRunId("optimize report")}`)];
+    context.onActivity(text.readingRun(runId));
+    const report = (await context.client.call("strategy_get_optimization", { runId, top: 50 }));
+    const entries = [
+        entry("output", formatOptimizationReport(report.data)
+            .split("\n")
+            .map((line) => `  ${line}`)
+            .join("\n"))
+    ];
+    const adoptIndex = args.findIndex((item) => item === "--adopt");
+    if (adoptIndex === -1)
+        return entries;
+    const target = args[adoptIndex + 1];
+    if (!target)
+        return [...entries, entry("error", `  ${text.giveSpaceFile}`)];
+    const best = report.data.candidates.find((candidate) => candidate.status === "completed");
+    if (!best)
+        return [...entries, entry("note", `  ${text.noBestCandidate}`)];
+    // Written to its own file rather than into the strategy: the source belongs to
+    // the user, and rewriting it would erase what they wrote.
+    fs.writeFileSync(target, `${JSON.stringify(best.params, null, 2)}\n`, "utf8");
+    entries.push(entry("success", `  ${text.adoptedParams(target)}\n  ${text.adoptHint(runId)}`));
+    return entries;
+}
+/**
+ * Puts two or more runs side by side.
+ *
+ * Opens in the browser by default, like `/report`: an overlay of several curves is
+ * the thing a terminal renders worst. Warnings are printed to the transcript
+ * either way, since they are the reason a comparison may be meaningless and should
+ * not live only in a window the user might not switch to.
+ */
+async function compareEntries(args, context) {
+    const text = activeMessages();
+    const runIds = args.filter((item) => !item.startsWith("-"));
+    if (runIds.length < MIN_COMPARED_RUNS)
+        return [entry("error", `  ${text.compareNeedsTwo}`)];
+    if (runIds.length > MAX_COMPARED_RUNS) {
+        return [entry("error", `  ${text.compareTooMany(MAX_COMPARED_RUNS)}`)];
+    }
+    const terminalOnly = args.some((item) => item === "--no-open" || item === "-n");
+    context.onActivity(text.readingRun(runIds.join(", ")));
+    const report = buildComparison(await collectComparison(context.client, runIds));
+    const entries = [];
+    for (const warning of report.warnings) {
+        entries.push(entry("note", `  ! ${warning.message}`));
+    }
+    if (terminalOnly) {
+        entries.push(entry("output", formatComparison(report)
+            .split("\n")
+            // Warnings already stand on their own above, so they are not repeated
+            // inside the table block.
+            .filter((line) => !line.trimStart().startsWith("! "))
+            .map((line) => `  ${line}`)
+            .join("\n")));
+        return entries;
+    }
+    const file = writeComparison(report);
+    const opened = openInBrowser(file);
+    entries.push(entry(opened ? "success" : "note", `  ${opened ? text.reportOpened : text.reportWritten}\n  ${file}`));
+    return entries;
+}
+/**
+ * Reads `<strategy>.params.json` if it exists.
+ *
+ * The parameter space is validated against the strategy's own parameters, and
+ * those live inside `ctx.params.get(...)` calls where the host cannot see them.
+ * This file is the declared set, and it is also where `--adopt` writes.
+ */
+function readParamsBeside(strategyFile) {
+    const candidate = strategyFile.replace(/\.py$/, "") + ".params.json";
+    if (!fs.existsSync(candidate))
+        return null;
+    try {
+        const parsed = JSON.parse(fs.readFileSync(candidate, "utf8"));
+        return parsed && typeof parsed === "object" && !Array.isArray(parsed)
+            ? parsed
+            : null;
+    }
+    catch {
+        return null;
+    }
+}
+async function runsEntry(args, context) {
+    const text = activeMessages();
+    const limit = Number(args[0] ?? 10);
+    context.onActivity(text.readingRuns);
+    const result = (await context.client.call("strategy_list_runs", {
+        limit: Number.isFinite(limit) && limit > 0 ? Math.min(limit, 200) : 10
+    }));
+    return entry("output", formatRunTable(result.data)
+        .split("\n")
+        .map((line) => `  ${line}`)
+        .join("\n"));
+}
+async function reportEntries(args, context) {
+    const text = activeMessages();
+    const runId = args.find((item) => !item.startsWith("-"));
+    if (!runId)
+        return [entry("error", `  ${text.giveRunId("report")}`)];
+    const terminalOnly = args.some((item) => item === "--no-open" || item === "-n");
+    context.onActivity(text.readingRun(runId));
+    const run = (await context.client.call("strategy_get_run", { runId }));
+    const entries = [
+        entry("output", formatRunDetail(run.data)
+            .split("\n")
+            .map((line) => `  ${line}`)
+            .join("\n"))
+    ];
+    if (run.data.status !== "completed")
+        return entries;
+    // One reader for both paths. Callers must not choose a page size: the tool
+    // rejects a limit above its own cap, and a limit below the row count silently
+    // returns a prefix — `collectReport` follows pagination instead.
+    const collected = await collectReport(context.client, runId);
+    if (terminalOnly) {
+        if (collected.equity.length > 1) {
+            entries.push(entry("output", `  ${text.equityHeading}\n${formatEquitySparkline(collected.equity)}`));
+        }
+        entries.push(entry("output", `  ${text.tradesHeading}\n${formatTradeTable(collected.trades, 12)}`));
+        return entries;
+    }
+    // A browser can show the full curve, a drawdown band, and every trade at once;
+    // a terminal cannot. The sparkline stays available behind --no-open.
+    const file = writeReport(collected);
+    const opened = openInBrowser(file);
+    entries.push(entry(opened ? "success" : "note", `  ${opened ? text.reportOpened : text.reportWritten}\n  ${file}`));
+    return entries;
+}
+/** One instrument's stored range and the gaps that would fail a backtest. */
+async function coverageEntry(args, context) {
+    const text = activeMessages();
+    const instId = (args[0] ?? DEFAULT_INSTRUMENT).toUpperCase();
+    context.onActivity(text.readingCoverage);
+    const result = (await context.client.call("data_coverage", { instId }));
+    return entry(result.data === null || result.data.missingCount > 0 ? "note" : "output", formatCoverageDetail(result.data, instId)
+        .split("\n")
+        .map((line) => `  ${line}`)
+        .join("\n"));
+}
+async function deleteEntry(args, context) {
+    const text = activeMessages();
+    const runId = args.find((item) => !item.startsWith("-"));
+    if (!runId)
+        return entry("error", `  ${text.giveRunId("delete")}`);
+    // Deletion is irreversible, so it is confirmed rather than assumed.
+    if (!args.includes("--yes") && !args.includes("-y")) {
+        return entry("note", `  ${text.deleteConfirm(runId)}`);
+    }
+    const result = (await context.client.call("strategy_delete_run", { runId }));
+    return result.data.deleted
+        ? entry("success", `  ${text.deleted(runId)}`)
+        : entry("note", `  ${text.alreadyFinished(runId)}`);
+}
+async function cancelEntry(args, context) {
+    const text = activeMessages();
+    const runId = args[0];
+    if (!runId)
+        return entry("error", `  ${text.giveRunId("cancel")}`);
+    const result = (await context.client.call("strategy_cancel_run", { runId }));
+    return result.data.cancelled
+        ? entry("success", `  ${text.cancelled(runId)}`)
+        : entry("note", `  ${text.alreadyFinished(runId)}`);
+}
+async function envEntry(args, context) {
+    const text = activeMessages();
+    if ((args[0] ?? "").toLowerCase() === "setup") {
+        context.onActivity(text.preparingEnvironment);
+        const result = (await context.client.call("strategy_environment_setup", {}));
+        const log = (result.data.log ?? []).map((line) => `  ${line}`).join("\n");
+        return entry("success", `${log}\n  ${text.environmentReady}`);
+    }
+    context.onActivity(text.checkingEnvironment);
+    const result = (await context.client.call("strategy_environment", {}));
+    const status = result.data;
+    const lines = [
+        `  ${padEndDisplay(text.pythonLabel, 8)} ${status.interpreter ?? text.notFound}${status.version ? `  ${status.version}` : ""}`,
+        `  ${padEndDisplay(text.readyLabel, 8)} ${status.ready ? text.yes : text.no}`
+    ];
+    for (const problem of status.problems)
+        lines.push(`  ${"!".padEnd(8)} ${problem}`);
+    if (!status.ready)
+        lines.push(`  ${padEndDisplay(text.fixLabel, 8)} /env setup`);
+    return entry(status.ready ? "output" : "note", lines.join("\n"));
+}
+async function statusEntry(context) {
+    const text = activeMessages();
+    context.onActivity(text.readingStatus);
+    const health = (await context.client.health());
+    const websocket = (health.websocket ?? {});
+    const database = (health.database ?? {});
+    const subscriptions = Array.isArray(health.subscriptions) ? health.subscriptions.length : 0;
+    const megabytes = ((database.sizeBytes ?? 0) / 1_048_576).toFixed(1);
+    return entry("output", [
+        `  ${padEndDisplay(text.runtimeLabel, 12)} ${String(health.version ?? "?")}  pid ${String(health.pid ?? "?")}`,
+        `  ${padEndDisplay(text.publicWs, 12)} ${websocket.public?.state ?? "?"}`,
+        `  ${padEndDisplay(text.businessWs, 12)} ${websocket.business?.state ?? "?"}`,
+        `  ${padEndDisplay(text.subscribed(subscriptions), 12)}`,
+        `  ${padEndDisplay(text.databaseLabel, 12)} ${megabytes} MB`,
+        // Stated on every status read: demo and live are different markets, and a
+        // reader who cannot tell which one is streaming may trust the wrong prices.
+        `  ${padEndDisplay(text.marketEnvironmentLabel, 12)} ${describeEnvironment(String(health.marketEnvironment ?? "")) ?? "?"}`
+    ].join("\n"));
+}
+/** Polls a run until it settles, reporting progress through `onProgress`. */
+async function waitForRun(context, runId, onProgress) {
+    for (;;) {
+        const response = (await context.client.call("strategy_get_run", { runId }));
+        const run = response.data;
+        if (run.status === "completed" || run.status === "failed" || run.status === "cancelled")
+            return run;
+        onProgress(run);
+        if (context.signal?.aborted) {
+            await context.client.call("strategy_cancel_run", { runId }).catch(() => undefined);
+            return { ...run, status: "cancelled", error: "Cancelled from the shell" };
+        }
+        await new Promise((resolve) => setTimeout(resolve, 400));
+    }
+}
+//# sourceMappingURL=execute.js.map