agentfootprint 9.46.3 → 9.48.0

package/dist/recipes/version.js

@@ -0,0 +1,89 @@
+"use strict";
+/**
+ * version — is this string a version, or something that looks like one?
+ *
+ * Pattern: a total predicate + a refusal sentence. Pure, no dependencies.
+ * Role:    recipes/ layer. Used by `defineAgentRecipe` and by the same
+ *          validation `AgentBuilder.recipe()` runs on a hand-written literal.
+ * Emits:   N/A.
+ *
+ * ## Why strict SemVer, and why a near-miss is refused rather than repaired
+ *
+ * The version is the half of a recipe row that makes the other half worth
+ * reading: two runs of `support-desk` that behaved differently are a mystery
+ * until the record says `1.2.0` and `1.3.0`. That only works if every producer
+ * spells versions the same way, so the ones that would quietly break grouping
+ * are refused at the declaration:
+ *
+ *   `'1.2'`      two runs, `'1.2'` and `'1.2.0'`, that are the same version and
+ *                do not group together.
+ *   `'v1.2.3'`   the same, with a decoration that sorts differently.
+ *   `'1.02.3'`   leading zeros: `'1.02.3'` and `'1.2.3'` again split one arm.
+ *   `'latest'`   a RANGE, not a version — it names whatever was installed, so
+ *   `'^1.2.3'`   the row would describe a different composition each week and
+ *   `'1.x'`      say nothing about the run it is stamped on.
+ *
+ * None is repaired. Padding `'1.2'` to `'1.2.0'` would put a version on the
+ * record that the author never wrote, which is the one thing a manifest field
+ * may not do.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.versionRefusal = exports.isSemverVersion = void 0;
+/**
+ * The official SemVer 2.0.0 grammar (semver.org, "Backus–Naur Form Grammar for
+ * Valid SemVer Versions"), transcribed. Kept verbatim rather than loosened: a
+ * home-grown `\d+\.\d+\.\d+` would accept `01.2.3` and reject `1.0.0-rc.1`,
+ * which is wrong in both directions.
+ */
+const SEMVER = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$/;
+/** Whether `value` is a SemVer 2.0.0 version string. Total: any input, no throw. */
+function isSemverVersion(value) {
+    return typeof value === 'string' && SEMVER.test(value);
+}
+exports.isSemverVersion = isSemverVersion;
+/**
+ * The sentence a bad version gets. Names the value, the grammar, and the
+ * specific mistake when the shape identifies one — a refusal that only says
+ * "invalid" makes the author guess which half was wrong.
+ *
+ * @param callSite - the API the author called, e.g. `defineAgentRecipe`.
+ */
+function versionRefusal(callSite, value) {
+    const shown = typeof value === 'string' ? `'${value}'` : `${typeof value}`;
+    return (`${callSite}: version ${shown} is not a version. A recipe's version must be SemVer 2.0.0 ` +
+        `— three dot-separated numbers, optionally a prerelease and build ('1.2.0', '2.0.0-rc.1', ` +
+        `'1.0.0+build.5').\n\n` +
+        `${diagnose(value)}\n\n` +
+        `Nothing is padded or stripped for you: the version is stamped on the run manifest, where ` +
+        `it is the field two runs are grouped by, and a value the author never wrote would group ` +
+        `runs that are not the same composition.`);
+}
+exports.versionRefusal = versionRefusal;
+/** The specific mistake, when the shape names one. Falls back to the general rule. */
+function diagnose(value) {
+    if (typeof value !== 'string') {
+        return `A version is a string; this was ${value === null ? 'null' : typeof value}.`;
+    }
+    if (value.trim() === '')
+        return 'This one is empty.';
+    if (/^v/i.test(value)) {
+        return `Drop the leading '${value[0] ?? 'v'}' — SemVer carries no prefix ('1.2.0', not '${value}').`;
+    }
+    if (/^\d+\.\d+$/.test(value)) {
+        return (`This has two parts; SemVer has three. Did you mean '${value}.0'? Write it out — ` +
+            `'${value}' and '${value}.0' would be two labels for one composition.`);
+    }
+    if (/^\d+$/.test(value)) {
+        return `This is one number. Did you mean '${value}.0.0'?`;
+    }
+    if (/^[~^><=]/.test(value) || /\bx\b|\*/.test(value)) {
+        return (`This is a RANGE, not a version. A range names whatever happens to be installed, so the ` +
+            `manifest row would describe a different composition each week. Write the version this ` +
+            `recipe IS.`);
+    }
+    if (/^0\d|\.0\d/.test(value)) {
+        return `Numeric parts carry no leading zeros ('1.2.0', not '01.02.00').`;
+    }
+    return `Neither the numbers, the prerelease nor the build metadata matched the grammar.`;
+}
+//# sourceMappingURL=version.js.map

