smolcoder-plus 1.0.0

package/dist/ui.js

@@ -0,0 +1,226 @@
+"use strict";
+// Terminal UI: one readline interface for everything (prompt, pickers,
+// approval), a spinner for the silent gap before the first streamed token,
+// and small helpers for status lines. No dependencies.
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UI = void 0;
+exports.renderPlan = renderPlan;
+exports.summarizeArgs = summarizeArgs;
+const readline = __importStar(require("readline"));
+const util_1 = require("./util");
+/** Shared checklist renderer: ✔ done (dim) · ▶ current (cyan) · ○ pending. */
+function renderPlan(plan, indent = "  ") {
+    const cur = plan.currentIndex;
+    const header = `${indent}${util_1.c.bold("Plan")} ${util_1.c.dim(`${plan.doneCount}/${plan.steps.length}`)}`;
+    const rows = plan.steps.map((s, i) => {
+        if (s.done)
+            return `${indent}${util_1.c.dim("✔ " + s.text)}`;
+        if (i === cur)
+            return `${indent}${util_1.c.cyan("▶ " + s.text)}`;
+        return `${indent}${util_1.c.gray("○ " + s.text)}`;
+    });
+    return [header, ...rows].join("\n");
+}
+class UI {
+    rl;
+    spinnerTimer = null;
+    spinnerActive = false;
+    atLineStart = true;
+    onInterrupt = null;
+    constructor() {
+        this.rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout,
+            historySize: 100,
+        });
+        this.rl.on("SIGINT", () => {
+            if (this.onInterrupt) {
+                this.onInterrupt();
+            }
+            else {
+                this.println("");
+                process.exit(0);
+            }
+        });
+    }
+    ask(prompt) {
+        return new Promise((resolve) => this.rl.question(prompt, (a) => resolve(a)));
+    }
+    /** y / n / a(lways allow this program for the session) */
+    async confirmCommand(command, reason) {
+        this.stopSpinner();
+        const answer = await this.ask(`${util_1.c.yellow("run?")} ${util_1.c.bold(command)}\n` +
+            (reason ? `  ${util_1.c.dim(reason)}\n` : "") +
+            `  ${util_1.c.dim("[y]es / [n]o / [a]lways allow this program this session:")} `);
+        const ch = answer.trim().toLowerCase();
+        if (ch === "a" || ch === "always")
+            return "always";
+        if (ch === "y" || ch === "yes" || ch === "")
+            return "yes";
+        return "no";
+    }
+    startSpinner(label) {
+        if (!process.stdout.isTTY) {
+            // Headless liveness heartbeat: a working local model can generate for
+            // minutes with nothing visible — tick on stderr so a log-follower can
+            // tell "working" from "hung".
+            this.stopSpinner();
+            const started = Date.now();
+            this.spinnerTimer = setInterval(() => {
+                const secs = Math.round((Date.now() - started) / 1000);
+                process.stderr.write(util_1.c.gray(`· ${label}… ${secs}s\n`));
+            }, 15000);
+            return;
+        }
+        this.stopSpinner();
+        const frames = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+        let i = 0;
+        const started = Date.now();
+        this.spinnerActive = true;
+        this.spinnerTimer = setInterval(() => {
+            const secs = Math.floor((Date.now() - started) / 1000);
+            process.stdout.write(`\r${util_1.c.cyan(frames[i++ % frames.length])} ${util_1.c.dim(label + (secs > 2 ? ` ${secs}s` : ""))}   `);
+        }, 100);
+    }
+    stopSpinner() {
+        if (this.spinnerTimer) {
+            clearInterval(this.spinnerTimer);
+            this.spinnerTimer = null;
+        }
+        if (this.spinnerActive) {
+            process.stdout.write("\r" + " ".repeat(60) + "\r");
+            this.spinnerActive = false;
+        }
+    }
+    ensureLine() {
+        if (!this.atLineStart) {
+            process.stdout.write("\n");
+            this.atLineStart = true;
+        }
+    }
+    /** Meta output (tool lines, status, warnings) goes to stderr so headless
+     * consumers get a clean stdout with just the model's answer. */
+    meta(s) {
+        this.stopSpinner();
+        this.ensureLine();
+        process.stderr.write(s + "\n");
+    }
+    /** Streamed model text goes straight to stdout. */
+    token(text) {
+        this.stopSpinner();
+        process.stdout.write(text);
+        this.atLineStart = text.endsWith("\n");
+    }
+    /** Headless mode: reasoning noise is suppressed — automations want the answer. */
+    thinking(_text) { }
+    toolCall(name, args) {
+        const summary = summarizeArgs(name, args);
+        this.meta(`${util_1.c.cyan("→")} ${util_1.c.bold(name)} ${util_1.c.dim(summary)}`);
+    }
+    toolResult(result) {
+        const firstLine = result.split("\n")[0] ?? "";
+        const isError = firstLine.startsWith("Error");
+        const lines = result.split("\n").length;
+        const label = isError
+            ? util_1.c.red(firstLine.slice(0, 120))
+            : util_1.c.dim(firstLine.slice(0, 100) + (lines > 1 ? ` (+${lines - 1} lines)` : ""));
+        this.meta(`  ${isError ? util_1.c.red("✗") : util_1.c.green("✓")} ${label}`);
+    }
+    println(s = "") {
+        this.stopSpinner();
+        this.ensureLine();
+        process.stdout.write(s + "\n");
+        this.atLineStart = true;
+    }
+    status(s) {
+        this.meta(util_1.c.gray(s));
+    }
+    turnEnd(label) {
+        this.meta(util_1.c.dim(`■ ${label}`));
+    }
+    planUpdated(plan) {
+        this.meta(renderPlan(plan));
+    }
+    warn(s) {
+        this.meta(util_1.c.yellow(s));
+    }
+    error(s) {
+        this.meta(util_1.c.red(s));
+    }
+    close() {
+        this.stopSpinner();
+        this.rl.close();
+    }
+}
+exports.UI = UI;
+function summarizeArgs(name, args) {
+    try {
+        // Unparseable (usually cut-off) arguments: show what arrived, not "undefined".
+        if (args && typeof args.__raw === "string") {
+            return `(arguments could not be parsed: ${args.__raw.replace(/\s+/g, " ")}…)`;
+        }
+        switch (name) {
+            case "read_file":
+                return String(args.path ?? "") + (args.offset ? ` from line ${args.offset}` : "");
+            case "write_file":
+                return `${args.path} (${String(args.content ?? "").split("\n").length} lines)`;
+            case "edit_file":
+                return String(args.path ?? "");
+            case "list_files":
+                return String(args.path ?? ".");
+            case "search":
+                return `"${args.pattern}"${args.path ? ` in ${args.path}` : ""}`;
+            case "run_command":
+                return String(args.command ?? "");
+            case "task":
+                return [args.action, args.command ?? args.task_id ?? ""].filter(Boolean).join(" ");
+            case "plan": {
+                if (args.action === "set")
+                    return `set (${String(args.steps ?? "").split("\n").filter(Boolean).length} steps)`;
+                if (args.action === "done")
+                    return `done${args.step ? " " + args.step : ""}`;
+                if (args.action === "add")
+                    return `add: ${String(args.text ?? "").slice(0, 60)}`;
+                return String(args.action ?? "");
+            }
+            default:
+                return JSON.stringify(args).slice(0, 80);
+        }
+    }
+    catch {
+        return "";
+    }
+}

