@sackville-mcp/artifacts 0.0.1-alpha.0

package/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or Derivative
+          Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2026 Curtis Autery
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/dist/index.d.mts

@@ -0,0 +1,125 @@
+//#region src/store.d.ts
+interface Artifact {
+  /** Absolute path of the artifact on disk. */
+  path: string;
+  contentType: string;
+  byteSize: number;
+  /** Hex SHA-256 of the bytes — lets a consumer verify/cache by content. */
+  sha256: string;
+  /**
+   * True when `contentType` could not be recovered (a legacy artifact rehydrated
+   * with no `<kind>.meta.json` sidecar) and was defaulted to
+   * `application/octet-stream` — never a silent failure (ADR 0013 §4).
+   */
+  contentTypeInferred?: boolean;
+}
+/**
+ * Bounds on a store's own `<baseDir>/<prefix>` subtree (ADR 0017). All optional; an
+ * unset dimension is not enforced, and a policy with no dimension set is a no-op (so
+ * a store with no retention NEVER deletes — fully backward-compatible).
+ */
+interface RetentionPolicy {
+  /** Evict `<id>` dirs whose mtime is older than `now - maxAgeMs`. */
+  maxAgeMs?: number;
+  /** Keep at most this many `<id>` dirs (newest by mtime). */
+  maxEntries?: number;
+  /** Keep the subtree's total bytes at or under this cap (evict oldest-first). */
+  maxBytes?: number;
+}
+/** A sane default throttle for the server bins' opportunistic `put()` sweep — a hot
+ * write loop re-scans the subtree at most once a minute, GC stays responsive enough. */
+declare const DEFAULT_SWEEP_INTERVAL_MS = 60000;
+interface ArtifactStoreOptions {
+  /** Retention bounds; absent ⇒ the store is append-only (no GC). */
+  retention?: RetentionPolicy;
+  /** Clock injection (testing / determinism). Default `Date.now`. */
+  now?: () => number;
+  /** Minimum ms between opportunistic `put()`-triggered sweeps. Default 0 (every put). */
+  sweepIntervalMs?: number;
+}
+/**
+ * Parse a `RetentionPolicy` from raw env strings (each bin's per-pillar
+ * `SACKVILLE_<PILLAR>_ARTIFACT_MAX_AGE_MS` / `_MAX_ENTRIES` / `_MAX_BYTES`). Returns
+ * `undefined` when NONE is set (⇒ no GC — opt-in). A non-numeric or negative value is
+ * ignored (treated as unset) so a typo never silently deletes everything.
+ */
+declare function retentionFromEnv(raw: {
+  maxAgeMs?: string;
+  maxEntries?: string;
+  maxBytes?: string;
+}): RetentionPolicy | undefined;
+/**
+ * On-disk-backed store for verification artifacts (traces, screenshots, video,
+ * HAR, audit reports, changelog diffs, coverage reports…), addressed by a
+ * `sackville://<prefix>/<id>/<kind>` handle. Artifacts are large/binary, so they
+ * are written to disk and returned by handle — never inlined into a tool result.
+ *
+ * The handle `prefix` is **parameterized** so each pillar emits its own handle
+ * space over one shared store (`browser/run` → `sackville://browser/run/<id>/<kind>`;
+ * `deps` → `sackville://deps/<id>/<kind>`). Extracted from the browser pillar per
+ * ADR 0010; a persistent/remote backend can replace this later — the handle
+ * contract stays the same.
+ *
+ * The on-disk layout is `<baseDir>/<prefix>/<id>/<kind>` — the prefix lives IN the
+ * path (ADR 0013 slice 1), so one shared `baseDir` is collision-free across pillars
+ * and a store can **rehydrate a foreign-prefix handle** it never `put()` itself
+ * (the cross-pillar verify read). Because a rehydrate is a filesystem read
+ * addressed by an agent-supplied string, every segment is allowlist-validated and
+ * the resolved path is realpath-confined under `baseDir`.
+ */
+declare class ArtifactStore {
+  private readonly baseDir;
+  private readonly prefix;
+  private artifacts;
+  /**
+   * @param baseDir on-disk root for stored artifact bytes (created if absent).
+   * @param prefix the handle namespace between `sackville://` and `/<id>/<kind>`
+   *   (may contain `/`, e.g. `browser/run`); each segment must be a safe segment.
+   */
+  private readonly retention?;
+  private readonly now;
+  private readonly sweepIntervalMs;
+  private lastSweepAt;
+  constructor(baseDir: string, prefix: string, opts?: ArtifactStoreOptions);
+  /** The handle a (`runId`, `kind`) pair maps to — reconstruct without re-storing. */
+  handleFor(runId: string, kind: string): string;
+  /** Persist `body` under run `runId` as artifact `kind`; returns its handle. */
+  put(runId: string, kind: string, body: string | Buffer, contentType: string): string;
+  private hasPolicy;
+  /** Opportunistic, THROTTLED sweep after a write (ADR 0017): at most once per
+   * `sweepIntervalMs` so a hot write loop doesn't re-scan the subtree every put. */
+  private maybeSweep;
+  /**
+   * Evict `<id>` dirs under THIS store's own `<baseDir>/<prefix>` subtree per the
+   * `RetentionPolicy` — age (`maxAgeMs`) then count (`maxEntries`) then size
+   * (`maxBytes`), oldest-first by dir mtime (so a just-written run is evicted last).
+   * Disk-based (a cold process's in-process map is empty), confinement-checked before
+   * every delete (never deletes THROUGH a symlink escaping `baseDir`), and a no-op when
+   * no policy is set. Returns the evicted ids. Public so a bin can sweep on startup.
+   */
+  sweep(nowMs?: number): string[];
+  /** Forget the in-process handles of an evicted id, so a later `get()` misses → disk
+   * (also gone) → `undefined`, never a read of a deleted path. */
+  private dropHandles;
+  /**
+   * Resolve a handle to its metadata + bytes, or `undefined` if no such artifact
+   * exists. A handle this store `put()` resolves from the in-process map; any other
+   * well-formed handle is **rehydrated from disk** by its own prefix/id/kind.
+   * Throws on a malformed/unsafe handle (a traversal or separator in a segment).
+   */
+  get(handle: string): (Artifact & {
+    body: Buffer;
+  }) | undefined;
+  /** Parse `sackville://<prefix>/<id>/<kind>`; validate every segment. */
+  private parseHandle;
+  private readSidecar;
+  /**
+   * Realpath-confine `path` under `baseDir` — defends against a symlinked
+   * prefix/id dir escaping the store root even though every segment is allowlisted
+   * (the same realpath posture the LSP write-mode confinement uses).
+   */
+  private assertConfined;
+}
+//#endregion
+export { type Artifact, ArtifactStore, type ArtifactStoreOptions, DEFAULT_SWEEP_INTERVAL_MS, type RetentionPolicy, retentionFromEnv };
+//# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/store.ts"],"mappings":";UAaiB,QAAA;EAAA;EAEf,IAAA;EACA,WAAA;EACA,QAAA;EAFA;EAIA,MAAA;EAFA;;;;AAQmB;EAAnB,mBAAA;AAAA;;;;;;UAQe,eAAA;EAMP;EAJR,QAAA;EASoC;EAPpC,UAAA;EAOoC;EALpC,QAAA;AAAA;;;cAKW,yBAAA;AAAA,UAEI,oBAAA;EAEH;EAAZ,SAAA,GAAY,eAAe;EAI3B;EAFA,GAAA;EAEe;EAAf,eAAA;AAAA;;;;;;;iBASc,gBAAA,CAAiB,GAAA;EAC/B,QAAA;EACA,UAAA;EACA,QAAA;AAAA,IACE,eAAe;;;;;;;;;;;;;;;;;;;;cA2DN,aAAA;EAAA,iBAcQ,OAAA;EAAA,iBACA,MAAA;EAAA,QAdX,SAAA;EA8BJ;;;;;EAAA,iBAvBa,SAAA;EAAA,iBACA,GAAA;EAAA,iBACA,eAAA;EAAA,QACT,WAAA;cAGW,OAAA,UACA,MAAA,UACjB,IAAA,GAAM,oBAAA;EA0IR;EAhIA,SAAA,CAAU,KAAA,UAAe,IAAA;EAgIH;EA3HtB,GAAA,CAAI,KAAA,UAAe,IAAA,UAAc,IAAA,WAAe,MAAA,EAAQ,WAAA;EAAA,QAuBhD,SAAA;EAyHA;;EAAA,QAhHA,UAAA;EAiJc;AAAA;;;;;;;EAjItB,KAAA,CAAM,KAAA;;;UAgEE,WAAA;;;;;;;EAWR,GAAA,CAAI,MAAA,YAAkB,QAAA;IAAa,IAAA,EAAM,MAAA;EAAA;;UAqBjC,WAAA;EAAA,QAaA,WAAA;;;;;;UAoBA,cAAA;AAAA"}

