smolcoder-plus 1.0.0

package/dist/attachments.js

@@ -0,0 +1,158 @@
+"use strict";
+// Files the user attaches to a message in the web UI: a screenshot pasted from
+// the clipboard, a dropped image, or a text file. Images travel to the model
+// as vision input when the model can see; text files are inlined into the
+// user turn. The bytes live under ~/.smolcoder/uploads/<session>/, never
+// inside the workspace, so an attachment can never dirty the user's repo.
+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.IMAGE_TOKENS = exports.MAX_TEXT_BYTES = exports.MAX_UPLOAD_BYTES = void 0;
+exports.safeName = safeName;
+exports.extOf = extOf;
+exports.mimeForExt = mimeForExt;
+exports.looksLikeText = looksLikeText;
+exports.classifyUpload = classifyUpload;
+exports.imageBase64 = imageBase64;
+exports.imageDataUrl = imageDataUrl;
+exports.renderAttachmentsForModel = renderAttachmentsForModel;
+const fs = __importStar(require("fs"));
+/** Largest single upload the hub accepts. */
+exports.MAX_UPLOAD_BYTES = 20 * 1024 * 1024;
+/** Text files are inlined into the prompt, so they must stay small enough for
+ * a local model's context window. */
+exports.MAX_TEXT_BYTES = 48 * 1024;
+/** Rough prompt cost of one image for the context gauge: a screenshot on a
+ * qwen-vl class model lands around here after the backend's own resize. */
+exports.IMAGE_TOKENS = 1500;
+const IMAGE_MIMES = {
+    png: "image/png",
+    jpg: "image/jpeg",
+    jpeg: "image/jpeg",
+    gif: "image/gif",
+    webp: "image/webp",
+};
+/** Strip any path and control characters from a user-supplied file name. */
+function safeName(name) {
+    const base = String(name ?? "").split(/[\\/]/).pop() ?? "";
+    const cleaned = base.replace(/[\x00-\x1f\x7f]/g, "").trim().slice(0, 80);
+    return cleaned || "file";
+}
+/** Extension for the stored copy: from the name when it has one, else from the
+ * declared type (a clipboard screenshot arrives as image/png with no name). */
+function extOf(name, mime) {
+    const m = /\.([a-z0-9]{1,8})$/i.exec(name);
+    if (m)
+        return m[1].toLowerCase();
+    const type = mime.toLowerCase().split(";")[0].trim();
+    for (const [ext, t] of Object.entries(IMAGE_MIMES))
+        if (t === type)
+            return ext;
+    return type.startsWith("text/") ? "txt" : "bin";
+}
+/** Content type to serve a stored upload with. Everything that is not a
+ * raster image was accepted as text. */
+function mimeForExt(ext) {
+    return IMAGE_MIMES[ext.toLowerCase()] ?? "text/plain; charset=utf-8";
+}
+function looksLikeText(bytes) {
+    const n = Math.min(bytes.length, 8192);
+    for (let i = 0; i < n; i++)
+        if (bytes[i] === 0)
+            return false;
+    return true;
+}
+/** Decide how an upload is used, or say why it cannot be. */
+function classifyUpload(name, mime, bytes) {
+    if (bytes.length === 0)
+        return { error: `"${name}" is empty.` };
+    const ext = extOf(name, mime);
+    if (IMAGE_MIMES[ext])
+        return { kind: "image", mime: IMAGE_MIMES[ext] };
+    if (!looksLikeText(bytes)) {
+        return { error: `"${name}" is not a supported attachment. Images (png, jpg, gif, webp) and text files can be attached.` };
+    }
+    if (bytes.length > exports.MAX_TEXT_BYTES) {
+        return {
+            error: `"${name}" is too large to attach as text (${Math.round(bytes.length / 1024)} KB; the limit is ${exports.MAX_TEXT_BYTES / 1024} KB). Put it in the workspace and ask the agent to read it.`,
+        };
+    }
+    return { kind: "text", mime: "text/plain; charset=utf-8" };
+}
+/** Base64 of a stored image, or null when the file is gone: a deleted upload
+ * must not fail the whole request. */
+function imageBase64(ref) {
+    try {
+        return fs.readFileSync(ref.path).toString("base64");
+    }
+    catch {
+        return null;
+    }
+}
+function imageDataUrl(ref) {
+    const b64 = imageBase64(ref);
+    return b64 === null ? null : `data:${ref.mime};base64,${b64}`;
+}
+const FENCE = "```";
+/** The prompt text and image references for a turn's attachments. Text files
+ * are inlined verbatim; images become vision input when the model can see,
+ * otherwise a note so the model can tell the user what it cannot do. */
+function renderAttachmentsForModel(attachments, canSeeImages) {
+    const parts = [];
+    const images = [];
+    for (const a of attachments) {
+        if (a.kind === "image") {
+            if (canSeeImages) {
+                images.push({ path: a.path, mime: a.mime, name: a.name });
+                parts.push(`[Attached image: ${a.name}]`);
+            }
+            else {
+                parts.push(`[Attached image: ${a.name} — this model cannot view images. If the image matters, tell the user to switch to a vision-capable model with /models.]`);
+            }
+            continue;
+        }
+        let body;
+        try {
+            body = fs.readFileSync(a.path, "utf8");
+        }
+        catch {
+            body = "(the file is no longer available)";
+        }
+        if (body.length > exports.MAX_TEXT_BYTES)
+            body = body.slice(0, exports.MAX_TEXT_BYTES) + `\n… [truncated: ${a.size} bytes in total]`;
+        const fence = body.includes(FENCE) ? FENCE + "`" : FENCE;
+        parts.push(`[Attached file: ${a.name} (${a.size} bytes)]\n${fence}\n${body}\n${fence}`);
+    }
+    return { text: parts.join("\n\n"), images };
+}

