@relayfile/core 0.10.24 → 0.10.26

package/dist/files.d.ts

@@ -66,4 +66,6 @@ export declare function readFile(storage: StorageAdapter, path: string): FileRow
 export declare function deleteFile(storage: StorageAdapter, req: DeleteFileRequest): DeleteResult;
 export declare const DEFAULT_CONTENT_TYPE = "text/markdown";
 export declare const MAX_FILE_BYTES: number;
+export declare const MAX_PATH_SEGMENT_BYTES = 200;
+export declare function hasOversizedPathSegment(path: string): boolean;
 export declare function encodedSize(content: string, encoding: "utf-8" | "base64"): number;

package/dist/files.js

@@ -41,6 +41,9 @@ export function writeFile(storage, req) {
         return { ok: false, error: "invalid_input" };
     }
     const path = normalizePath(req.path);
+    if (hasOversizedPathSegment(path)) {
+        return { ok: false, error: "invalid_input" };
+    }
     const ifMatch = normalizeIfMatch(req.ifMatch);
     if (!ifMatch) {
         return { ok: false, error: "missing_precondition" };
@@ -204,6 +207,24 @@ export function deleteFile(storage, req) {
 }
 export const DEFAULT_CONTENT_TYPE = "text/markdown";
 export const MAX_FILE_BYTES = 10 * 1024 * 1024;
+// Local mounts materialize each path segment as a real filesystem entry, and
+// most filesystems (ext4, APFS, ...) reject names over 255 bytes with
+// ENAMETOOLONG -- worse once a mount's own atomic-write suffix (e.g.
+// `.tmp-<random>`) is appended to the leaf segment. A provider adapter that
+// builds a path segment from unbounded user content (a long title, etc.) can
+// produce a canonical path no mount can ever materialize, which then fails
+// forever on every sync cycle since nothing else revisits an already-written
+// path. Reject that at write time instead of a bounded content-derived slug
+// having to be probabilistically clean everywhere it's used.
+export const MAX_PATH_SEGMENT_BYTES = 200;
+function encodedByteLength(value) {
+    return new TextEncoder().encode(value).length;
+}
+export function hasOversizedPathSegment(path) {
+    return path
+        .split("/")
+        .some((segment) => segment.length > 0 && encodedByteLength(segment) > MAX_PATH_SEGMENT_BYTES);
+}
 function normalizeEncoding(value) {
     const encoding = value?.trim().toLowerCase() ?? "";
     if (!encoding || encoding === "utf-8" || encoding === "utf8") {

package/dist/files.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/files.test.js

@@ -0,0 +1,76 @@
+import { describe, expect, it } from "vitest";
+import { hasOversizedPathSegment, MAX_PATH_SEGMENT_BYTES, writeFile } from "./files.js";
+describe("hasOversizedPathSegment", () => {
+    it("accepts a path whose every segment is at the byte limit", () => {
+        const segment = "a".repeat(MAX_PATH_SEGMENT_BYTES - ".json".length);
+        expect(hasOversizedPathSegment(`/reddit/subreddits/localllama/posts/${segment}.json`)).toBe(false);
+    });
+    it("rejects a path with one segment over the byte limit", () => {
+        const segment = "a".repeat(MAX_PATH_SEGMENT_BYTES + 1);
+        expect(hasOversizedPathSegment(`/reddit/subreddits/localllama/posts/${segment}.json`)).toBe(true);
+    });
+    it("counts UTF-8 encoded bytes, not JS string length", () => {
+        // Each "é" is 1 UTF-16 code unit but 2 UTF-8 bytes.
+        const segment = "é".repeat(MAX_PATH_SEGMENT_BYTES); // 200 chars, 400 bytes
+        expect(hasOversizedPathSegment(`/x/${segment}`)).toBe(true);
+    });
+    it("ignores empty segments from a normalized path", () => {
+        expect(hasOversizedPathSegment("/reddit/subreddits/localllama.json")).toBe(false);
+    });
+    it("reproduces the real oversized r/LocalLLaMA post slug that broke the mount", () => {
+        const badPath = "/reddit/subreddits/localllama/posts/i-just-don-t-get-it-these-big-tech-companies-can-illegally-" +
+            "scrape-the-entire-internet-and-gatekeep-their-better-models-behind-higher-prices-so-it-s-natural-" +
+            "that-people-look-for-affordable-options-and-there-will-be-providers-who-apparently-distill-models-" +
+            "from-them__1uvwn9q.json";
+        expect(hasOversizedPathSegment(badPath)).toBe(true);
+    });
+});
+describe("writeFile", () => {
+    function storageStub(overrides = {}) {
+        return {
+            getFile: () => null,
+            listFiles: () => [],
+            putFile: () => { },
+            deleteFile: () => { },
+            appendEvent: () => { },
+            listEvents: () => ({ items: [], nextCursor: null }),
+            getRecentEvents: () => [],
+            getOperation: () => null,
+            putOperation: () => { },
+            listOperations: () => ({ items: [], nextCursor: null }),
+            nextRevision: () => "rev_1",
+            nextOperationId: () => "op_1",
+            nextEventId: () => "evt_1",
+            enqueueWriteback: () => { },
+            getPendingWritebacks: () => [],
+            getWorkspaceId: () => "ws_test",
+            ...overrides,
+        };
+    }
+    it("rejects a write whose path has an oversized segment before touching storage", () => {
+        const segment = "a".repeat(MAX_PATH_SEGMENT_BYTES + 1);
+        let storageTouched = false;
+        const storage = storageStub({
+            getFile: () => {
+                storageTouched = true;
+                return null;
+            },
+        });
+        const result = writeFile(storage, {
+            path: `/reddit/subreddits/localllama/posts/${segment}.json`,
+            ifMatch: "*",
+            content: "{}",
+        });
+        expect(result).toEqual({ ok: false, error: "invalid_input" });
+        expect(storageTouched).toBe(false);
+    });
+    it("allows a write with normal-length path segments to proceed past the guard", () => {
+        const storage = storageStub();
+        const result = writeFile(storage, {
+            path: "/reddit/subreddits/localllama/posts/a-normal-title__abc123.json",
+            ifMatch: "0",
+            content: "{}",
+        });
+        expect(result.ok).toBe(true);
+    });
+});

package/dist/webhooks.js

@@ -13,7 +13,7 @@
  * This module stays pure. It only operates over plain storage records and
  * optional callbacks for suppression/staleness policy.
  */
-import { normalizePath, DEFAULT_CONTENT_TYPE, MAX_FILE_BYTES, encodedSize } from "./files.js";
+import { normalizePath, DEFAULT_CONTENT_TYPE, MAX_FILE_BYTES, encodedSize, hasOversizedPathSegment } from "./files.js";
 export function ingestWebhook(storage, input, options = {}) {
     const envelopeStorage = getWebhookStorage(storage);
     const correlationId = input.correlationId?.trim() ?? "";
@@ -226,6 +226,15 @@ export function applyWebhookEnvelope(storage, envelope, options = {}) {
                 revision: null,
             };
         }
+        if (hasOversizedPathSegment(event.path)) {
+            return {
+                status: "rejected",
+                eventType: event.type,
+                path: event.path,
+                revision: null,
+                reason: "path_too_long",
+            };
+        }
         const content = typeof event.content === "string"
             ? event.content
             : JSON.stringify(event.data ?? {});

package/dist/webhooks.test.js

@@ -168,6 +168,29 @@ describe("webhook Slack path canonicalization", () => {
         expect(envelope?.deliveryIds).toEqual(["delivery_1", "delivery_2"]);
         expect(envelope?.payload.path).toBe("/slack/channels/C123/messages/1711111111_000100/meta.json");
     });
+    it("rejects an envelope write whose path has an oversized segment instead of writing it", () => {
+        const storage = new MemoryStorage();
+        const oversizedSlug = "a".repeat(250);
+        const queued = ingestWebhook(storage, {
+            provider: "reddit",
+            eventType: "file.created",
+            path: `/reddit/subreddits/localllama/posts/${oversizedSlug}__1uvwn9q.json`,
+            deliveryId: "delivery_1",
+            timestamp: "2026-07-15T09:45:00.000Z",
+            correlationId: "corr_1",
+        }, {
+            generateEnvelopeId: () => "env_1",
+            coalesceWindowMs: 10_000,
+        });
+        expect(queued.status).toBe("queued");
+        const envelope = storage.envelopes.get("env_1");
+        if (!envelope)
+            throw new Error("envelope not queued");
+        const result = applyWebhookEnvelope(storage, envelope);
+        expect(result.status).toBe("rejected");
+        expect(result.reason).toBe("path_too_long");
+        expect(storage.files.size).toBe(0);
+    });
 });
 function fileRow(path, overrides = {}) {
     return {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@relayfile/core",
-  "version": "0.10.24",
+  "version": "0.10.26",
   "description": "Shared business logic for relayfile — file operations, ACL, queries, events, and writeback lifecycle",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",