package/dist/recipes/version.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"version.js","sourceRoot":"","sources":["../../src/recipes/version.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;;;AAEH;;;;;GAKG;AACH,MAAM,MAAM,GACV,qLAAqL,CAAC;AAExL,oFAAoF;AACpF,SAAgB,eAAe,CAAC,KAAc;IAC5C,OAAO,OAAO,KAAK,KAAK,QAAQ,IAAI,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;AACzD,CAAC;AAFD,0CAEC;AAED;;;;;;GAMG;AACH,SAAgB,cAAc,CAAC,QAAgB,EAAE,KAAc;IAC7D,MAAM,KAAK,GAAG,OAAO,KAAK,KAAK,QAAQ,CAAC,CAAC,CAAC,IAAI,KAAK,GAAG,CAAC,CAAC,CAAC,GAAG,OAAO,KAAK,EAAE,CAAC;IAC3E,OAAO,CACL,GAAG,QAAQ,aAAa,KAAK,6DAA6D;QAC1F,2FAA2F;QAC3F,uBAAuB;QACvB,GAAG,QAAQ,CAAC,KAAK,CAAC,MAAM;QACxB,2FAA2F;QAC3F,0FAA0F;QAC1F,yCAAyC,CAC1C,CAAC;AACJ,CAAC;AAXD,wCAWC;AAED,sFAAsF;AACtF,SAAS,QAAQ,CAAC,KAAc;IAC9B,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE,CAAC;QAC9B,OAAO,mCAAmC,KAAK,KAAK,IAAI,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,OAAO,KAAK,GAAG,CAAC;IACtF,CAAC;IACD,IAAI,KAAK,CAAC,IAAI,EAAE,KAAK,EAAE;QAAE,OAAO,oBAAoB,CAAC;IACrD,IAAI,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC;QACtB,OAAO,qBACL,KAAK,CAAC,CAAC,CAAC,IAAI,GACd,+CAA+C,KAAK,KAAK,CAAC;IAC5D,CAAC;IACD,IAAI,YAAY,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC;QAC7B,OAAO,CACL,uDAAuD,KAAK,sBAAsB;YAClF,IAAI,KAAK,UAAU,KAAK,8CAA8C,CACvE,CAAC;IACJ,CAAC;IACD,IAAI,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC;QACxB,OAAO,qCAAqC,KAAK,QAAQ,CAAC;IAC5D,CAAC;IACD,IAAI,UAAU,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,UAAU,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC;QACrD,OAAO,CACL,yFAAyF;YACzF,wFAAwF;YACxF,YAAY,CACb,CAAC;IACJ,CAAC;IACD,IAAI,YAAY,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC;QAC7B,OAAO,iEAAiE,CAAC;IAC3E,CAAC;IACD,OAAO,iFAAiF,CAAC;AAC3F,CAAC"}

package/dist/recorders/observability/fileRecordingSink.js