package/dist/config.js

@@ -0,0 +1,87 @@
+"use strict";
+// User config (~/.smolcoder.json) and the data directory (~/.smolcoder/) that
+// holds saved web sessions and the workspace list. Shared by the CLI entry
+// point, the session loop and the web hub.
+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.DATA_DIR = exports.CONFIG_PATH = void 0;
+exports.loadConfig = loadConfig;
+exports.saveConfig = saveConfig;
+exports.updateConfig = updateConfig;
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+// SMOLCODER_CONFIG points tests at a scratch file so they never touch the
+// real one.
+exports.CONFIG_PATH = process.env.SMOLCODER_CONFIG || path.join(os.homedir(), ".smolcoder.json");
+exports.DATA_DIR = path.join(os.homedir(), ".smolcoder");
+function loadConfig() {
+    try {
+        const cfg = JSON.parse(fs.readFileSync(exports.CONFIG_PATH, "utf8"));
+        // Never let bypass be inherited implicitly from a past session — a single
+        // shift+tab into it would otherwise silently persist unattended, unchecked
+        // command execution into every later run, including headless -p in CI.
+        // Requires an explicit flag (-m bypass / --bypass) each time. Old configs
+        // saved "write"/"yolo" under the previous mode names.
+        if (cfg.lastMode === "write")
+            cfg.lastMode = "edit";
+        if (cfg.lastMode === "yolo" || cfg.lastMode === "bypass")
+            cfg.lastMode = "edit";
+        cfg.hosts = Array.isArray(cfg.hosts)
+            ? cfg.hosts
+                .filter((h) => h && typeof h.address === "string" && h.address.trim())
+                .map((h) => ({ address: h.address.trim(), ...(typeof h.name === "string" && h.name.trim() ? { name: h.name.trim() } : {}) }))
+            : [];
+        return cfg;
+    }
+    catch {
+        return {};
+    }
+}
+function saveConfig(cfg) {
+    try {
+        fs.writeFileSync(exports.CONFIG_PATH, JSON.stringify(cfg, null, 2));
+    }
+    catch {
+        /* non-fatal */
+    }
+}
+/** Change some settings and keep the rest. Re-reads the file first: several
+ * web sessions share it, and each one only knows about its own fields. */
+function updateConfig(patch) {
+    const next = { ...loadConfig(), ...patch };
+    saveConfig(next);
+    return next;
+}