@rse/ase 0.9.46 → 0.9.48

package/dst/ase-kv.js

@@ -30,10 +30,10 @@ export class KV {
         KV.validateKey(key);
         return KV.store.has(key);
     }
-    /*  get a value by key; returns undefined if no value is stored  */
+    /*  get a deep copy of a value by key; returns undefined if no value is stored  */
     static get(key) {
         KV.validateKey(key);
-        return KV.store.get(key);
+        return structuredClone(KV.store.get(key));
     }
     /*  set a value under the given key; overwrites any existing value  */
     static set(key, val) {
@@ -72,7 +72,48 @@ export class KV {
         for (const [k, v] of snap)
             KV.store.set(k, v);
     }
+    /*  execute a single key/value command and return its result text  */
+    static execute(c) {
+        if (c.command === "clear")
+            return `OK: removed ${KV.clear(c.prefix)} key(s)`;
+        else if (c.command === "set") {
+            if (c.key === undefined)
+                throw new Error("missing `key`");
+            if (c.val === undefined)
+                throw new Error("missing `val`");
+            KV.set(c.key, c.val);
+            return `OK: stored key "${c.key}"`;
+        }
+        else if (c.command === "get") {
+            if (c.key === undefined)
+                throw new Error("missing `key`");
+            if (!KV.has(c.key))
+                return "";
+            const val = KV.get(c.key);
+            return val === undefined ? "" : JSON.stringify(val);
+        }
+        else if (c.command === "delete") {
+            if (c.key === undefined)
+                throw new Error("missing `key`");
+            return KV.delete(c.key) ?
+                `OK: removed key "${c.key}"` :
+                `WARNING: no key "${c.key}" to remove`;
+        }
+        else
+            throw new Error(`invalid command "${String(c.command)}"`);
+    }
 }