package/dist/index.mjs

@@ -0,0 +1,262 @@
+import { createHash } from "node:crypto";
+import { existsSync, mkdirSync, readFileSync, readdirSync, realpathSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { join, sep } from "node:path";
+//#region src/store.ts
+/** A sane default throttle for the server bins' opportunistic `put()` sweep — a hot
+* write loop re-scans the subtree at most once a minute, GC stays responsive enough. */
+const DEFAULT_SWEEP_INTERVAL_MS = 6e4;
+/**
+* Parse a `RetentionPolicy` from raw env strings (each bin's per-pillar
+* `SACKVILLE_<PILLAR>_ARTIFACT_MAX_AGE_MS` / `_MAX_ENTRIES` / `_MAX_BYTES`). Returns
+* `undefined` when NONE is set (⇒ no GC — opt-in). A non-numeric or negative value is
+* ignored (treated as unset) so a typo never silently deletes everything.
+*/
+function retentionFromEnv(raw) {
+	const n = (v) => {
+		if (!v) return void 0;
+		const x = Number(v);
+		return Number.isFinite(x) && x >= 0 ? x : void 0;
+	};
+	const policy = {};
+	const age = n(raw.maxAgeMs);
+	const entries = n(raw.maxEntries);
+	const bytes = n(raw.maxBytes);
+	if (age !== void 0) policy.maxAgeMs = age;
+	if (entries !== void 0) policy.maxEntries = entries;
+	if (bytes !== void 0) policy.maxBytes = bytes;
+	return Object.keys(policy).length > 0 ? policy : void 0;
+}
+/**
+* A single safe path segment: an agent-supplied `id`/`kind` (or a prefix segment
+* parsed out of a foreign handle) may only contain these characters and is never
+* `.`/`..` — so it cannot traverse, separate, or escape. Mirrors the `safeId`
+* allowlist the deps surface uses (`packages/mcp/src/deps.ts`).
+*/
+function isSafeSegment(value) {
+	return value.length > 0 && value !== "." && value !== ".." && /^[A-Za-z0-9._-]+$/.test(value);
+}
+function assertSafeSegment(value, what) {
+	if (!isSafeSegment(value)) throw new Error(`ArtifactStore: unsafe ${what} segment ${JSON.stringify(value)}`);
+}
+/**
+* On-disk-backed store for verification artifacts (traces, screenshots, video,
+* HAR, audit reports, changelog diffs, coverage reports…), addressed by a
+* `sackville://<prefix>/<id>/<kind>` handle. Artifacts are large/binary, so they
+* are written to disk and returned by handle — never inlined into a tool result.
+*
+* The handle `prefix` is **parameterized** so each pillar emits its own handle
+* space over one shared store (`browser/run` → `sackville://browser/run/<id>/<kind>`;
+* `deps` → `sackville://deps/<id>/<kind>`). Extracted from the browser pillar per
+* ADR 0010; a persistent/remote backend can replace this later — the handle
+* contract stays the same.
+*
+* The on-disk layout is `<baseDir>/<prefix>/<id>/<kind>` — the prefix lives IN the
+* path (ADR 0013 slice 1), so one shared `baseDir` is collision-free across pillars
+* and a store can **rehydrate a foreign-prefix handle** it never `put()` itself
+* (the cross-pillar verify read). Because a rehydrate is a filesystem read
+* addressed by an agent-supplied string, every segment is allowlist-validated and
+* the resolved path is realpath-confined under `baseDir`.
+*/
+var ArtifactStore = class {
+	baseDir;
+	prefix;
+	artifacts = /* @__PURE__ */ new Map();
+	/**
+	* @param baseDir on-disk root for stored artifact bytes (created if absent).
+	* @param prefix the handle namespace between `sackville://` and `/<id>/<kind>`
+	*   (may contain `/`, e.g. `browser/run`); each segment must be a safe segment.
+	*/
+	retention;
+	now;
+	sweepIntervalMs;
+	lastSweepAt = Number.NEGATIVE_INFINITY;
+	constructor(baseDir, prefix, opts = {}) {
+		this.baseDir = baseDir;
+		this.prefix = prefix;
+		for (const seg of prefix.split("/")) assertSafeSegment(seg, "prefix");
+		mkdirSync(baseDir, { recursive: true });
+		this.retention = opts.retention;
+		this.now = opts.now ?? Date.now;
+		this.sweepIntervalMs = opts.sweepIntervalMs ?? 0;
+	}
+	/** The handle a (`runId`, `kind`) pair maps to — reconstruct without re-storing. */
+	handleFor(runId, kind) {
+		return `sackville://${this.prefix}/${runId}/${kind}`;
+	}
+	/** Persist `body` under run `runId` as artifact `kind`; returns its handle. */
+	put(runId, kind, body, contentType) {
+		assertSafeSegment(runId, "id");
+		assertSafeSegment(kind, "kind");
+		const handle = this.handleFor(runId, kind);
+		const buf = typeof body === "string" ? Buffer.from(body, "utf8") : body;
+		const dir = join(this.baseDir, this.prefix, runId);
+		mkdirSync(dir, { recursive: true });
+		this.assertConfined(dir);
+		const path = join(dir, kind);
+		writeFileSync(path, buf);
+		writeFileSync(`${path}.meta.json`, JSON.stringify({ contentType }));
+		this.artifacts.set(handle, {
+			path,
+			contentType,
+			byteSize: buf.byteLength,
+			sha256: createHash("sha256").update(buf).digest("hex")
+		});
+		this.maybeSweep();
+		return handle;
+	}
+	hasPolicy() {
+		const r = this.retention;
+		return !!r && (r.maxAgeMs !== void 0 || r.maxEntries !== void 0 || r.maxBytes !== void 0);
+	}
+	/** Opportunistic, THROTTLED sweep after a write (ADR 0017): at most once per
+	* `sweepIntervalMs` so a hot write loop doesn't re-scan the subtree every put. */
+	maybeSweep() {
+		if (!this.hasPolicy()) return;
+		const t = this.now();
+		if (t - this.lastSweepAt < this.sweepIntervalMs) return;
+		this.lastSweepAt = t;
+		this.sweep(t);
+	}
+	/**
+	* Evict `<id>` dirs under THIS store's own `<baseDir>/<prefix>` subtree per the
+	* `RetentionPolicy` — age (`maxAgeMs`) then count (`maxEntries`) then size
+	* (`maxBytes`), oldest-first by dir mtime (so a just-written run is evicted last).
+	* Disk-based (a cold process's in-process map is empty), confinement-checked before
+	* every delete (never deletes THROUGH a symlink escaping `baseDir`), and a no-op when
+	* no policy is set. Returns the evicted ids. Public so a bin can sweep on startup.
+	*/
+	sweep(nowMs = this.now()) {
+		if (!this.hasPolicy()) return [];
+		const root = join(this.baseDir, this.prefix);
+		if (!existsSync(root)) return [];
+		const r = this.retention;
+		const entries = [];
+		for (const d of readdirSync(root, { withFileTypes: true })) {
+			if (!d.isDirectory()) continue;
+			const dir = join(root, d.name);
+			try {
+				const st = statSync(dir);
+				let bytes = 0;
+				for (const f of readdirSync(dir, { withFileTypes: true })) if (f.isFile()) bytes += statSync(join(dir, f.name)).size;
+				entries.push({
+					id: d.name,
+					dir,
+					mtimeMs: st.mtimeMs,
+					bytes
+				});
+			} catch {}
+		}
+		const evict = /* @__PURE__ */ new Set();
+		if (r.maxAgeMs !== void 0) {
+			const cut = nowMs - r.maxAgeMs;
+			for (const e of entries) if (e.mtimeMs < cut) evict.add(e.id);
+		}
+		let kept = entries.filter((e) => !evict.has(e.id)).sort((a, b) => b.mtimeMs - a.mtimeMs);
+		if (r.maxEntries !== void 0 && kept.length > r.maxEntries) {
+			for (const e of kept.slice(r.maxEntries)) evict.add(e.id);
+			kept = kept.slice(0, r.maxEntries);
+		}
+		if (r.maxBytes !== void 0) {
+			let total = 0;
+			for (const e of kept) {
+				total += e.bytes;
+				if (total > r.maxBytes) evict.add(e.id);
+			}
+		}
+		const evicted = [];
+		for (const e of entries) {
+			if (!evict.has(e.id)) continue;
+			try {
+				this.assertConfined(e.dir);
+			} catch {
+				continue;
+			}
+			rmSync(e.dir, {
+				recursive: true,
+				force: true
+			});
+			this.dropHandles(e.id);
+			evicted.push(e.id);
+		}
+		return evicted;
+	}
+	/** Forget the in-process handles of an evicted id, so a later `get()` misses → disk
+	* (also gone) → `undefined`, never a read of a deleted path. */
+	dropHandles(id) {
+		const p = `sackville://${this.prefix}/${id}/`;
+		for (const key of this.artifacts.keys()) if (key.startsWith(p)) this.artifacts.delete(key);
+	}
+	/**
+	* Resolve a handle to its metadata + bytes, or `undefined` if no such artifact
+	* exists. A handle this store `put()` resolves from the in-process map; any other
+	* well-formed handle is **rehydrated from disk** by its own prefix/id/kind.
+	* Throws on a malformed/unsafe handle (a traversal or separator in a segment).
+	*/
+	get(handle) {
+		const meta = this.artifacts.get(handle);
+		if (meta) return {
+			...meta,
+			body: readFileSync(meta.path)
+		};
+		const { prefix, id, kind } = this.parseHandle(handle);
+		const path = join(this.baseDir, prefix, id, kind);
+		if (!existsSync(path)) return void 0;
+		this.assertConfined(path);
+		const buf = readFileSync(path);
+		const { contentType, contentTypeInferred } = this.readSidecar(path);
+		return {
+			path,
+			contentType,
+			contentTypeInferred,
+			byteSize: buf.byteLength,
+			sha256: createHash("sha256").update(buf).digest("hex"),
+			body: buf
+		};
+	}
+	/** Parse `sackville://<prefix>/<id>/<kind>`; validate every segment. */
+	parseHandle(handle) {
+		const rest = handle.startsWith("sackville://") ? handle.slice(12) : void 0;
+		if (rest === void 0) throw new Error(`ArtifactStore: not a sackville:// handle: ${handle}`);
+		const parts = rest.split("/");
+		if (parts.length < 3) throw new Error(`ArtifactStore: malformed handle: ${handle}`);
+		const kind = parts.pop();
+		const id = parts.pop();
+		assertSafeSegment(id, "id");
+		assertSafeSegment(kind, "kind");
+		for (const seg of parts) assertSafeSegment(seg, "prefix");
+		return {
+			prefix: parts.join("/"),
+			id,
+			kind
+		};
+	}
+	readSidecar(path) {
+		const sidecar = `${path}.meta.json`;
+		if (!existsSync(sidecar)) return {
+			contentType: "application/octet-stream",
+			contentTypeInferred: true
+		};
+		try {
+			const parsed = JSON.parse(readFileSync(sidecar, "utf8"));
+			if (typeof parsed.contentType === "string" && parsed.contentType.length > 0) return { contentType: parsed.contentType };
+		} catch {}
+		return {
+			contentType: "application/octet-stream",
+			contentTypeInferred: true
+		};
+	}
+	/**
+	* Realpath-confine `path` under `baseDir` — defends against a symlinked
+	* prefix/id dir escaping the store root even though every segment is allowlisted
+	* (the same realpath posture the LSP write-mode confinement uses).
+	*/
+	assertConfined(path) {
+		const root = realpathSync(this.baseDir);
+		const resolved = realpathSync(path);
+		if (resolved !== root && !resolved.startsWith(root + sep)) throw new Error(`ArtifactStore: path escapes baseDir: ${path}`);
+	}
+};
+//#endregion
+export { ArtifactStore, DEFAULT_SWEEP_INTERVAL_MS, retentionFromEnv };
+
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../src/store.ts"],"sourcesContent":["import { createHash } from 'node:crypto'\nimport {\n  existsSync,\n  mkdirSync,\n  readdirSync,\n  readFileSync,\n  realpathSync,\n  rmSync,\n  statSync,\n  writeFileSync,\n} from 'node:fs'\nimport { join, sep } from 'node:path'\n\nexport interface Artifact {\n  /** Absolute path of the artifact on disk. */\n  path: string\n  contentType: string\n  byteSize: number\n  /** Hex SHA-256 of the bytes — lets a consumer verify/cache by content. */\n  sha256: string\n  /**\n   * True when `contentType` could not be recovered (a legacy artifact rehydrated\n   * with no `<kind>.meta.json` sidecar) and was defaulted to\n   * `application/octet-stream` — never a silent failure (ADR 0013 §4).\n   */\n  contentTypeInferred?: boolean\n}\n\n/**\n * Bounds on a store's own `<baseDir>/<prefix>` subtree (ADR 0017). All optional; an\n * unset dimension is not enforced, and a policy with no dimension set is a no-op (so\n * a store with no retention NEVER deletes — fully backward-compatible).\n */\nexport interface RetentionPolicy {\n  /** Evict `<id>` dirs whose mtime is older than `now - maxAgeMs`. */\n  maxAgeMs?: number\n  /** Keep at most this many `<id>` dirs (newest by mtime). */\n  maxEntries?: number\n  /** Keep the subtree's total bytes at or under this cap (evict oldest-first). */\n  maxBytes?: number\n}\n\n/** A sane default throttle for the server bins' opportunistic `put()` sweep — a hot\n * write loop re-scans the subtree at most once a minute, GC stays responsive enough. */\nexport const DEFAULT_SWEEP_INTERVAL_MS = 60_000\n\nexport interface ArtifactStoreOptions {\n  /** Retention bounds; absent ⇒ the store is append-only (no GC). */\n  retention?: RetentionPolicy\n  /** Clock injection (testing / determinism). Default `Date.now`. */\n  now?: () => number\n  /** Minimum ms between opportunistic `put()`-triggered sweeps. Default 0 (every put). */\n  sweepIntervalMs?: number\n}\n\n/**\n * Parse a `RetentionPolicy` from raw env strings (each bin's per-pillar\n * `SACKVILLE_<PILLAR>_ARTIFACT_MAX_AGE_MS` / `_MAX_ENTRIES` / `_MAX_BYTES`). Returns\n * `undefined` when NONE is set (⇒ no GC — opt-in). A non-numeric or negative value is\n * ignored (treated as unset) so a typo never silently deletes everything.\n */\nexport function retentionFromEnv(raw: {\n  maxAgeMs?: string\n  maxEntries?: string\n  maxBytes?: string\n}): RetentionPolicy | undefined {\n  const n = (v: string | undefined): number | undefined => {\n    if (!v) return undefined\n    const x = Number(v)\n    return Number.isFinite(x) && x >= 0 ? x : undefined\n  }\n  const policy: RetentionPolicy = {}\n  const age = n(raw.maxAgeMs)\n  const entries = n(raw.maxEntries)\n  const bytes = n(raw.maxBytes)\n  if (age !== undefined) policy.maxAgeMs = age\n  if (entries !== undefined) policy.maxEntries = entries\n  if (bytes !== undefined) policy.maxBytes = bytes\n  return Object.keys(policy).length > 0 ? policy : undefined\n}\n\n/** A handle parsed into its on-disk-addressing parts. */\ninterface ParsedHandle {\n  /** The handle namespace (may contain `/`, e.g. `browser/run`). */\n  prefix: string\n  id: string\n  kind: string\n}\n\n/**\n * A single safe path segment: an agent-supplied `id`/`kind` (or a prefix segment\n * parsed out of a foreign handle) may only contain these characters and is never\n * `.`/`..` — so it cannot traverse, separate, or escape. Mirrors the `safeId`\n * allowlist the deps surface uses (`packages/mcp/src/deps.ts`).\n */\nfunction isSafeSegment(value: string): boolean {\n  return value.length > 0 && value !== '.' && value !== '..' && /^[A-Za-z0-9._-]+$/.test(value)\n}\n\nfunction assertSafeSegment(value: string, what: string): void {\n  if (!isSafeSegment(value)) {\n    throw new Error(`ArtifactStore: unsafe ${what} segment ${JSON.stringify(value)}`)\n  }\n}\n\n/**\n * On-disk-backed store for verification artifacts (traces, screenshots, video,\n * HAR, audit reports, changelog diffs, coverage reports…), addressed by a\n * `sackville://<prefix>/<id>/<kind>` handle. Artifacts are large/binary, so they\n * are written to disk and returned by handle — never inlined into a tool result.\n *\n * The handle `prefix` is **parameterized** so each pillar emits its own handle\n * space over one shared store (`browser/run` → `sackville://browser/run/<id>/<kind>`;\n * `deps` → `sackville://deps/<id>/<kind>`). Extracted from the browser pillar per\n * ADR 0010; a persistent/remote backend can replace this later — the handle\n * contract stays the same.\n *\n * The on-disk layout is `<baseDir>/<prefix>/<id>/<kind>` — the prefix lives IN the\n * path (ADR 0013 slice 1), so one shared `baseDir` is collision-free across pillars\n * and a store can **rehydrate a foreign-prefix handle** it never `put()` itself\n * (the cross-pillar verify read). Because a rehydrate is a filesystem read\n * addressed by an agent-supplied string, every segment is allowlist-validated and\n * the resolved path is realpath-confined under `baseDir`.\n */\nexport class ArtifactStore {\n  private artifacts = new Map<string, Artifact>()\n\n  /**\n   * @param baseDir on-disk root for stored artifact bytes (created if absent).\n   * @param prefix the handle namespace between `sackville://` and `/<id>/<kind>`\n   *   (may contain `/`, e.g. `browser/run`); each segment must be a safe segment.\n   */\n  private readonly retention?: RetentionPolicy\n  private readonly now: () => number\n  private readonly sweepIntervalMs: number\n  private lastSweepAt = Number.NEGATIVE_INFINITY\n\n  constructor(\n    private readonly baseDir: string,\n    private readonly prefix: string,\n    opts: ArtifactStoreOptions = {},\n  ) {\n    for (const seg of prefix.split('/')) assertSafeSegment(seg, 'prefix')\n    mkdirSync(baseDir, { recursive: true })\n    this.retention = opts.retention\n    this.now = opts.now ?? Date.now\n    this.sweepIntervalMs = opts.sweepIntervalMs ?? 0\n  }\n\n  /** The handle a (`runId`, `kind`) pair maps to — reconstruct without re-storing. */\n  handleFor(runId: string, kind: string): string {\n    return `sackville://${this.prefix}/${runId}/${kind}`\n  }\n\n  /** Persist `body` under run `runId` as artifact `kind`; returns its handle. */\n  put(runId: string, kind: string, body: string | Buffer, contentType: string): string {\n    assertSafeSegment(runId, 'id')\n    assertSafeSegment(kind, 'kind')\n    const handle = this.handleFor(runId, kind)\n    const buf = typeof body === 'string' ? Buffer.from(body, 'utf8') : body\n    const dir = join(this.baseDir, this.prefix, runId)\n    mkdirSync(dir, { recursive: true })\n    this.assertConfined(dir)\n    const path = join(dir, kind)\n    writeFileSync(path, buf)\n    // Sidecar so a cold-process rehydrate recovers contentType (not inferable\n    // from raw bytes). One per artifact: `<kind>.meta.json`.\n    writeFileSync(`${path}.meta.json`, JSON.stringify({ contentType }))\n    this.artifacts.set(handle, {\n      path,\n      contentType,\n      byteSize: buf.byteLength,\n      sha256: createHash('sha256').update(buf).digest('hex'),\n    })\n    this.maybeSweep()\n    return handle\n  }\n\n  private hasPolicy(): boolean {\n    const r = this.retention\n    return (\n      !!r && (r.maxAgeMs !== undefined || r.maxEntries !== undefined || r.maxBytes !== undefined)\n    )\n  }\n\n  /** Opportunistic, THROTTLED sweep after a write (ADR 0017): at most once per\n   * `sweepIntervalMs` so a hot write loop doesn't re-scan the subtree every put. */\n  private maybeSweep(): void {\n    if (!this.hasPolicy()) return\n    const t = this.now()\n    if (t - this.lastSweepAt < this.sweepIntervalMs) return\n    this.lastSweepAt = t\n    this.sweep(t)\n  }\n\n  /**\n   * Evict `<id>` dirs under THIS store's own `<baseDir>/<prefix>` subtree per the\n   * `RetentionPolicy` — age (`maxAgeMs`) then count (`maxEntries`) then size\n   * (`maxBytes`), oldest-first by dir mtime (so a just-written run is evicted last).\n   * Disk-based (a cold process's in-process map is empty), confinement-checked before\n   * every delete (never deletes THROUGH a symlink escaping `baseDir`), and a no-op when\n   * no policy is set. Returns the evicted ids. Public so a bin can sweep on startup.\n   */\n  sweep(nowMs: number = this.now()): string[] {\n    if (!this.hasPolicy()) return []\n    const root = join(this.baseDir, this.prefix)\n    if (!existsSync(root)) return []\n    const r = this.retention as RetentionPolicy\n\n    interface Entry {\n      id: string\n      dir: string\n      mtimeMs: number\n      bytes: number\n    }\n    const entries: Entry[] = []\n    for (const d of readdirSync(root, { withFileTypes: true })) {\n      if (!d.isDirectory()) continue\n      const dir = join(root, d.name)\n      try {\n        const st = statSync(dir)\n        let bytes = 0\n        for (const f of readdirSync(dir, { withFileTypes: true })) {\n          if (f.isFile()) bytes += statSync(join(dir, f.name)).size\n        }\n        entries.push({ id: d.name, dir, mtimeMs: st.mtimeMs, bytes })\n      } catch {\n        // a racing delete / unreadable entry — skip it this pass\n      }\n    }\n\n    const evict = new Set<string>()\n    if (r.maxAgeMs !== undefined) {\n      const cut = nowMs - r.maxAgeMs\n      for (const e of entries) if (e.mtimeMs < cut) evict.add(e.id)\n    }\n    // Newest-first survivors drive the count + size caps (oldest evicted first).\n    let kept = entries.filter((e) => !evict.has(e.id)).sort((a, b) => b.mtimeMs - a.mtimeMs)\n    if (r.maxEntries !== undefined && kept.length > r.maxEntries) {\n      for (const e of kept.slice(r.maxEntries)) evict.add(e.id)\n      kept = kept.slice(0, r.maxEntries)\n    }\n    if (r.maxBytes !== undefined) {\n      let total = 0\n      for (const e of kept) {\n        total += e.bytes\n        if (total > r.maxBytes) evict.add(e.id)\n      }\n    }\n\n    const evicted: string[] = []\n    for (const e of entries) {\n      if (!evict.has(e.id)) continue\n      try {\n        this.assertConfined(e.dir) // never delete THROUGH a symlink escaping baseDir\n      } catch {\n        continue\n      }\n      rmSync(e.dir, { recursive: true, force: true })\n      this.dropHandles(e.id)\n      evicted.push(e.id)\n    }\n    return evicted\n  }\n\n  /** Forget the in-process handles of an evicted id, so a later `get()` misses → disk\n   * (also gone) → `undefined`, never a read of a deleted path. */\n  private dropHandles(id: string): void {\n    const p = `sackville://${this.prefix}/${id}/`\n    for (const key of this.artifacts.keys()) if (key.startsWith(p)) this.artifacts.delete(key)\n  }\n\n  /**\n   * Resolve a handle to its metadata + bytes, or `undefined` if no such artifact\n   * exists. A handle this store `put()` resolves from the in-process map; any other\n   * well-formed handle is **rehydrated from disk** by its own prefix/id/kind.\n   * Throws on a malformed/unsafe handle (a traversal or separator in a segment).\n   */\n  get(handle: string): (Artifact & { body: Buffer }) | undefined {\n    const meta = this.artifacts.get(handle)\n    if (meta) return { ...meta, body: readFileSync(meta.path) }\n\n    const { prefix, id, kind } = this.parseHandle(handle)\n    const path = join(this.baseDir, prefix, id, kind)\n    if (!existsSync(path)) return undefined\n    this.assertConfined(path)\n    const buf = readFileSync(path)\n    const { contentType, contentTypeInferred } = this.readSidecar(path)\n    return {\n      path,\n      contentType,\n      contentTypeInferred,\n      byteSize: buf.byteLength,\n      sha256: createHash('sha256').update(buf).digest('hex'),\n      body: buf,\n    }\n  }\n\n  /** Parse `sackville://<prefix>/<id>/<kind>`; validate every segment. */\n  private parseHandle(handle: string): ParsedHandle {\n    const rest = handle.startsWith('sackville://') ? handle.slice('sackville://'.length) : undefined\n    if (rest === undefined) throw new Error(`ArtifactStore: not a sackville:// handle: ${handle}`)\n    const parts = rest.split('/')\n    if (parts.length < 3) throw new Error(`ArtifactStore: malformed handle: ${handle}`)\n    const kind = parts.pop() as string\n    const id = parts.pop() as string\n    assertSafeSegment(id, 'id')\n    assertSafeSegment(kind, 'kind')\n    for (const seg of parts) assertSafeSegment(seg, 'prefix')\n    return { prefix: parts.join('/'), id, kind }\n  }\n\n  private readSidecar(path: string): { contentType: string; contentTypeInferred?: boolean } {\n    const sidecar = `${path}.meta.json`\n    if (!existsSync(sidecar))\n      return { contentType: 'application/octet-stream', contentTypeInferred: true }\n    try {\n      const parsed = JSON.parse(readFileSync(sidecar, 'utf8')) as { contentType?: unknown }\n      if (typeof parsed.contentType === 'string' && parsed.contentType.length > 0) {\n        return { contentType: parsed.contentType }\n      }\n    } catch {\n      // fall through to the inferred default below\n    }\n    return { contentType: 'application/octet-stream', contentTypeInferred: true }\n  }\n\n  /**\n   * Realpath-confine `path` under `baseDir` — defends against a symlinked\n   * prefix/id dir escaping the store root even though every segment is allowlisted\n   * (the same realpath posture the LSP write-mode confinement uses).\n   */\n  private assertConfined(path: string): void {\n    const root = realpathSync(this.baseDir)\n    const resolved = realpathSync(path)\n    if (resolved !== root && !resolved.startsWith(root + sep)) {\n      throw new Error(`ArtifactStore: path escapes baseDir: ${path}`)\n    }\n  }\n}\n"],"mappings":"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"}

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@sackville-mcp/artifacts",
+  "version": "0.0.1-alpha.0",
+  "type": "module",
+  "license": "Apache-2.0",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.mts",
+        "default": "./dist/index.mjs"
+      }
+    }
+  },
+  "main": "./dist/index.mjs",
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ceautery/sackville.git",
+    "directory": "packages/artifacts"
+  },
+  "scripts": {
+    "build": "tsdown src/index.ts --dts",
+    "typecheck": "tsc --noEmit"
+  }
+}