package/dist/util.js

@@ -0,0 +1,91 @@
+"use strict";
+// Small shared helpers. Zero dependencies: ANSI codes are written by hand.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.c = void 0;
+exports.estimateTokens = estimateTokens;
+exports.truncateMiddle = truncateMiddle;
+exports.truncateEnd = truncateEnd;
+exports.plural = plural;
+exports.fmtDuration = fmtDuration;
+exports.probeJson = probeJson;
+exports.tryFetchJson = tryFetchJson;
+const useColor = process.stdout.isTTY && !process.env.NO_COLOR;
+function wrap(code, s) {
+    return useColor ? `\x1b[${code}m${s}\x1b[0m` : s;
+}
+exports.c = {
+    dim: (s) => wrap("2", s),
+    bold: (s) => wrap("1", s),
+    cyan: (s) => wrap("36", s),
+    green: (s) => wrap("32", s),
+    yellow: (s) => wrap("33", s),
+    red: (s) => wrap("31", s),
+    magenta: (s) => wrap("35", s),
+    gray: (s) => wrap("90", s),
+};
+/** Rough token estimate: ~4 chars per token. Corrected by real usage after each request. */
+function estimateTokens(text) {
+    return Math.ceil(text.length / 4);
+}
+/** Cap a string in the middle, keeping head and tail — best shape for command output. */
+function truncateMiddle(s, maxChars) {
+    if (s.length <= maxChars)
+        return s;
+    const head = Math.floor(maxChars * 0.6);
+    const tail = maxChars - head;
+    const omitted = s.length - maxChars;
+    return (s.slice(0, head) +
+        `\n... [${omitted} characters omitted to save context] ...\n` +
+        s.slice(s.length - tail));
+}
+function truncateEnd(s, maxChars, note) {
+    if (s.length <= maxChars)
+        return s;
+    return s.slice(0, maxChars) + `\n... [truncated${note ? ": " + note : ""}]`;
+}
+function plural(n, word) {
+    return `${n} ${word}${n === 1 ? "" : "s"}`;
+}
+function fmtDuration(ms) {
+    if (ms < 1000)
+        return `${ms}ms`;
+    const s = ms / 1000;
+    if (s < 60)
+        return `${s.toFixed(1)}s`;
+    return `${Math.floor(s / 60)}m${Math.round(s % 60)}s`;
+}
+/** Like tryFetchJson, but also says whether anything answered at all — a 404
+ * from a live server is worth a follow-up request, a dead address is not. */
+async function probeJson(url, timeoutMs = 1500) {
+    const ctrl = new AbortController();
+    const t = setTimeout(() => ctrl.abort(), timeoutMs);
+    try {
+        const res = await fetch(url, { signal: ctrl.signal });
+        if (!res.ok)
+            return { reached: true, data: null };
+        return { reached: true, data: await res.json().catch(() => null) };
+    }
+    catch {
+        return { reached: false, data: null };
+    }
+    finally {
+        clearTimeout(t);
+    }
+}
+/** fetch with a hard timeout; returns null on any failure (used for detection probes). */
+async function tryFetchJson(url, init, timeoutMs = 1500) {
+    const ctrl = new AbortController();
+    const t = setTimeout(() => ctrl.abort(), timeoutMs);
+    try {
+        const res = await fetch(url, { ...init, signal: ctrl.signal });
+        if (!res.ok)
+            return null;
+        return await res.json();
+    }
+    catch {
+        return null;
+    }
+    finally {
+        clearTimeout(t);
+    }
+}