+/*  extract the message of a caught error  */
+const errorMessage = (err) => err instanceof Error ? err.message : String(err);
+/*  execute a single key/value command and render it as an MCP tool result  */
+const mcpToolExec = (c) => {
+    try {
+        return { content: [{ type: "text", text: KV.execute(c) }] };
+    }
+    catch (err) {
+        return { isError: true, content: [{ type: "text", text: `ERROR: ${errorMessage(err)}` }] };
+    }
+};
 /*  MCP registration entry point for in-memory key/value tools  */
 export class KVMCP {
     register(mcp) {
@@ -85,19 +126,7 @@ export class KVMCP {
                 key: z.string()
                     .describe("key identifier (non-empty, no whitespace-only, no control characters, up to 1024 characters)")
             }
-        }, async (args) => {
-            try {
-                if (!KV.has(args.key))
-                    return { content: [{ type: "text", text: "" }] };
-                const val = KV.get(args.key);
-                const text = val === undefined ? "" : JSON.stringify(val);
-                return { content: [{ type: "text", text }] };
-            }
-            catch (err) {
-                const message = err instanceof Error ? err.message : String(err);
-                return { isError: true, content: [{ type: "text", text: `ERROR: ${message}` }] };
-            }
-        });
+        }, async (args) => mcpToolExec({ command: "get", key: args.key }));
         /*  key/value set  */
         mcp.registerTool("ase_kv_set", {
             title: "ASE key/value set",
@@ -110,16 +139,7 @@ export class KVMCP {
                 val: z.union([z.string(), z.number(), z.boolean(), z.null(), z.array(z.unknown()), z.record(z.string(), z.unknown())])
                     .describe("arbitrary JSON-compatible value to store under `key`")
             }
-        }, async (args) => {
-            try {
-                KV.set(args.key, args.val);
-                return { content: [{ type: "text", text: `OK: stored key "${args.key}"` }] };
-            }
-            catch (err) {
-                const message = err instanceof Error ? err.message : String(err);
-                return { isError: true, content: [{ type: "text", text: `ERROR: ${message}` }] };
-            }
-        });
+        }, async (args) => mcpToolExec({ command: "set", key: args.key, val: args.val }));
         /*  key/value clear  */
         mcp.registerTool("ase_kv_clear", {
             title: "ASE key/value clear",
@@ -131,16 +151,7 @@ export class KVMCP {
                 prefix: z.string().optional()
                     .describe("if given, only remove keys starting with this prefix (otherwise remove all keys)")
             }
-        }, async (args) => {
-            try {
-                const n = KV.clear(args.prefix);
-                return { content: [{ type: "text", text: `OK: removed ${n} key(s)` }] };
-            }
-            catch (err) {
-                const message = err instanceof Error ? err.message : String(err);
-                return { isError: true, content: [{ type: "text", text: `ERROR: ${message}` }] };
-            }
-        });
+        }, async (args) => mcpToolExec({ command: "clear", prefix: args.prefix }));
         /*  key/value delete  */
         mcp.registerTool("ase_kv_delete", {
             title: "ASE key/value delete",
@@ -150,19 +161,7 @@ export class KVMCP {
                 key: z.string()
                     .describe("key identifier (non-empty, no whitespace-only, no control characters, up to 1024 characters)")
             }
-        }, async (args) => {
-            try {
-                const removed = KV.delete(args.key);
-                const msg = removed ?
-                    `OK: removed key "${args.key}"` :
-                    `WARNING: no key "${args.key}" to remove`;
-                return { content: [{ type: "text", text: msg }] };
-            }
-            catch (err) {
-                const message = err instanceof Error ? err.message : String(err);
-                return { isError: true, content: [{ type: "text", text: `ERROR: ${message}` }] };
-            }
-        });
+        }, async (args) => mcpToolExec({ command: "delete", key: args.key }));
         /*  key/value batch  */
         mcp.registerTool("ase_kv_batch", {
             title: "ASE key/value batch",
@@ -199,39 +198,10 @@ export class KVMCP {
             const snapshot = tx ? KV.snapshot() : null;
             for (const c of args.commands) {
                 try {
-                    if (c.command === "clear") {
-                        const n = KV.clear(c.prefix);
-                        results.push(`OK: removed ${n} key(s)`);
-                    }
-                    else if (c.command === "set") {
-                        if (c.key === undefined)
-                            throw new Error("missing `key`");
-                        if (c.val === undefined)
-                            throw new Error("missing `val`");
-                        KV.set(c.key, c.val);
-                        results.push(`OK: stored key "${c.key}"`);
-                    }
-                    else if (c.command === "get") {
-                        if (c.key === undefined)
-                            throw new Error("missing `key`");
-                        if (!KV.has(c.key))
-                            results.push("");
-                        else {
-                            const val = KV.get(c.key);
-                            results.push(val === undefined ? "" : JSON.stringify(val));
-                        }
-                    }
-                    else if (c.command === "delete") {
-                        if (c.key === undefined)
-                            throw new Error("missing `key`");
-                        const removed = KV.delete(c.key);
-                        results.push(removed ?
-                            `OK: removed key "${c.key}"` :
-                            `WARNING: no key "${c.key}" to remove`);
-                    }
+                    results.push(KV.execute(c));
                 }
                 catch (err) {
-                    const message = err instanceof Error ? err.message : String(err);
+                    const message = errorMessage(err);
                     if (tx) {
                         if (snapshot !== null)
                             KV.restore(snapshot);

package/dst/ase-log.js

@@ -24,11 +24,7 @@ export default class Log {
         this._logFile = _logFile;
     }
     async init() {
-        /*  log messages  */
-        const idx = levels.findIndex((l) => l.name === this._logLevel);
-        if (idx === -1)
-            throw new RangeError(`invalid log level "${this._logLevel}" (expected one of: ${levels.map((l) => l.name).join(", ")})`);
-        this.logLevelIdx = idx;
+        this.logLevel(this._logLevel);
         if (this._logFile !== "-")
             this.stream = this.openStream(this._logFile);
     }
@@ -73,4 +69,16 @@ export default class Log {
                 this.stream.write(line);
         }
     }
+    /*  close the log file stream, flushing all pending writes  */
+    async close() {
+        if (this.stream === null)
+            return;
+        const stream = this.stream;
+        this.stream = null;
+        await new Promise((resolve) => {
+            stream.end(() => {
+                resolve();
+            });
+        });
+    }
 }

package/dst/ase-markdown.js

@@ -69,6 +69,16 @@ export class Markdown {
             n++;
         return n;
     }
+    /*  test whether the newline at offset pos starts a paragraph break,
+        i.e. whether it is followed by a blank line or the end of the text  */
+    static isParagraphBreak(text, pos) {
+        let n = pos + 1;
+        while (n < text.length && (text[n] === " " || text[n] === "\t"))
+            n++;
+        if (text[n] === "\r")
+            n++;
+        return n >= text.length || text[n] === "\n";
+    }
     /*  PASS 1 of rewrite(): rewrite inline code spans that carry
         backslash-escaped backticks (`\``) into CommonMark-correct spans  */
     static rewriteEscapedSpans(text) {
@@ -118,7 +128,7 @@ export class Markdown {
                     k += runLen;
                     continue;
                 }
-                if (c === "\n" && /^[ \t]*\r?(?:\n|$)/.test(text.slice(k + 1)))
+                if (c === "\n" && Markdown.isParagraphBreak(text, k))
                     /*  a code span never crosses a paragraph break  */
                     break;
                 inner += c;
@@ -185,7 +195,7 @@ export class Markdown {
                                 closes = true;
                             p += r;
                         }
-                        else if (text[p] === "\n" && /^[ \t]*\r?(?:\n|$)/.test(text.slice(p + 1)))
+                        else if (text[p] === "\n" && Markdown.isParagraphBreak(text, p))
                             /*  a code span never crosses a paragraph break  */
                             break;
                         else

package/dst/ase-mcp.js

@@ -23,7 +23,7 @@ export default class MCPCommand {
         let ctx = this.loadContext();
         /*  fast path: already running  */
         if (ctx.port !== null) {
-            const match = await probe(ctx.port, ctx.projectId);
+            const match = await probe(ctx.port, ctx.projectId).catch(() => null);
             if (match === true)
                 return { projectId: ctx.projectId, port: ctx.port };
         }
@@ -94,8 +94,11 @@ export default class MCPCommand {
                     return;
                 triggerReconnect("http connection lost");
             };
+            /*  activate the connection and flush buffered messages  */
             await next.start();
             client = next;
+            for (const msg of pending.splice(0, pending.length))
+                sendToClient(msg);
         };
         /*  reconnect loop: restart service if needed, then reconnect client  */
         const reconnect = async (attempt = 0) => {
@@ -132,12 +135,26 @@ export default class MCPCommand {
             this.log.write("warning", `mcp: ${reason} — reconnecting`);
             reconnect(0).catch(() => { });
         };
-        /*  wire stdio server  */
-        server.onmessage = (msg) => {
-            client?.send(msg).catch((err) => {
+        /*  bounded buffer for messages arriving while no HTTP client is connected  */
+        const MAX_PENDING = 100;
+        const pending = [];
+        /*  forward a message to the HTTP client, buffering it while the client
+            is disconnected so requests survive a reconnect window  */
+        const sendToClient = (msg) => {
+            if (client === null) {
+                if (pending.length >= MAX_PENDING) {
+                    this.log.write("warning", "mcp: pending queue overflow, dropping oldest message");
+                    pending.shift();
+                }
+                pending.push(msg);
+                return;
+            }
+            client.send(msg).catch((err) => {
                 this.log.write("error", `mcp: http send: ${this.asError(err).message}`);
             });
         };
+        /*  wire stdio server  */
+        server.onmessage = sendToClient;
         server.onerror = (err) => {
             this.log.write("error", `mcp: stdio: ${err.message}`);
         };

package/dst/ase-meta.js

@@ -6,7 +6,7 @@
 import path from "node:path";
 import fs from "node:fs";
 import { fileURLToPath } from "node:url";
-import { writeStdout } from "./ase-stdout.js";
+import { writeStdout } from "./ase-stdio.js";
 /*  reusable functionality: resolve and read plugin "meta/" files  */
 export class Meta {
     /*  determine the plugin "meta/" directory; the build process copies

package/dst/ase-persona.js

@@ -20,9 +20,7 @@ export class Persona {
         if (val === undefined)
             return "engineer";
         const style = String(isScalar(val) ? val.value : val);
-        if (!Persona.styles.includes(style))
-            return "engineer";
-        return style;
+        return Persona.styles.find((s) => s === style) ?? "engineer";
     }
     /*  set the persona style on the strongest scope of an optional session  */
     static set(log, style, session) {

package/dst/ase-service.js

@@ -477,6 +477,16 @@ export default class ServiceCommand {
         }
         throw lastErr;
     }
+    /*  build the "POST /command" request options for a command token  */
+    commandRequest(cmd, timeoutMs) {
+        return {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: { command: cmd },
+            signal: AbortSignal.timeout(timeoutMs),
+            ignoreResponseError: true
+        };
+    }
     /*  status flow: report whether the service is running  */
     async doStatus() {
         const ctx = this.loadContext();
@@ -484,15 +494,9 @@ export default class ServiceCommand {
             process.stdout.write("service: not running (no port configured)\n");
             return 1;
         }
-        const match = await probe(ctx.port, ctx.projectId);
+        const match = await probe(ctx.port, ctx.projectId).catch(() => null);
         if (match === true) {
-            const r = await ofetch.raw(`http://${HOST}:${ctx.port}/command`, {
-                method: "POST",
-                headers: { "Content-Type": "application/json" },
-                body: { command: "status" },
-                signal: AbortSignal.timeout(2000),
-                ignoreResponseError: true
-            });
+            const r = await ofetch.raw(`http://${HOST}:${ctx.port}/command`, this.commandRequest("status", 2000));
             const d = r._data;
             const uptimeMs = typeof d?.uptimeMs === "number" ? d.uptimeMs : 0;
             const uptime = prettyMs(uptimeMs, { verbose: true });
@@ -509,30 +513,16 @@ export default class ServiceCommand {
     /*  send command: POST /command with the arbitrary cmd token  */
     async doSend(cmd) {
         let ctx = this.loadContext();
-        if (ctx.port === null) {
-            await this.doStart();
-            ctx = this.loadContext();
-            if (ctx.port === null)
-                throw new Error("service not running (no port configured after auto-start)");
-        }
-        let match = await probe(ctx.port, ctx.projectId);
-        if (match !== true) {
+        if (ctx.port === null || await probe(ctx.port, ctx.projectId).catch(() => null) !== true) {
+            /*  auto-start the service once, then re-check  */
             await this.doStart();
             ctx = this.loadContext();
             if (ctx.port === null)
                 throw new Error("service not running (no port configured after auto-start)");
-            match = await probe(ctx.port, ctx.projectId);
-            if (match !== true)
+            if (await probe(ctx.port, ctx.projectId).catch(() => null) !== true)
                 throw new Error(`service not responding on port ${ctx.port} after auto-start`);
         }
-        const r = await ofetch.raw(`http://${HOST}:${ctx.port}/command`, {
-            method: "POST",
-            headers: { "Content-Type": "application/json" },
-            body: { command: cmd },
-            signal: AbortSignal.timeout(5000),
-            ignoreResponseError: true,
-            responseType: "text"
-        });
+        const r = await ofetch.raw(`http://${HOST}:${ctx.port}/command`, { ...this.commandRequest(cmd, 5000), responseType: "text" });
         const body = typeof r._data === "string" ? r._data : JSON.stringify(r._data);
         process.stdout.write(body);
         if (!body.endsWith("\n"))
@@ -546,7 +536,7 @@ export default class ServiceCommand {
             this.log.write("info", "service: not running (no port configured)");
             return 0;
         }
-        const match = await probe(ctx.port, ctx.projectId);
+        const match = await probe(ctx.port, ctx.projectId).catch(() => null);
         if (match === false) {
             this.log.write("info", `service: not running (port ${ctx.port} in use by foreign service)`);
             return 1;

package/dst/ase-setup.js

@@ -63,27 +63,18 @@ export default class SetupCommand {
             path.join(prefix, "bin"),
             path.join(prefix, "lib", "node_modules")
         ];
+        const accessible = (dir, mode) => fs.access(dir, mode).then(() => true, () => false);
         for (const dir of candidates) {
-            try {
-                await fs.access(dir, fs.constants.W_OK);
-            }
-            catch {
-                /*  directory exists but not writable, or does not exist
-                    inside a non-writable parent: require sudo  */
-                try {
-                    await fs.access(dir, fs.constants.F_OK);
-                    return true;
-                }
-                catch {
-                    /*  directory does not exist: check parent writability  */
-                    try {
-                        await fs.access(path.dirname(dir), fs.constants.W_OK);
-                    }
-                    catch {
-                        return true;
-                    }
-                }
-            }
+            /*  a writable directory needs no elevation at all  */
+            if (await accessible(dir, fs.constants.W_OK))
+                continue;
+            /*  the directory exists, but is not writable: require sudo  */
+            if (await accessible(dir, fs.constants.F_OK))
+                return true;
+            /*  the directory does not exist: require sudo unless it can
+                be created inside a writable parent directory  */
+            if (!(await accessible(path.dirname(dir), fs.constants.W_OK)))
+                return true;
         }
         return false;
     }
@@ -110,25 +101,7 @@ export default class SetupCommand {
         for (let i = 0; i < retries; i++) {
             const final = (i === retries - 1);
             try {
-                if (quiet) {
-                    const result = await execa(cmd, args, { stdio: "ignore", cwd, reject: false });
-                    if (typeof result.exitCode === "number" && result.exitCode !== 0) {
-                        if (!final) {
-                            this.log.write("info", `setup: attempt ${i + 1}/${retries} failed for "${cmd} ${args.join(" ")}" ` +
-                                `(exit code: ${result.exitCode}): retrying...`);
-                            await new Promise((resolve) => setTimeout(resolve, 1000));
-                            continue;
-                        }
-                        if (ignoreError !== undefined) {
-                            this.log.write("info", `setup: ${ignoreError} (skipped)`);
-                            return;
-                        }
-                        this.log.write("error", `setup: command failed: exit code: ${result.exitCode}`);
-                        throw new Error(`command "${cmd} ${args.join(" ")}" failed (exit code: ${result.exitCode})`);
-                    }
-                    return;
-                }
-                await execa(cmd, args, { stdio: "pipe", cwd });
+                await execa(cmd, args, { stdio: quiet ? "ignore" : "pipe", cwd });
                 return;
             }
             catch (err) {
@@ -383,29 +356,13 @@ export default class SetupCommand {
                 args.push(name, transport.url);
             }
         }
-        else if (tool === "copilot") {
-            /*  GitHub Copilot CLI implies the stdio transport when the
-                command is provided after "--"; only "http"/"sse" servers
-                need an explicit "--transport" flag and take the URL as a
-                positional argument  */
-            if (transport.type === "stdio") {
-                args.push(name);
-                for (const [key, val] of Object.entries(env))
-                    args.push("--env", `${key}=${val}`);
-                args.push("--", ...transport.command);
-            }
-            else {
-                args.push("--transport", "http");
-                for (const [key, val] of Object.entries(transport.headers ?? {}))
-                    args.push("--header", `${key}: ${val}`);
-                args.push(name, transport.url);
-            }
-        }
         else {
-            /*  OpenAI Codex CLI takes the server name as the first
-                positional argument and implies the stdio transport when the
-                command is provided after "--"; "http" servers take the URL
-                via the "--url" option (with optional "--header" flags)  */
+            /*  the GitHub Copilot CLI and OpenAI Codex CLI both take the
+                server name as a positional argument and imply the stdio
+                transport when the command is provided after "--"; for "http"
+                servers the GitHub Copilot CLI needs an explicit
+                "--transport" flag and takes the URL positionally, while the
+                OpenAI Codex CLI takes it via the "--url" option  */
             if (transport.type === "stdio") {
                 args.push(name);
                 for (const [key, val] of Object.entries(env))
@@ -413,9 +370,14 @@ export default class SetupCommand {
                 args.push("--", ...transport.command);
             }
             else {
+                if (tool === "copilot")
+                    args.push("--transport", "http");
                 for (const [key, val] of Object.entries(transport.headers ?? {}))
                     args.push("--header", `${key}: ${val}`);
-                args.push(name, "--url", transport.url);
+                if (tool === "copilot")
+                    args.push(name, transport.url);
+                else
+                    args.push(name, "--url", transport.url);
             }
         }
         await this.run(toolSpecs[tool].cli, args);
@@ -684,24 +646,18 @@ export default class SetupCommand {
         AST, reproducing the exact whitespace tokens json-asty emits for a
         canonically 4-space-indented settings.json  */
     statuslineBuildMember(root, command) {
-        const strMember = (key, val, epilog) => {
-            const k = root.create("string").set({ body: JSON.stringify(key), value: key, epilog: ": " });
-            const v = root.create("string").set({ body: JSON.stringify(val), value: val });
-            const m = root.create("member");
-            if (epilog !== undefined)
-                m.set({ epilog });
-            return m.add(k, v);
-        };
-        const numMember = (key, val, epilog) => {
+        const member = (key, val, epilog) => {
+            const type = typeof val === "number" ? "number" : "string";
+            const body = typeof val === "number" ? String(val) : JSON.stringify(val);
             const k = root.create("string").set({ body: JSON.stringify(key), value: key, epilog: ": " });
-            const v = root.create("number").set({ body: String(val), value: val });
+            const v = root.create(type).set({ body, value: val });
             const m = root.create("member");
             if (epilog !== undefined)
                 m.set({ epilog });
             return m.add(k, v);
         };
         const obj = root.create("object").set({ prolog: "{\n        ", epilog: "\n    }\n" });
-        obj.add(strMember("type", "command", ",\n        "), strMember("command", command, ",\n        "), numMember("padding", 0));
+        obj.add(member("type", "command", ",\n        "), member("command", command, ",\n        "), member("padding", 0));
         const key = root.create("string").set({
             body: JSON.stringify("statusLine"),
             value: "statusLine",

package/dst/ase-skills.js

@@ -54,7 +54,7 @@ export class Skills {
     }
     /*  fetch GitHub stars given a repository URL (or empty string)  */
     static async fetchStars(repository) {
-        const m = /^.+?\/\/github\.com\/([^/]+\/[^/#?]+?)(?:\.git)?(?:[/#?].*)?$/.exec(repository);
+        const m = /^(?:.*?:\/\/)?(?:[^@/]*@)?github\.com[:/]([^/]+\/[^/#?]+?)(?:\.git)?(?:[/#?].*)?$/.exec(repository);
         if (m === null)
             return "N.A.";
         try {