agentsw 0.7.1 → 0.7.2

package/dist/config-transaction.js

@@ -1,18 +1,13 @@
 import fs from "node:fs";
 import path from "node:path";
 import { randomUUID } from "node:crypto";
-import { backupsDir } from "./fsutil.js";
-function snapshot(file) {
-    try {
-        const stat = fs.lstatSync(file);
-        if (!stat.isFile())
-            throw new Error("not a regular file");
-        return { text: fs.readFileSync(file, "utf8"), mode: stat.mode & 0o777, identity: `${stat.dev}:${stat.ino}` };
-    }
-    catch (error) {
-        if (error.code === "ENOENT")
-            return { text: undefined };
-        throw new Error(`${file}: cannot read a regular configuration file`);
+import { appDataDir, backupsDir, isDryRun, readFileSnapshot } from "./fsutil.js";
+function sameSnapshot(actual, expected) {
+    return actual.text === expected.text && actual.mode === expected.mode && actual.identity === expected.identity;
+}
+function assertSnapshot(file, expected) {
+    if (!sameSnapshot(readFileSnapshot(file), expected)) {
+        throw new Error(`${file}: configuration changed since it was read`);
     }
 }
 function atomicWrite(file, text, mode) {
@@ -20,16 +15,94 @@ function atomicWrite(file, text, mode) {
     try {
         fs.writeFileSync(temp, text, { flag: "wx", mode });
         fs.chmodSync(temp, mode);
+        const stat = fs.lstatSync(temp, { bigint: true });
         fs.renameSync(temp, file);
+        return { text, mode: Number(stat.mode & 511n), identity: `${stat.dev}:${stat.ino}` };
     }
     finally {
         fs.rmSync(temp, { force: true });
     }
 }
+// Store saves and all adapter/management commits share this cross-process lock.
+// It covers synchronous validation/commit only, never discovery or network waits.
+const lockFile = path.join(appDataDir("agentsw"), ".write.lock");
+function writeLockBusyError() {
+    let owner;
+    try {
+        const stat = fs.lstatSync(lockFile);
+        if (stat.isFile() && stat.size <= 4096) {
+            const value = JSON.parse(fs.readFileSync(lockFile, "utf8"));
+            if (value && typeof value === "object" && "pid" in value && "createdAt" in value &&
+                typeof value.pid === "number" && Number.isInteger(value.pid) && value.pid > 0 && value.pid <= 0x7fffffff &&
+                typeof value.createdAt === "string" && Number.isFinite(Date.parse(value.createdAt))) {
+                owner = { pid: value.pid, createdAt: new Date(value.createdAt).toISOString() };
+            }
+        }
+    }
+    catch { /* An empty, unreadable, or initializing lock is not evidence that its owner exited. */ }
+    let status = "owner metadata is missing or unreadable; the lock may still be initializing";
+    if (owner) {
+        status = `owner PID ${owner.pid}, created ${owner.createdAt}; process status could not be determined`;
+        try {
+            process.kill(owner.pid, 0);
+            return new Error(`${lockFile}: configuration write busy; owner PID ${owner.pid} is running on this host (created ${owner.createdAt}); wait for it to finish; do not remove an active lock`);
+        }
+        catch (error) {
+            if (error.code === "ESRCH") {
+                status = `owner PID ${owner.pid} is no longer running on this host (created ${owner.createdAt}); a previous writer may have crashed`;
+            }
+        }
+    }
+    // No timeout-based or automatic unlink: PID reuse, shared homes, and initializing writers
+    // make even an apparently abandoned lock unsafe to steal while other writers can start.
+    return new Error(`${lockFile}: configuration write busy; ${status}; recovery: stop all agentsw writers, confirm this lock is abandoned, then manually remove ${lockFile} and retry; never remove a lock held by an active writer`);
+}
+function withWriteLock(operation) {
+    fs.mkdirSync(path.dirname(lockFile), { recursive: true, mode: 0o700 });
+    let fd;
+    try {
+        fd = fs.openSync(lockFile, "wx", 0o600);
+    }
+    catch (error) {
+        if (error.code === "EEXIST") {
+            throw writeLockBusyError();
+        }
+        throw new Error(`${lockFile}: cannot acquire configuration write lock`);
+    }
+    try {
+        const owned = fs.fstatSync(fd, { bigint: true });
+        try {
+            try {
+                fs.writeFileSync(fd, JSON.stringify({ pid: process.pid, createdAt: new Date().toISOString() }) + "\n");
+            }
+            catch {
+                throw new Error(`${lockFile}: cannot record configuration write lock owner`);
+            }
+            return operation();
+        }
+        finally {
+            // Keep the descriptor open while checking ownership, preventing inode reuse.
+            // A replaced lock belongs to somebody else; never remove it on their behalf.
+            try {
+                const current = fs.lstatSync(lockFile, { bigint: true });
+                if (current.dev === owned.dev && current.ino === owned.ino)
+                    fs.unlinkSync(lockFile);
+            }
+            catch (error) {
+                if (error.code !== "ENOENT")
+                    throw error;
+            }
+        }
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+}
 /** Validate the entire plan and save every original before mutating any configuration. */
 export function commitFileChanges(changes, opts = {}) {
     const paths = new Set();
     const identities = new Set();
+    const reads = new Map(opts.reads);
     const plan = changes.map((change) => {
         const file = path.resolve(change.file);
         // Resolve the parent too, so directory symlinks cannot disguise duplicate plans.
@@ -45,94 +118,106 @@ export function commitFileChanges(changes, opts = {}) {
         if (paths.has(canonical))
             throw new Error(`${file}: duplicate file plan`);
         paths.add(canonical);
-        const current = snapshot(file);
+        const current = readFileSnapshot(file);
         if (current.identity && identities.has(current.identity))
             throw new Error(`${file}: duplicate file plan`);
         if (current.identity)
             identities.add(current.identity);
-        if (current.text !== change.before)
+        if (current.text !== change.before || (change.expected && !sameSnapshot(current, change.expected))) {
             throw new Error(`${file}: configuration changed since it was read`);
+        }
         if (change.mode !== undefined && (!Number.isInteger(change.mode) || change.mode < 0 || change.mode > 0o777)) {
             throw new Error(`${file}: invalid file permissions`);
         }
-        return { ...change, file, originalMode: current.mode };
-    }).filter((change) => change.before !== change.after);
+        if (!reads.has(file))
+            reads.set(file, change.expected ?? current);
+        return { ...change, file, original: current };
+    }).filter((change) => change.before !== change.after || (change.original.text !== undefined && change.mode !== undefined && change.mode !== change.original.mode));
+    const validateReads = () => {
+        for (const [file, expected] of reads)
+            assertSnapshot(file, expected);
+    };
+    validateReads();
     const files = plan.map((change) => change.file);
-    if (!plan.length || opts.dryRun)
+    if (!plan.length || (opts.dryRun ?? isDryRun()))
         return { files };
-    let backupDir;
-    let currentFile = backupsDir;
-    try {
-        fs.mkdirSync(backupsDir, { recursive: true, mode: 0o700 });
-        backupDir = fs.mkdtempSync(path.join(backupsDir, "transaction-"));
-        fs.chmodSync(backupDir, 0o700);
-        for (const [index, change] of plan.entries()) {
-            currentFile = change.file;
-            if (change.before === undefined)
-                continue;
-            const backup = path.join(backupDir, `${index}-${path.basename(change.file)}`);
-            fs.writeFileSync(backup, change.before, { flag: "wx", mode: 0o600 });
-            fs.chmodSync(backup, 0o600);
+    return withWriteLock(() => {
+        // Another writer may have committed between planning and acquiring the lock.
+        validateReads();
+        let backupDir;
+        let currentFile = backupsDir;
+        try {
+            fs.mkdirSync(backupsDir, { recursive: true, mode: 0o700 });
+            backupDir = fs.mkdtempSync(path.join(backupsDir, "transaction-"));
+            fs.chmodSync(backupDir, 0o700);
+            for (const [index, change] of plan.entries()) {
+                currentFile = change.file;
+                if (change.before === undefined)
+                    continue;
+                const backup = path.join(backupDir, `${index}-${path.basename(change.file)}`);
+                fs.writeFileSync(backup, change.before, { flag: "wx", mode: 0o600 });
+                fs.chmodSync(backup, 0o600);
+            }
+            fs.writeFileSync(path.join(backupDir, "manifest.json"), JSON.stringify(plan.map((change, index) => ({
+                file: change.file,
+                backup: change.before === undefined ? null : `${index}-${path.basename(change.file)}`,
+                mode: change.original.mode,
+            })), null, 2) + "\n", { flag: "wx", mode: 0o600 });
+            fs.chmodSync(path.join(backupDir, "manifest.json"), 0o600);
+            validateReads();
         }
-        fs.writeFileSync(path.join(backupDir, "manifest.json"), JSON.stringify(plan.map((change, index) => ({
-            file: change.file,
-            backup: change.before === undefined ? null : `${index}-${path.basename(change.file)}`,
-            mode: change.originalMode,
-        })), null, 2) + "\n", { flag: "wx", mode: 0o600 });
-        for (const change of plan) {
-            currentFile = change.file;
-            if (snapshot(change.file).text !== change.before)
-                throw new Error("stale snapshot");
+        catch {
+            throw new Error(`${currentFile}: backup or pre-write validation failed; configuration files were not changed`);
         }
-    }
-    catch {
-        throw new Error(`${currentFile}: backup or pre-write validation failed; configuration files were not changed`);
-    }
-    const applied = [];
-    const createdDirectories = [];
-    try {
-        for (const change of plan) {
-            currentFile = change.file;
-            if (snapshot(change.file).text !== change.before)
-                throw new Error("stale snapshot");
-            if (change.after === undefined)
-                fs.unlinkSync(change.file);
-            else {
-                const missing = [];
-                for (let dir = path.dirname(change.file); !fs.existsSync(dir); dir = path.dirname(dir))
-                    missing.push(dir);
-                for (const dir of missing.reverse()) {
-                    fs.mkdirSync(dir, { mode: 0o700 });
-                    createdDirectories.push(dir);
+        const applied = [];
+        const createdDirectories = [];
+        try {
+            for (const change of plan) {
+                currentFile = change.file;
+                assertSnapshot(change.file, change.original);
+                let written;
+                if (change.after === undefined) {
+                    fs.unlinkSync(change.file);
+                    written = { text: undefined };
+                }
+                else {
+                    const missing = [];
+                    for (let dir = path.dirname(change.file); !fs.existsSync(dir); dir = path.dirname(dir))
+                        missing.push(dir);
+                    for (const dir of missing.reverse()) {
+                        fs.mkdirSync(dir, { mode: 0o700 });
+                        createdDirectories.push(dir);
+                    }
+                    written = atomicWrite(change.file, change.after, change.mode ?? change.original.mode ?? 0o600);
                 }
-                atomicWrite(change.file, change.after, change.mode ?? change.originalMode ?? 0o600);
+                applied.push({ change, written });
+                reads.set(change.file, written);
             }
-            applied.push(change);
+            validateReads();
         }
-    }
-    catch {
-        const failed = [];
-        for (const change of applied.reverse()) {
-            try {
-                // Do not overwrite a third party's intervening edit while rolling back.
-                if (snapshot(change.file).text !== change.after)
-                    throw new Error("stale rollback snapshot");
-                if (change.before === undefined)
-                    fs.unlinkSync(change.file);
-                else
-                    atomicWrite(change.file, change.before, change.originalMode ?? 0o600);
-            }
-            catch {
-                failed.push(change.file);
+        catch {
+            const failed = [];
+            for (const { change, written } of applied.reverse()) {
+                try {
+                    // Do not overwrite a third party's intervening edit while rolling back.
+                    assertSnapshot(change.file, written);
+                    if (change.before === undefined)
+                        fs.unlinkSync(change.file);
+                    else
+                        atomicWrite(change.file, change.before, change.original.mode ?? 0o600);
+                }
+                catch {
+                    failed.push(change.file);
+                }
             }
-        }
-        for (const dir of createdDirectories.reverse()) {
-            try {
-                fs.rmdirSync(dir);
+            for (const dir of createdDirectories.reverse()) {
+                try {
+                    fs.rmdirSync(dir);
+                }
+                catch { /* Only remove empty directories created by this transaction. */ }
             }
-            catch { /* Only remove empty directories created by this transaction. */ }
+            throw new Error(`${currentFile}: configuration transaction failed; ${failed.length ? `rollback incomplete for ${failed.join(", ")}` : "previous writes rolled back"}; backups: ${backupDir}`);
         }
-        throw new Error(`${currentFile}: configuration transaction failed; ${failed.length ? `rollback incomplete for ${failed.join(", ")}` : "previous writes rolled back"}; backups: ${backupDir}`);
-    }
-    return { files, backupDir };
+        return { files, backupDir };
+    });
 }

package/dist/discover.js

@@ -1,23 +1,64 @@
+/** Append operations to the path, never to a query string or fragment. */
+function modelListUrl(baseUrl) {
+    const url = new URL(baseUrl);
+    if (url.protocol !== "https:" && url.protocol !== "http:")
+        throw new Error("provider URL must use HTTP or HTTPS");
+    const pathname = url.pathname.replace(/\/+$/, "");
+    url.pathname = /\/v\d+(?:beta\d*)?$/.test(pathname) ? `${pathname}/models` : `${pathname}/v1/models`;
+    url.hash = "";
+    return url;
+}
+function parseModelPage(body) {
+    if (!body || typeof body !== "object")
+        throw new Error("invalid model-list response");
+    const page = body;
+    const rows = page.data ?? page.models;
+    if (!Array.isArray(rows))
+        throw new Error("model-list response has no model array");
+    if (page.has_more !== undefined && typeof page.has_more !== "boolean")
+        throw new Error("invalid model-list pagination flag");
+    const ids = rows.flatMap((row) => {
+        if (!row || typeof row !== "object")
+            return [];
+        const id = row.id;
+        return typeof id === "string" && id.length > 0 ? [id] : [];
+    });
+    return { ids, hasMore: page.has_more === true, lastId: typeof page.last_id === "string" ? page.last_id : undefined };
+}
 /**
  * List model ids from the provider's own /v1/models endpoint.
  * Resellers expose the id list here but no metadata (context, thinking, modalities) —
  * metadata is filled from models.dev afterwards (enrichModels).
  */
 export async function discoverProviderModels(opts) {
-    const base = opts.baseUrl.replace(/\/+$/, "");
-    const url = /\/v\d+$/.test(base) ? `${base}/models` : `${base}/v1/models`;
+    const url = modelListUrl(opts.baseUrl);
     const headers = opts.protocol === "anthropic"
         ? { "x-api-key": opts.apiKey, "anthropic-version": "2023-06-01" }
         : { authorization: `Bearer ${opts.apiKey}` };
-    const res = await fetch(url, { headers, signal: AbortSignal.timeout(20000) });
-    if (!res.ok)
-        throw new Error(`${url} -> HTTP ${res.status}`);
-    const body = (await res.json());
-    const rows = body.data ?? body.models ?? [];
-    const ids = rows.map((r) => r.id).filter((id) => typeof id === "string" && id.length > 0);
-    if (ids.length === 0)
-        throw new Error(`${url} returned no models`);
-    return [...new Set(ids)].sort();
+    const ids = new Set();
+    const cursors = new Set();
+    const initialCursor = url.searchParams.get("after_id");
+    if (initialCursor)
+        cursors.add(initialCursor);
+    while (true) {
+        const res = await fetch(url.toString(), { headers, signal: AbortSignal.timeout(20000) });
+        if (!res.ok)
+            throw new Error(`model discovery -> HTTP ${res.status}`);
+        const page = parseModelPage(await res.json());
+        for (const id of page.ids)
+            ids.add(id);
+        if (!page.hasMore)
+            break;
+        if (!page.lastId || !page.lastId.trim())
+            throw new Error("model-list pagination is missing last_id");
+        if (cursors.has(page.lastId))
+            throw new Error("model-list pagination repeated a cursor");
+        cursors.add(page.lastId);
+        url.searchParams.set("after_id", page.lastId);
+    }
+    if (ids.size === 0)
+        throw new Error("provider returned no models");
+    return [...ids].sort();
 }
 /**
  * Probe which wire protocols an endpoint supports by hitting /v1/models
@@ -25,8 +66,7 @@ export async function discoverProviderModels(opts) {
  * with a valid model list (at least one model id).
  */
 export async function probeProtocols(opts) {
-    const base = opts.baseUrl.replace(/\/+$/, "");
-    const url = /\/v\d+$/.test(base) ? `${base}/models` : `${base}/v1/models`;
+    const url = modelListUrl(opts.baseUrl).toString();
     const attempts = [
         { protocol: "openai", headers: { authorization: `Bearer ${opts.apiKey}` } },
         { protocol: "anthropic", headers: { "x-api-key": opts.apiKey, "anthropic-version": "2023-06-01" } },
@@ -37,10 +77,8 @@ export async function probeProtocols(opts) {
             const res = await fetch(url, { headers: a.headers, signal: AbortSignal.timeout(15000) });
             if (!res.ok)
                 continue;
-            const body = (await res.json());
-            const rows = body.data ?? body.models ?? [];
-            const ids = rows.map((r) => r.id).filter((id) => typeof id === "string" && id.length > 0);
-            if (ids.length > 0)
+            const page = parseModelPage(await res.json());
+            if (page.ids.length > 0)
                 supported.push(a.protocol);
         }
         catch {

package/dist/envfile.js

@@ -1,27 +1,108 @@
 /** Tokenize complete dotenv assignments, including quoted multiline values. */
 export function envAssignments(file, text) {
     const result = [];
-    const pattern = /^([\t ]*(?:export[\t ]+)?)([A-Za-z_][A-Za-z0-9_]*)([\t ]*=[\t ]*)("(?:\\[\s\S]|[^"\\])*"|'[^']*'|[^\r\n]*)(?:[\t ]*#[^\r\n]*)?[\t ]*(?:\r?\n|$)/gm;
-    let end = 0;
-    const trivia = (text) => text.split(/\r?\n/).every((line) => !line.trim() || line.trimStart().startsWith("#"));
-    for (const match of text.matchAll(pattern)) {
-        if (!trivia(text.slice(end, match.index)))
-            throw new Error(`${file}: invalid environment configuration`);
-        let value = match[4];
-        if (value.startsWith('"') || value.startsWith("'")) {
-            if (value.at(-1) !== value[0])
-                throw new Error(`${file}: invalid quoted environment value`);
-            const quote = value[0];
-            value = value.slice(1, -1);
-            if (quote === '"')
-                value = value.replace(/\\n/g, "\n").replace(/\\r/g, "\r");
+    let position = 0;
+    const invalid = () => { throw new Error(`${file}: invalid environment configuration`); };
+    const skipSpace = () => { while (text[position] === " " || text[position] === "\t")
+        position++; };
+    while (position < text.length) {
+        const start = position;
+        skipSpace();
+        if (text[position] === "#") {
+            while (position < text.length && text[position] !== "\n" && text[position] !== "\r")
+                position++;
         }
-        else
-            value = value.split("#", 1)[0].trim();
-        result.push({ name: match[2], offset: match.index + match[1].length, value, start: match.index, length: match[0].length });
-        end = match.index + match[0].length;
+        else if (position < text.length && text[position] !== "\r" && text[position] !== "\n") {
+            if (text.startsWith("export", position) && /[\t ]/.test(text[position + 6] ?? "")) {
+                position += 6;
+                skipSpace();
+            }
+            const offset = position;
+            const name = /^[A-Za-z_][A-Za-z0-9_]*/.exec(text.slice(position))?.[0];
+            if (!name)
+                return invalid();
+            position += name.length;
+            skipSpace();
+            if (text[position++] !== "=")
+                invalid();
+            skipSpace();
+            const valueStart = position;
+            let value;
+            const quote = text[position];
+            if (quote === '"' || quote === "'") {
+                position++;
+                const contentStart = position;
+                while (position < text.length && text[position] !== quote) {
+                    if (quote === '"' && text[position] === "\\")
+                        position++;
+                    position++;
+                }
+                if (text[position] !== quote)
+                    invalid();
+                value = text.slice(contentStart, position++);
+                if (quote === '"')
+                    value = value.replace(/\\(\\|"|n|r)/g, (_escape, character) => character === "n" ? "\n" : character === "r" ? "\r" : character);
+            }
+            else {
+                while (position < text.length && !"\r\n#".includes(text[position]))
+                    position++;
+                value = text.slice(valueStart, position).trimEnd();
+            }
+            const valueLength = quote === '"' || quote === "'" ? position - valueStart : value.length;
+            skipSpace();
+            if (text[position] === "#") {
+                while (position < text.length && text[position] !== "\n" && text[position] !== "\r")
+                    position++;
+            }
+            if (position < text.length && text[position] !== "\r" && text[position] !== "\n")
+                invalid();
+            if (text[position] === "\r") {
+                if (text[position + 1] !== "\n")
+                    invalid();
+                position++;
+            }
+            if (text[position] === "\n")
+                position++;
+            result.push({ name, offset, value, start, length: position - start, valueStart, valueLength });
+            continue;
+        }
+        if (text[position] === "\r") {
+            if (text[position + 1] !== "\n")
+                invalid();
+            position++;
+        }
+        if (text[position] === "\n")
+            position++;
     }
-    if (!trivia(text.slice(end)))
-        throw new Error(`${file}: invalid environment configuration`);
     return result;
 }
+/** Quote only when necessary, with no dotenv escape round-trip ambiguity. */
+function encodeEnvValue(value) {
+    if (/^[^\s#'"`]+$/.test(value) && !value.includes("\\"))
+        return value;
+    if (!value.includes("'"))
+        return `'${value}'`;
+    return `"${value.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n").replace(/\r/g, "\\r")}"`;
+}
+/** Update complete parsed values, retaining exports, comments and unrelated bytes. */
+export function upsertEnvAssignment(file, text, name, value) {
+    const assignments = envAssignments(file, text).filter((assignment) => assignment.name === name);
+    const encoded = encodeEnvValue(value);
+    if (!assignments.length) {
+        const newline = text.includes("\r\n") ? "\r\n" : "\n";
+        return text + (text === "" || text.endsWith("\n") ? "" : newline) + `${name}=${encoded}${newline}`;
+    }
+    for (const assignment of assignments.reverse()) {
+        text = text.slice(0, assignment.valueStart) + encoded + text.slice(assignment.valueStart + assignment.valueLength);
+    }
+    return text;
+}
+/** Delete complete assignments, never lines embedded in another quoted value. */
+export function removeEnvAssignments(file, text, names) {
+    const assignments = envAssignments(file, text);
+    for (const assignment of assignments.reverse()) {
+        if (names.has(assignment.name))
+            text = text.slice(0, assignment.start) + text.slice(assignment.start + assignment.length);
+    }
+    return text;
+}