smolcoder-plus 1.0.0

package/dist/web/terminal.js

@@ -0,0 +1,190 @@
+"use strict";
+// Embedded terminal for the web panel, without a PTY (that would need a native
+// dependency). A persistent shell reads commands from a pipe: state such as
+// cwd and env carries across commands, output streams back, and a sentinel
+// after every command reports its exit code and the shell's cwd. No TTY means
+// no colors from most tools and no interactive programs — the panel says so.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Terminal = void 0;
+exports.toOsPath = toOsPath;
+exports.stripControl = stripControl;
+const child_process_1 = require("child_process");
+const shell_1 = require("../tools/shell");
+const RS = "\x1e"; // record separator — never appears in normal output
+const SENTINEL = /\x1e(-?\d+)\x1e([^\x1e]*)\x1e\r?\n?/;
+const BUFFER_CAP = 200_000;
+const HOLD_CAP = 600; // a partial sentinel is held back at most this long
+class Terminal {
+    id;
+    hooks;
+    cwd;
+    /** Recent output for replay when a page (re)connects. */
+    buffer = "";
+    closed = false;
+    shell;
+    proc = null;
+    acc = "";
+    kind;
+    interrupting = false;
+    spawnedAt = 0;
+    quickExits = 0;
+    constructor(id, cwd, hooks) {
+        this.id = id;
+        this.hooks = hooks;
+        this.cwd = cwd;
+        this.shell = (0, shell_1.pickShell)();
+        this.kind = /powershell|pwsh/i.test(this.shell.exe) ? "powershell" : "posix";
+        this.emit(`\x1b[2m${this.shell.label} · no TTY: interactive programs will not work · ctrl+c interrupts\x1b[0m\n`);
+        this.spawn();
+    }
+    spawn() {
+        const args = this.kind === "posix" ? ["-l"] : ["-NoProfile", "-NonInteractive", "-Command", "-"];
+        this.spawnedAt = Date.now();
+        let proc;
+        try {
+            proc = (0, child_process_1.spawn)(this.shell.exe, args, {
+                cwd: this.cwd,
+                env: { ...process.env, TERM: "dumb" },
+                detached: process.platform !== "win32",
+                windowsHide: true,
+                stdio: ["pipe", "pipe", "pipe"],
+            });
+        }
+        catch (err) {
+            this.emit(`[could not start ${this.shell.label}: ${err?.message ?? err}]\n`);
+            return;
+        }
+        this.proc = proc;
+        proc.stdout?.on("data", (d) => this.ingest(d.toString("utf8")));
+        proc.stderr?.on("data", (d) => this.ingest(d.toString("utf8")));
+        proc.on("error", (err) => this.emit(`[could not start ${this.shell.label}: ${err.message}]\n`));
+        proc.on("close", (code) => {
+            if (this.proc !== proc)
+                return;
+            this.proc = null;
+            if (this.acc) {
+                this.emit(this.acc);
+                this.acc = "";
+            }
+            if (this.closed)
+                return;
+            if (this.interrupting) {
+                this.interrupting = false;
+                this.emit("\n\x1b[33m[interrupted]\x1b[0m\n");
+                this.spawn();
+                return;
+            }
+            // A shell that dies instantly, twice, is not going to work — stop.
+            const quick = Date.now() - this.spawnedAt < 1500;
+            this.quickExits = quick ? this.quickExits + 1 : 0;
+            if (this.quickExits >= 2) {
+                this.emit(`\n\x1b[31m[${this.shell.label} keeps exiting (code ${code}) — close this tab and open a new terminal]\x1b[0m\n`);
+                return;
+            }
+            this.emit(`\n\x1b[2m[shell exited with code ${code} — starting a new one]\x1b[0m\n`);
+            this.spawn();
+        });
+    }
+    /** Run one line. Echoed into the stream first, so every connected page (and
+     * the replay) shows the command with its output. */
+    write(line) {
+        if (this.closed)
+            return;
+        const cmd = line.replace(/\r?\n$/, "");
+        this.emit(`\x1b[36m❯\x1b[0m ${cmd}\n`);
+        if (!this.proc?.stdin?.writable) {
+            this.emit("\x1b[31m[no shell running]\x1b[0m\n");
+            return;
+        }
+        const payload = this.kind === "posix"
+            ? // The group redirect keeps a stdin-hungry command (cat, ssh) from
+                // eating the next command off our pipe; 2>&1 keeps output ordered.
+                `{\n${cmd}\n} </dev/null 2>&1\nprintf '${RS}%s${RS}%s${RS}\\n' "$?" "$PWD"\n`
+            : `${cmd}\nWrite-Output ([string][char]0x1e + $(if ($?) {0} else {1}) + [char]0x1e + (Get-Location).Path + [char]0x1e)\n`;
+        try {
+            this.proc.stdin.write(payload);
+        }
+        catch (err) {
+            this.emit(`[could not write to the shell: ${err?.message ?? err}]\n`);
+        }
+    }
+    /** ctrl+c: kill the shell (and whatever it is running), start a fresh one
+     * in the last known cwd. */
+    interrupt() {
+        if (this.closed)
+            return;
+        if (!this.proc) {
+            this.spawn();
+            return;
+        }
+        this.interrupting = true;
+        if (this.proc.pid)
+            (0, shell_1.killTree)(this.proc.pid);
+    }
+    close() {
+        this.closed = true;
+        if (this.proc?.pid)
+            (0, shell_1.killTree)(this.proc.pid);
+        this.proc = null;
+    }
+    ingest(text) {
+        this.acc += text;
+        for (;;) {
+            const m = SENTINEL.exec(this.acc);
+            if (!m)
+                break;
+            const before = this.acc.slice(0, m.index);
+            if (before)
+                this.emit(before);
+            this.acc = this.acc.slice(m.index + m[0].length);
+            const cwd = toOsPath(m[2].trim()) || this.cwd;
+            this.cwd = cwd;
+            this.hooks.done(Number(m[1]), cwd);
+        }
+        // Hold back a partial sentinel that may complete with the next chunk,
+        // but never for long — a stray RS in real output must not stall the view.
+        const i = this.acc.indexOf(RS);
+        if (i < 0) {
+            if (this.acc)
+                this.emit(this.acc);
+            this.acc = "";
+        }
+        else {
+            if (i > 0)
+                this.emit(this.acc.slice(0, i));
+            this.acc = this.acc.slice(i);
+            if (this.acc.length > HOLD_CAP) {
+                this.emit(this.acc);
+                this.acc = "";
+            }
+        }
+    }
+    emit(text) {
+        text = stripControl(text);
+        if (!text)
+            return;
+        this.buffer += text;
+        if (this.buffer.length > BUFFER_CAP)
+            this.buffer = this.buffer.slice(-Math.floor(BUFFER_CAP * 0.8));
+        this.hooks.output(text);
+    }
+}
+exports.Terminal = Terminal;
+/** Git Bash reports /c/x for C:\x; spawn() needs the Windows form. */
+function toOsPath(p) {
+    if (process.platform === "win32") {
+        const m = /^\/([a-zA-Z])(\/.*)?$/.exec(p);
+        if (m)
+            return `${m[1].toUpperCase()}:${(m[2] ?? "/").replace(/\//g, "\\")}`;
+    }
+    return p;
+}
+/** Keep SGR color codes (the page renders them) and \r (progress bars), drop
+ * every other escape sequence: cursor moves, screen clears, OSC titles. */
+function stripControl(s) {
+    return s
+        .replace(/\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)/g, "")
+        .replace(/\x1b\[[0-9;?]*[ -/]*[@-ln-~]/g, "")
+        .replace(/\x1b[^[\]]/g, "")
+        .replace(/[\x00-\x08\x0b\x0c\x0e-\x1a\x1c-\x1f]/g, "");
+}

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "smolcoder-plus",
+  "version": "1.0.0",
+  "description": "A smol, zero-config CLI coding agent for local models (Ollama & LM Studio). It just works.",
+  "keywords": [
+    "cli",
+    "coding-agent",
+    "agent",
+    "ollama",
+    "lm-studio",
+    "local-llm",
+    "local-models",
+    "smol",
+    "ai"
+  ],
+  "license": "MIT",
+  "author": "Leon van Zyl",
+  "homepage": "https://github.com/leonvanzyl/smolcoder#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/leonvanzyl/smolcoder.git"
+  },
+  "bugs": {
+    "url": "https://github.com/leonvanzyl/smolcoder/issues"
+  },
+  "bin": {
+    "smolcoder-plus": "dist/index.js"
+  },
+  "main": "dist/index.js",
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "clean": "node -e \"require('fs').rmSync('dist', { recursive: true, force: true })\"",
+    "build": "npm run clean && tsc",
+    "postbuild": "node -e \"require('fs').chmodSync('dist/index.js', 0o755)\"",
+    "dev": "tsc -w",
+    "prepublishOnly": "npm test",
+    "test": "npm run build && node scripts/test.cjs"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "devDependencies": {
+    "@types/node": "^20.14.0",
+    "typescript": "^5.5.0"
+  }
+}