@@ -0,0 +1,201 @@
+"use strict";
+/**
+ * fileRecordingSink — one archived run, one JSON file, in a directory.
+ *
+ * The destination that needs nothing installed: an incident can be inspected
+ * with `ls` and `cat`, and a run archive is a folder you can tar. It is also
+ * the reference implementation of {@link RecordingSink} — a sink is one method,
+ * and this file is what "implement the other ones like this" points at.
+ *
+ * ## The file name is a key, and keys must be injective
+ *
+ * `runId` becomes a file name, which makes `runId ↦ name` a mapping used as a
+ * key: two different runs landing on one name means one archive silently
+ * overwrites another, and the evidence is gone with no error anywhere. So the
+ * mapping is `runId + '.json'` — appending a constant suffix, which is
+ * injective — over a DOMAIN that is asserted rather than assumed, and anything
+ * outside it is refused by name.
+ *
+ * The domain is `[a-z0-9]` followed by `[a-z0-9._-]*`, and every exclusion is
+ * load-bearing:
+ *
+ *   • **no uppercase.** This is the one that looks like fussiness and is not.
+ *     macOS/APFS and Windows/NTFS are case-INSENSITIVE by default, so `run-A`
+ *     and `run-a` are two distinct strings that name ONE file. A mapping that
+ *     is injective as a string can still collide as a file name, which is
+ *     exactly the bug artifacts/scopePath.ts found on a stock Mac in 9.44.0 —
+ *     its conformance battery had pairs for separators, absence markers and
+ *     pre-escaped values, and no pair differing only in case. Excluding
+ *     uppercase from the domain means no two valid ids differ by case alone, so
+ *     there is nothing for a case-folding filesystem to fold together.
+ *   • **no `/` or `\`.** A separator inside a field is separator donation: an
+ *     id containing one would silently become a path with a directory hop.
+ *   • **no leading `.` or `-`.** A leading dot hides the archive from `ls`; a
+ *     leading dash is read as a flag by every CLI tool that would then handle
+ *     it. Both are enforced by the first-character class.
+ *   • **no bare `.` / `..`.** Path navigation, not names.
+ *   • **length capped.** `NAME_MAX` is 255 on the common filesystems and the
+ *     suffixes here add to it.
+ *   • **no Windows reserved device names.** `con`, `nul`, `com1` … are devices
+ *     with OR without an extension: `con.json` opens the console, not a file.
+ *
+ * Ids this library mints all satisfy it: `makeRunId()` produces
+ * `run-<epoch ms>-<seq>` and the footprintjs engine produces
+ * `<epoch ms>-<padded counter>`. The assertion is there for the ids a CALLER
+ * states, which is the case that is neither controlled nor rare.
+ *
+ * ## Atomic, so a reader never sees half an archive
+ *
+ * The bytes go to a temporary file in the same directory and are then renamed
+ * into place. `rename` within one filesystem is atomic, so a crash mid-write
+ * leaves a `.tmp` nobody reads rather than a truncated `.json` that parses as
+ * far as it got — a half-written archive is the one failure a bug report cannot
+ * survive, because it looks like evidence.
+ *
+ * Writing the same `runId` twice REPLACES the file, atomically. That is the
+ * intended behaviour and worth stating: the run id is the archive's identity,
+ * so a second envelope for one run is a newer version of one archive (a partial
+ * crash dump later superseded by the finished run), not a second archive.
+ *
+ * Node-only. `node:fs` is reached through `lazyRequire`, the same law the other
+ * filesystem adapters follow, so importing the door costs a browser bundle
+ * nothing and constructing one where there is no filesystem refuses by name.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fileRecordingSink = exports.recordingFileName = exports.UnsafeRecordingIdError = void 0;
+const lazyRequire_js_1 = require("../../lib/lazyRequire.js");
+/** The archive file's extension. Also the tmp file's discriminator. */
+const ENVELOPE_EXTENSION = '.json';
+/** `NAME_MAX` is 255; leave room for the extension and the tmp suffix. */
+const MAX_RUN_ID_LENGTH = 200;
+/** Valid from the first character on — see the module header for each rule. */
+const SAFE_RUN_ID = /^[a-z0-9][a-z0-9._-]*$/;
+/**
+ * Reserved on Windows with any extension, so `con.json` is still the console.
+ * Checked against the whole id because the id IS the name's stem.
+ */
+const WINDOWS_RESERVED = new Set([
+    'con',
+    'prn',
+    'aux',
+    'nul',
+    ...Array.from({ length: 9 }, (_, i) => `com${String(i + 1)}`),
+    ...Array.from({ length: 9 }, (_, i) => `lpt${String(i + 1)}`),
+]);
+/**
+ * Raised when a run id cannot safely become a file name.
+ *
+ * Its own class because the fix is never a retry: the caller has to name the
+ * archive something a filesystem can hold one-to-one.
+ */
+class UnsafeRecordingIdError extends Error {
+    code = 'ERR_UNSAFE_RECORDING_ID';
+    runId;
+    constructor(runId, reason) {
+        super(`[recording-sink] run id ${JSON.stringify(runId)} cannot become a file name: ${reason}\n\n` +
+            `A file name is a key: if two runs can land on one name, one archive overwrites the ` +
+            `other and the evidence is gone with nothing raised anywhere. So the safe set is ` +
+            `asserted rather than hoped for — lowercase letters, digits, '.', '_' and '-', ` +
+            `starting with a letter or digit, at most ${String(MAX_RUN_ID_LENGTH)} characters. ` +
+            `(Uppercase is excluded because macOS and Windows fold case: 'run-A' and 'run-a' are ` +
+            `two ids and one file.) Either state a run.runId in that set, or write to a sink whose ` +
+            `keys are not file names.`);
+        this.name = 'UnsafeRecordingIdError';
+        this.runId = runId;
+    }
+}
+exports.UnsafeRecordingIdError = UnsafeRecordingIdError;
+/**
+ * The mapping under test: one run id → one file name, injectively.
+ *
+ * Exported so the collision battery can drive the mapping directly rather than
+ * inferring it from files on a disk.
+ *
+ * @throws {UnsafeRecordingIdError} for any id outside the safe domain.
+ */
+function recordingFileName(runId) {
+    if (typeof runId !== 'string' || runId === '') {
+        throw new UnsafeRecordingIdError(String(runId), 'it is not a non-empty string.');
+    }
+    if (runId.length > MAX_RUN_ID_LENGTH) {
+        throw new UnsafeRecordingIdError(runId, `it is ${String(runId.length)} characters; the limit is ${String(MAX_RUN_ID_LENGTH)}.`);
+    }
+    if (/[A-Z]/.test(runId)) {
+        throw new UnsafeRecordingIdError(runId, 'it contains uppercase letters, and case-insensitive filesystems (macOS, Windows) would ' +
+            'let it share a file with its lowercase twin.');
+    }
+    if (!SAFE_RUN_ID.test(runId)) {
+        throw new UnsafeRecordingIdError(runId, 'it must start with a lowercase letter or digit and contain only [a-z0-9._-] — path ' +
+            'separators, spaces and control characters are not names.');
+    }
+    if (/^\.+$/.test(runId)) {
+        throw new UnsafeRecordingIdError(runId, 'it is only dots, which is path navigation.');
+    }
+    if (WINDOWS_RESERVED.has(runId)) {
+        throw new UnsafeRecordingIdError(runId, `'${runId}' is a reserved device name on Windows, with or without an extension.`);
+    }
+    return `${runId}${ENVELOPE_EXTENSION}`;
+}
+exports.recordingFileName = recordingFileName;
+/** Process-local, so two sinks in one process cannot pick one tmp name. */
+let _tmpSeq = 0;
+/**
+ * A directory-backed recording sink — one JSON file per run, written atomically.
+ *
+ * @example
+ * ```ts
+ * const recorder = recordRun(agent);
+ * await agent.run({ message: 'hi' });
+ *
+ * await persistRecording(recorder, {
+ *   sink: fileRecordingSink({ directory: './run-archive' }),
+ *   run: { complete: true },
+ * });
+ * // → ./run-archive/run-1787093273110-1.json
+ * ```
+ */
+function fileRecordingSink(options) {
+    const directory = options?.directory;
+    if (typeof directory !== 'string' || directory.trim() === '') {
+        throw new TypeError(`[recording-sink] fileRecordingSink({ directory: ${JSON.stringify(directory)} }) names no ` +
+            `directory. Give it a path — it will be created if it does not exist.`);
+    }
+    const fs = (0, lazyRequire_js_1.lazyRequire)('node:fs');
+    const path = (0, lazyRequire_js_1.lazyRequire)('node:path');
+    fs.mkdirSync(directory, { recursive: true });
+    return {
+        async write(envelope) {
+            // Assert the name BEFORE serializing: a refusal should cost nothing, and
+            // an id that cannot be filed should not first be turned into megabytes.
+            const name = recordingFileName(envelope?.run?.runId);
+            const target = path.join(directory, name);
+            let text;
+            try {
+                text = `${JSON.stringify(envelope, null, 2)}\n`;
+            }
+            catch (cause) {
+                // A circular reference or a BigInt inside the recording. Refuse by
+                // name: the alternative is a file that exists and is not the run.
+                throw new TypeError(`[recording-sink] this recording cannot be written as JSON: ${cause instanceof Error ? cause.message : String(cause)}. A run's state must survive structuredClone to be recorded at all, so this ` +
+                    `normally means a value was put into state after the run (a circular object, a ` +
+                    `BigInt). Nothing was written — a partial archive would be worse than none.`);
+            }
+            // Same directory, so the rename is a same-filesystem move and therefore
+            // atomic. `.tmp` can never collide with an archive name: archives always
+            // end in `.json`, these always end in `.tmp`.
+            const tmp = path.join(directory, `${name}.${String(process.pid)}.${String(++_tmpSeq)}.tmp`);
+            try {
+                await fs.promises.writeFile(tmp, text, 'utf8');
+                await fs.promises.rename(tmp, target);
+            }
+            catch (cause) {
+                // Leave no half-written debris behind, but never mask the real error.
+                await fs.promises.rm(tmp, { force: true }).catch(() => undefined);
+                throw cause;
+            }
+            return { id: name, uri: `file://${path.resolve(target)}` };
+        },
+    };
+}
+exports.fileRecordingSink = fileRecordingSink;
+//# sourceMappingURL=fileRecordingSink.js.map

package/dist/recorders/observability/fileRecordingSink.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fileRecordingSink.js","sourceRoot":"","sources":["../../../src/recorders/observability/fileRecordingSink.ts"],"names":[],"mappings":"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"}