@agent-native/core 0.211.0 → 0.211.1-nightly-20261020213022

package/dist/cli/template-baseline.js

@@ -10,6 +10,7 @@ const GIT_IDENTITY = {
     GIT_COMMITTER_NAME: "agent-native",
     GIT_COMMITTER_EMAIL: "noreply@agent-native.com",
 };
+const KEEP_LINE_ENDINGS = ["-c", "core.autocrlf=false", "-c", "core.eol=lf"];
 export function resolveBaselineStore(appDir) {
     const resolved = realpath(path.resolve(appDir));
     const gitDir = findGitDir(resolved);
@@ -67,10 +68,15 @@ export function writeBaseline(store, sourceDir, slot, meta) {
         copyPlainTree(sourceDir, target);
         const indexFile = path.join(stage, "index");
         const env = { ...process.env, ...GIT_IDENTITY, GIT_INDEX_FILE: indexFile };
-        git(store, ["--work-tree", stageRoot, "add", "-A", "--force", "."], {
-            cwd: stageRoot,
-            env,
-        });
+        git(store, [
+            ...KEEP_LINE_ENDINGS,
+            "--work-tree",
+            stageRoot,
+            "add",
+            "-A",
+            "--force",
+            ".",
+        ], { cwd: stageRoot, env });
         const tree = git(store, ["write-tree"], { cwd: stageRoot, env }).trim();
         const ref = baselineRefName(store, slot);
         const parent = revParse(store, ref);
@@ -142,7 +148,14 @@ export function materializeBaseline(store, slot) {
             return null;
         }
         const tarPath = path.join(out, ".baseline.tar");
-        const args = ["archive", "--format=tar", "-o", tarPath, ref];
+        const args = [
+            ...KEEP_LINE_ENDINGS,
+            "archive",
+            "--format=tar",
+            "-o",
+            tarPath,
+            ref,
+        ];
         if (store.prefix)
             args.push("--", store.prefix);
         git(store, args);

package/dist/cli/template-sync.js

@@ -149,12 +149,13 @@ export function mergeTemplateTrees(appDir, baseDir, theirsDir, options = {}) {
         manual: [],
         keptLocal: [],
     };
-    const paths = new Set([
+    const paths = Array.from(new Set([
         ...listMergeableFiles(baseDir),
         ...listMergeableFiles(theirsDir),
         ...listMergeableFiles(appDir),
-    ]);
-    for (const rel of Array.from(paths).sort()) {
+    ])).sort();
+    const normalized = crlfNormalizedPaths(appDir, paths);
+    for (const rel of paths) {
         const oursPath = path.join(appDir, rel);
         if (isLocalSymlink(oursPath)) {
             result.manual.push(`${rel} (local symlink)`);
@@ -162,7 +163,9 @@ export function mergeTemplateTrees(appDir, baseDir, theirsDir, options = {}) {
         }
         const base = readFileOrNull(path.join(baseDir, rel));
         const theirs = readFileOrNull(path.join(theirsDir, rel));
-        const ours = readFileOrNull(oursPath);
+        const app = readAppFile(oursPath, normalized.has(rel) ? (base ?? theirs) : null);
+        const ours = app.content;
+        const writeOurs = (content) => writeFile(oursPath, app.crlf ? withCrlf(content) : content);
         if (equalBuffers(base, theirs))
             continue;
         if (theirs === null) {
@@ -193,7 +196,7 @@ export function mergeTemplateTrees(appDir, baseDir, theirsDir, options = {}) {
             continue;
         if (equalBuffers(ours, base)) {
             if (!options.dryRun)
-                writeFile(oursPath, theirs);
+                writeOurs(theirs);
             result.updated.push(rel);
             continue;
         }
@@ -206,8 +209,9 @@ export function mergeTemplateTrees(appDir, baseDir, theirsDir, options = {}) {
             result.manual.push(`${rel} (merge failed)`);
             continue;
         }
-        if (!options.dryRun)
-            writeFile(oursPath, merged.content);
+        if (!options.dryRun && !equalBuffers(merged.content, ours)) {
+            writeOurs(merged.content);
+        }
         if (merged.conflicts > 0)
             result.conflicted.push(rel);
         else
@@ -475,19 +479,21 @@ async function statusCommand(target, flags, io) {
         try {
             const local = countLocallyModified(target.appDir, baseDir);
             lines.push(`  locally modified files: ${local}`);
-            const targetRef = flags.to ?? target.provenance.templateRef ?? latest;
-            const theirs = await materializeForTarget(target, flags, targetRef);
             try {
-                const changed = countUpstreamChanged(baseDir, theirs.dir);
-                lines.push(`  upstream-changed files: ${changed} (at ${theirs.ref})`);
+                const targetRef = flags.to ?? target.provenance.templateRef ?? latest;
+                const theirs = await materializeForTarget(target, flags, targetRef);
+                try {
+                    const changed = countUpstreamChanged(baseDir, theirs.dir);
+                    lines.push(`  upstream-changed files: ${changed} (at ${theirs.ref})`);
+                }
+                finally {
+                    fs.rmSync(theirs.dir, { recursive: true, force: true });
+                }
             }
-            finally {
-                fs.rmSync(theirs.dir, { recursive: true, force: true });
+            catch (err) {
+                lines.push(`  upstream-changed files: unavailable (${err instanceof Error ? err.message.split("\n")[0] : String(err)})`);
             }
         }
-        catch (err) {
-            lines.push(`  upstream-changed files: unavailable (${err instanceof Error ? err.message.split("\n")[0] : String(err)})`);
-        }
         finally {
             fs.rmSync(baseDir, { recursive: true, force: true });
         }
@@ -648,13 +654,19 @@ function backfillProvenance(target, template, materialized) {
         shape: target.shape,
     };
     pkg["agent-native"] = agentNative;
-    fs.writeFileSync(pkgPath, `${JSON.stringify(pkg, null, 2)}\n`);
+    const json = Buffer.from(`${JSON.stringify(pkg, null, 2)}\n`);
+    const app = readAppFile(pkgPath, json);
+    if (equalBuffers(app.content, json))
+        return;
+    fs.writeFileSync(pkgPath, app.crlf ? withCrlf(json) : json);
 }
 function countLocallyModified(appDir, baseDir) {
     let count = 0;
-    for (const rel of listMergeableFiles(baseDir)) {
+    const paths = Array.from(listMergeableFiles(baseDir));
+    const normalized = crlfNormalizedPaths(appDir, paths);
+    for (const rel of paths) {
         const base = readFileOrNull(path.join(baseDir, rel));
-        const ours = readFileOrNull(path.join(appDir, rel));
+        const ours = readAppFile(path.join(appDir, rel), normalized.has(rel) ? base : null).content;
         if (!equalBuffers(base, ours))
             count++;
     }
@@ -809,6 +821,75 @@ function equalBuffers(a, b) {
         return a === b;
     return a.equals(b);
 }
+// CRLF that git normalizes on add is not a local edit.
+function readAppFile(file, template) {
+    const content = readFileOrNull(file);
+    if (content === null ||
+        template === null ||
+        template.includes(0x0d) ||
+        !isTextBuffer(content) ||
+        !isTextBuffer(template)) {
+        return { content, crlf: false };
+    }
+    const text = content.toString("utf-8");
+    if (!text.includes("\r\n") || /\r(?!\n)/.test(text)) {
+        return { content, crlf: false };
+    }
+    return {
+        content: Buffer.from(text.replace(/\r\n/g, "\n")),
+        crlf: !/(^|[^\r])\n/.test(text),
+    };
+}
+// Paths whose CRLF git turns into LF on add; anywhere else a CR is content.
+function crlfNormalizedPaths(appDir, rels) {
+    const normalized = new Set();
+    if (!resolveBaselineStore(appDir).gitDir)
+        return normalized;
+    const res = spawnSync("git", ["check-attr", "-z", "--stdin", "text", "crlf", "eol"], {
+        cwd: appDir,
+        input: rels.join("\0"),
+        encoding: "utf-8",
+        maxBuffer: 64 * 1024 * 1024,
+    });
+    if (res.status !== 0) {
+        throw new Error(`git check-attr failed in ${appDir}: ${res.stderr || res.error?.message}`);
+    }
+    const config = spawnSync("git", ["config", "--get", "core.autocrlf"], {
+        cwd: appDir,
+        encoding: "utf-8",
+    });
+    if (config.status !== 0 && config.status !== 1) {
+        throw new Error(`git config core.autocrlf failed in ${appDir}: ${config.stderr || config.error?.message}`);
+    }
+    const byConfig = ["true", "yes", "on", "1", "input"].includes(config.stdout.trim().toLowerCase());
+    const attrs = new Map();
+    const fields = res.stdout.split("\0");
+    for (let i = 0; i + 2 < fields.length; i += 3) {
+        attrs.set(fields[i], {
+            ...attrs.get(fields[i]),
+            [fields[i + 1]]: fields[i + 2],
+        });
+    }
+    for (const [rel, { text, crlf, eol }] of attrs) {
+        const byAttrs = conversion(text) ??
+            conversion(crlf) ??
+            (eol === "lf" || eol === "crlf" ? true : null);
+        if (byAttrs ?? byConfig)
+            normalized.add(rel);
+    }
+    return normalized;
+}
+// A text or crlf attribute as git reads it: convert, keep bytes, or no say.
+function conversion(value) {
+    if (value === "set" || value === "auto" || value === "input")
+        return true;
+    return value === "unset" ? false : null;
+}
+function withCrlf(content) {
+    if (!isTextBuffer(content))
+        return content;
+    return Buffer.from(content.toString("utf-8").replace(/\r?\n/g, "\r\n"));
+}
 function isTextBuffer(buf) {
     if (buf === null)
         return true;

package/dist/collab/__fixtures__/live-copy-tasks.d.ts

@@ -0,0 +1 @@
+export declare const tasks: Record<string, (input: never) => Promise<import("../live-copy-tasks.js").LiveCopyTaskResult>>;

package/dist/collab/__fixtures__/live-copy-tasks.js

@@ -0,0 +1,92 @@
+import * as Y from "yjs";
+import { defineLiveCopyTasks } from "../live-copy-tasks.js";
+// A tiny live-copy task module for the live-copy spec: a body is a list of
+// paragraphs, and anything else is refused rather than dropped. Paragraphs
+// and seed sources starting with "!" drive the failure cases.
+function paragraph(text) {
+    const element = new Y.XmlElement("paragraph");
+    const content = new Y.XmlText();
+    content.insert(0, text);
+    element.insert(0, [content]);
+    return element;
+}
+/** An update whose base this document never had. */
+function orphanUpdate() {
+    const elsewhere = new Y.Doc();
+    elsewhere.getXmlFragment("default").insert(0, [paragraph("unknown base")]);
+    const before = Y.encodeStateVector(elsewhere);
+    const fragment = elsewhere.getXmlFragment("default");
+    fragment.insert(1, [paragraph("orphan")]);
+    return Y.encodeStateAsUpdate(elsewhere, before);
+}
+export const tasks = defineLiveCopyTasks({
+    derive(doc, field) {
+        const lines = [];
+        for (const node of doc.getXmlFragment(field).toArray()) {
+            if (!(node instanceof Y.XmlElement) || node.nodeName !== "paragraph") {
+                return {
+                    kind: "refused",
+                    reason: "unsupported_node",
+                    detail: node instanceof Y.XmlElement ? node.nodeName : "text",
+                };
+            }
+            const text = node
+                .toArray()
+                .map((child) => child.toString())
+                .join("");
+            if (text === "!spin") {
+                for (;;) {
+                    // never returns
+                }
+            }
+            if (text === "!html")
+                return { kind: "html" };
+            if (text === "!edit")
+                doc.getXmlFragment(field).insert(0, [paragraph("")]);
+            if (text === "!park")
+                Y.applyUpdate(doc, orphanUpdate());
+            lines.push(text);
+        }
+        return lines.join("\n");
+    },
+    seed(doc, field, source) {
+        if (source === "!refuse")
+            return { kind: "refused", reason: "too_complex" };
+        if (source === "!empty")
+            return;
+        if (source === "!junk")
+            return { kind: "update" };
+        if (source === "!stray")
+            doc.getText("other").insert(0, "hidden");
+        doc.getXmlFragment(field).insert(0, source.split("\n").map(paragraph));
+    },
+    edits: {
+        append(doc, field, input) {
+            const fragment = doc.getXmlFragment(field);
+            const text = input?.text ?? "";
+            fragment.insert(fragment.length, [paragraph(text)]);
+        },
+        clear(doc, field) {
+            const fragment = doc.getXmlFragment(field);
+            fragment.delete(0, fragment.length);
+        },
+        stray(doc) {
+            doc.getText("other").insert(0, "hidden");
+        },
+        unchanged() { },
+        refuse() {
+            return { kind: "refused", reason: "too_complex" };
+        },
+        junk() {
+            return { kind: "update" };
+        },
+        dependent(doc) {
+            Y.applyUpdate(doc, orphanUpdate());
+        },
+        dependentAndValid(doc, field) {
+            Y.applyUpdate(doc, orphanUpdate());
+            const fragment = doc.getXmlFragment(field);
+            fragment.insert(fragment.length, [paragraph("valid")]);
+        },
+    },
+});

package/dist/collab/awareness.d.ts

@@ -38,19 +38,19 @@ export declare const postAwareness: import("h3").EventHandlerWithFetch<import("h
     error: string;
     states?: undefined;
 } | {
-    error?: undefined;
     states: {
         clientId: number;
         state: string;
     }[];
+    error?: undefined;
 }>>;
 export declare const getActiveUsers: import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
     error: string;
     users?: undefined;
 } | {
-    error?: undefined;
     users: {
         clientId: number;
         lastSeen: number;
     }[];
+    error?: undefined;
 }>>;

package/dist/collab/bounded-task-bundle.d.ts

@@ -0,0 +1,17 @@
+import { type BoundedTaskSource } from "./bounded-task-source.js";
+export interface BundleBoundedTaskSourceOptions {
+    /** Shown in errors and runner names. Defaults to the entry file's name. */
+    name?: string;
+    /** Extra esbuild `conditions` for package resolution. */
+    conditions?: string[];
+}
+export interface BundledBoundedTaskSource extends BoundedTaskSource {
+    /** Every file esbuild read, for watch-mode rebuilds. */
+    readonly inputs: readonly string[];
+}
+/**
+ * Bundles a task module and everything it imports into one script a worker
+ * can evaluate. The module must export `tasks`: an object of functions that
+ * take plain data and return plain data (or a Promise of it).
+ */
+export declare function bundleBoundedTaskSource(entry: string | URL, options?: BundleBoundedTaskSourceOptions): Promise<BundledBoundedTaskSource>;

package/dist/collab/bounded-task-bundle.js

@@ -0,0 +1,39 @@
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { BOUNDED_TASK_GLOBAL, } from "./bounded-task-source.js";
+/**
+ * Bundles a task module and everything it imports into one script a worker
+ * can evaluate. The module must export `tasks`: an object of functions that
+ * take plain data and return plain data (or a Promise of it).
+ */
+export async function bundleBoundedTaskSource(entry, options = {}) {
+    const entryPath = entry instanceof URL || entry.startsWith("file:")
+        ? fileURLToPath(entry)
+        : path.resolve(entry);
+    const esbuild = await import("esbuild");
+    const result = await esbuild.build({
+        entryPoints: [entryPath],
+        bundle: true,
+        write: false,
+        format: "iife",
+        globalName: BOUNDED_TASK_GLOBAL,
+        platform: "node",
+        target: "node20",
+        metafile: true,
+        sourcemap: false,
+        legalComments: "none",
+        logLevel: "silent",
+        ...(options.conditions ? { conditions: options.conditions } : {}),
+    });
+    const output = result.outputFiles?.[0];
+    if (!output) {
+        throw new Error(`esbuild produced no output for bounded task ${entryPath}`);
+    }
+    const cwd = process.cwd();
+    return {
+        kind: "bounded-task-source",
+        name: options.name ?? path.basename(entryPath).replace(/\.[^.]+$/, ""),
+        code: output.text,
+        inputs: Object.keys(result.metafile?.inputs ?? {}).map((input) => path.resolve(cwd, input)),
+    };
+}

package/dist/collab/bounded-task-source.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Identifier the bundled task module is assigned to. `bundleBoundedTaskSource`
+ * emits an IIFE with this global name; the worker host reads it back.
+ */
+export declare const BOUNDED_TASK_GLOBAL = "__agentNativeBoundedTasks";
+/**
+ * A self-contained task module, bundled to one script. Produce it with
+ * `bundleBoundedTaskSource` (Node, esbuild); never hand-write `code`.
+ */
+export interface BoundedTaskSource {
+    readonly kind: "bounded-task-source";
+    readonly name: string;
+    readonly code: string;
+}

package/dist/collab/bounded-task-source.js

@@ -0,0 +1,8 @@
+// The bundler and the vitest base config import this, not bounded-tasks.ts:
+// packages that typecheck @agent-native/core/vitest-config from source load
+// several @types/node versions, and node:worker_threads does not type there.
+/**
+ * Identifier the bundled task module is assigned to. `bundleBoundedTaskSource`
+ * emits an IIFE with this global name; the worker host reads it back.
+ */
+export const BOUNDED_TASK_GLOBAL = "__agentNativeBoundedTasks";

package/dist/collab/bounded-tasks.d.ts

@@ -0,0 +1,67 @@
+import { BOUNDED_TASK_GLOBAL, type BoundedTaskSource } from "./bounded-task-source.js";
+export { BOUNDED_TASK_GLOBAL, type BoundedTaskSource };
+export type BoundedTaskErrorCode = "unavailable" | "closed" | "queue_full" | "queue_timeout" | "invalid_input" | "input_too_large" | "startup_failed" | "task_unknown" | "task_threw" | "deadline_exceeded" | "memory_exceeded" | "invalid_output" | "output_too_large" | "worker_crashed";
+export declare class BoundedTaskError extends Error {
+    readonly code: BoundedTaskErrorCode;
+    readonly task: string;
+    /** `name` of the error the task threw, for `task_threw`. */
+    readonly taskErrorName?: string;
+    constructor(code: BoundedTaskErrorCode, task: string, message: string, options?: {
+        cause?: unknown;
+        taskErrorName?: string;
+    });
+}
+export interface BoundedTaskRunnerOptions {
+    source: BoundedTaskSource;
+    /** Wall-clock budget for one task once a worker has it. Default 2000 ms. */
+    deadlineMs?: number;
+    /** Budget for a fresh worker to evaluate the bundle. Default 10000 ms. */
+    startupTimeoutMs?: number;
+    /** Workers alive at once; also the number of tasks running at once. Default 1. */
+    maxWorkers?: number;
+    /** Tasks allowed to wait for a worker. Beyond this, `queue_full`. Default 8. */
+    maxQueue?: number;
+    /**
+     * Longest a task may wait for a busy or terminating worker. A task waiting
+     * only for a worker to start is bounded by `startupTimeoutMs` instead.
+     * Default `deadlineMs`.
+     */
+    queueTimeoutMs?: number;
+    /** Strings count two bytes per UTF-16 unit. Default 8 MiB. */
+    maxInputBytes?: number;
+    /** Checked inside the worker before the result is copied out. Default 16 MiB. */
+    maxOutputBytes?: number;
+    /** Worker old-generation heap. Default 128 MiB. */
+    memoryLimitMb?: number;
+    /** Default 4 MiB. */
+    stackSizeMb?: number;
+    /** An idle worker is stopped after this long. Default 30000 ms. */
+    idleTimeoutMs?: number;
+}
+export interface BoundedTaskRunnerStats {
+    workers: number;
+    running: number;
+    queued: number;
+}
+export interface BoundedTaskRunner {
+    readonly name: string;
+    run<Output = unknown>(task: string, input: unknown): Promise<Output>;
+    stats(): BoundedTaskRunnerStats;
+    close(): Promise<void>;
+}
+/**
+ * Size of a structured-clone payload in bytes, or -1 when it holds anything
+ * but plain data (or more than 200,000 values). Stops counting once
+ * `limit` is passed. The worker host evaluates this function's source, so it
+ * must not reference anything outside its own body.
+ */
+export declare function measureBoundedPayload(value: unknown, limit: number): number;
+/**
+ * Runs functions from one bundled module in worker threads, each under a
+ * terminable deadline and a heap limit, with a fixed number of workers and a
+ * bounded wait queue. A task that overruns is stopped by terminating its
+ * worker, so synchronous work in the task never blocks the caller's event
+ * loop. Where worker threads do not exist (Cloudflare Workers), every run
+ * fails with `unavailable`; it never falls back to running inline.
+ */
+export declare function createBoundedTaskRunner(options: BoundedTaskRunnerOptions): BoundedTaskRunner;