package/dist/verification.js

@@ -0,0 +1,71 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.failureSignature = failureSignature;
+exports.projectVerification = projectVerification;
+const fs = __importStar(require("fs"));
+const sandbox_1 = require("./sandbox");
+/** A repeat hint only: timings, coordinates and stack line numbers may vary.
+ * The original output remains the evidence presented to the model. */
+function failureSignature(output) {
+    return output.replace(/\x1b\[[0-9;]*m/g, "").replace(/\d+(?:\.\d+)?/g, "#").replace(/\s+/g, " ").trim();
+}
+/** Conventional project checks, without executing or interpolating package data.
+ * Caller-owned acceptance commands take precedence in the final gate. */
+function projectVerification(workspace) {
+    let file;
+    try {
+        file = (0, sandbox_1.resolveInWorkspace)(workspace, "package.json");
+    }
+    catch {
+        return;
+    }
+    if (!fs.existsSync(file))
+        return;
+    try {
+        if (fs.statSync(file).size > 1024 * 1024)
+            return "npm run build --if-present";
+        const scripts = JSON.parse(fs.readFileSync(file, "utf8")).scripts;
+        if (!scripts || typeof scripts !== "object")
+            return;
+        const commands = ["build", "test", "test:e2e"].filter(name => typeof scripts[name] === "string" && scripts[name].trim())
+            .map(name => `npm run ${name}`);
+        return commands.length ? commands.join(" && ") : undefined;
+    }
+    catch {
+        // npm reports malformed package metadata precisely; never silently bless it.
+        return "npm run build --if-present";
+    }
+}

package/dist/web/channel.js

@@ -0,0 +1,260 @@
+"use strict";
+// SessionChannel: the SessionUI a web session talks to. Same contract the
+// terminal Tui implements, but every event is tagged with the session id and
+// handed to the hub, which multiplexes all sessions onto one SSE stream.
+// Keeps a replay buffer (so a page that connects later sees the transcript),
+// the pending input/approval promises, and a coarse status for the sidebar.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SessionChannel = void 0;
+exports.uploadUrl = uploadUrl;
+exports.stripAnsi = stripAnsi;
+const ui_1 = require("../ui");
+const REPLAY_CAP = 2000;
+class SessionChannel {
+    id;
+    host;
+    slashCommands = [];
+    getStatus = () => "";
+    /** Structured snapshot for the page's status bar; assigned by the hub. */
+    getState = () => ({});
+    hintLeft = "";
+    onModeCycle = null;
+    onCancel = null;
+    onExit = null;
+    phase = "starting";
+    title = "";
+    busyLabel = null;
+    replay = [];
+    closed = false;
+    pendingInput = null;
+    inputQueue = [];
+    exitRequested = false;
+    pending = new Map();
+    askId = 0;
+    restoreReplay(events) {
+        this.replay = events.slice(-REPLAY_CAP).filter((e) => e.t !== "confirm" && e.t !== "select" && e.t !== "prompt" && e.t !== "answered");
+        this.askId = Math.max(0, ...events.map((e) => typeof e.id === "number" ? e.id : 0));
+    }
+    constructor(id, host) {
+        this.id = id;
+        this.host = host;
+    }
+    // ---- lifecycle -----------------------------------------------------------
+    start() { }
+    close() {
+        this.closed = true;
+        this.busyLabel = null;
+        this.resolvePending(null);
+        this.host.changed(this.id);
+    }
+    /** Make the session loop's next readInput() return "/exit" without echoing
+     * it as a user message. Used when a session is closed from the sidebar. */
+    requestExit() {
+        this.exitRequested = true;
+        if (this.pendingInput) {
+            const r = this.pendingInput;
+            this.pendingInput = null;
+            r("/exit");
+        }
+    }
+    // ---- input from the page -------------------------------------------------
+    /** A message from the page: text, attachments, or both. */
+    handleMessage(text, attachments = []) {
+        text = text.trim();
+        if ((!text && !attachments.length) || this.closed)
+            return;
+        const input = attachments.length ? { text, attachments } : text;
+        if (this.pendingInput) {
+            const resolve = this.pendingInput;
+            this.pendingInput = null;
+            this.accept(input);
+            resolve(input);
+        }
+        else {
+            this.inputQueue.push(input);
+        }
+    }
+    handleAnswer(id, value) {
+        if (!this.pending.has(id))
+            return;
+        this.setStatus("busy");
+        this.settle(id, value);
+    }
+    /** Stop button / esc: answer any open prompt with "no"/cancel, then abort
+     * the turn. Without the first step a cancel during an approval prompt
+     * would leave the agent waiting on a promise nothing will resolve. */
+    cancel() {
+        this.resolvePending(null);
+        this.onCancel?.();
+    }
+    resolvePending(value) {
+        for (const id of [...this.pending.keys()])
+            this.settle(id, value);
+    }
+    /** Resolve one prompt and record the outcome in the transcript, so a page
+     * that replays it later (reconnect, resume) sees the answer, not live
+     * buttons for a question nobody is asking any more. */
+    settle(id, value) {
+        const p = this.pending.get(id);
+        if (!p)
+            return;
+        this.pending.delete(id);
+        this.broadcast({ t: "answered", id });
+        if (p.kind === "confirm") {
+            const a = value === "always" ? "always allow" : value === "yes" ? "yes" : "no";
+            this.broadcast({ t: "line", kind: "status", s: `${a} — ${p.label}` });
+        }
+        else if (value === null || value === undefined || (p.kind === "prompt" && !String(value).trim())) {
+            this.broadcast({ t: "line", kind: "status", s: `cancelled — ${p.label}` });
+        }
+        else if (p.kind === "prompt") {
+            this.broadcast({ t: "line", kind: "status", s: `${p.label}: ${String(value).trim().slice(0, 200)}` });
+        }
+        p.resolve(value);
+    }
+    accept(input) {
+        const text = typeof input === "string" ? input : input.text;
+        const files = typeof input === "string"
+            ? []
+            : input.attachments.map((a) => ({ id: a.id, name: a.name, kind: a.kind, size: a.size, url: uploadUrl(this.id, a.id) }));
+        this.setStatus("busy");
+        this.broadcast({ t: "user", s: text, ...(files.length ? { files } : {}) });
+        const label = text || files.map((f) => f.name).join(", ");
+        if (!this.title && !label.startsWith("/")) {
+            this.title = label.replace(/\s+/g, " ").slice(0, 60);
+            this.host.changed(this.id);
+        }
+    }
+    setStatus(s) {
+        if (this.phase === s)
+            return;
+        this.phase = s;
+        this.host.changed(this.id);
+    }
+    // ---- event plumbing ------------------------------------------------------
+    broadcast(ev) {
+        ev.sid = this.id;
+        if (ev.t !== "busy" && ev.t !== "state") {
+            const prev = this.replay[this.replay.length - 1];
+            if ((ev.t === "token" || ev.t === "thinking") && prev?.t === ev.t && String(prev.s).length + String(ev.s).length < 100_000) {
+                prev.s += ev.s;
+            }
+            else
+                this.replay.push({ ...ev });
+            if (this.replay.length > REPLAY_CAP)
+                this.replay.shift();
+            this.host.touched(this.id);
+        }
+        this.host.send(ev);
+    }
+    stateEvent() {
+        return { t: "state", sid: this.id, s: { ...this.getState(), busy: this.busyLabel, title: this.title } };
+    }
+    pushState() {
+        this.host.send(this.stateEvent());
+    }
+    refresh() {
+        this.pushState();
+    }
+    // ---- SessionUI -----------------------------------------------------------
+    readInput() {
+        this.busyLabel = null;
+        this.setStatus("idle");
+        this.pushState();
+        if (this.exitRequested || this.closed)
+            return Promise.resolve("/exit");
+        if (this.inputQueue.length) {
+            const text = this.inputQueue.shift();
+            this.accept(text);
+            return Promise.resolve(text);
+        }
+        return new Promise((resolve) => (this.pendingInput = resolve));
+    }
+    select(title, options) {
+        const id = ++this.askId;
+        this.broadcast({ t: "select", id, title, options });
+        this.setStatus("waiting");
+        return new Promise((resolve) => this.pending.set(id, { kind: "select", label: title, resolve: (i) => resolve(typeof i === "number" ? i : null) }));
+    }
+    prompt(title, placeholder = "") {
+        const id = ++this.askId;
+        this.broadcast({ t: "prompt", id, title, placeholder });
+        this.setStatus("waiting");
+        return new Promise((resolve) => this.pending.set(id, {
+            kind: "prompt",
+            label: title,
+            resolve: (s) => resolve(typeof s === "string" && s.trim() ? s.trim().slice(0, 500) : null),
+        }));
+    }
+    confirmCommand(command, reason) {
+        const id = ++this.askId;
+        this.broadcast({ t: "confirm", id, command, reason });
+        this.setStatus("waiting");
+        return new Promise((resolve) => this.pending.set(id, {
+            kind: "confirm",
+            label: command,
+            resolve: (a) => resolve(a === "always" ? "always" : a === "yes" ? "yes" : "no"),
+        }));
+    }
+    token(text) {
+        this.broadcast({ t: "token", s: text });
+    }
+    resetResponse() {
+        this.broadcast({ t: "response_reset" });
+    }
+    thinking(text) {
+        this.broadcast({ t: "thinking", s: text });
+    }
+    toolCall(name, args) {
+        this.broadcast({ t: "tool", name, summary: (0, ui_1.summarizeArgs)(name, args) });
+    }
+    toolResult(result) {
+        const lines = result.split("\n");
+        const first = lines[0] ?? "";
+        this.broadcast({
+            t: "result",
+            line: first.slice(0, 160),
+            err: first.startsWith("Error"),
+            extra: lines.length > 1 ? lines.length - 1 : 0,
+            body: result,
+        });
+    }
+    planUpdated(plan) {
+        this.broadcast({ t: "plan", steps: plan.steps, current: plan.currentIndex });
+        this.pushState();
+    }
+    println(s = "") {
+        if (s.trim())
+            this.broadcast({ t: "line", kind: "status", s: stripAnsi(s) });
+    }
+    status(s) {
+        this.broadcast({ t: "line", kind: "status", s: stripAnsi(s) });
+    }
+    warn(s) {
+        this.broadcast({ t: "line", kind: "warn", s: stripAnsi(s) });
+    }
+    error(s) {
+        this.broadcast({ t: "line", kind: "error", s: stripAnsi(s) });
+    }
+    turnEnd(label) {
+        this.broadcast({ t: "turnend", label });
+        this.pushState();
+    }
+    startSpinner(label) {
+        this.busyLabel = label;
+        this.broadcast({ t: "busy", label });
+    }
+    stopSpinner() {
+        this.busyLabel = null;
+        this.broadcast({ t: "busy", label: null });
+    }
+}
+exports.SessionChannel = SessionChannel;
+/** Where the page fetches a stored upload (it appends its own key). */
+function uploadUrl(sid, id) {
+    return `/upload?sid=${sid}&id=${id}`;
+}
+function stripAnsi(s) {
+    // eslint-disable-next-line no-control-regex
+    return s.replace(/\x1b\[[0-9;]*m/g, "");
+}