@relayfile/core 0.8.14 → 0.8.17

package/dist/dedup.coverage.test.js

@@ -15,6 +15,7 @@ describe("dedup type contracts", () => {
         const identity = {
             kind: "push",
             key: "repo:abc:main",
+            ttlSeconds: 300,
         };
         const store = {
             async has(key) {

package/dist/dedup.d.ts

@@ -1,6 +1,7 @@
 export interface ContentIdentity {
     kind: string;
     key: string;
+    ttlSeconds?: number;
 }
 export interface DedupEntry {
     contentIdentity?: ContentIdentity;

package/dist/webhooks.d.ts

@@ -87,6 +87,6 @@ export interface WebhookStorageAdapter extends StorageAdapter {
 }
 export declare function ingestWebhook(storage: StorageAdapter, input: IngestWebhookInput, options?: IngestWebhookOptions): IngestResult;
 export declare function normalizeEnvelope(input: IngestWebhookInput, now?: () => string): Partial<EnvelopeRow>;
-export declare function normalizeEnvelopeEvent(envelope: Pick<EnvelopeRow, "payload" | "receivedAt">): EnvelopeEvent | null;
-export declare function normalizeEnvelopePath(envelope: Pick<EnvelopeRow, "payload">): string | null;
+export declare function normalizeEnvelopeEvent(envelope: Pick<EnvelopeRow, "payload" | "receivedAt"> & Partial<Pick<EnvelopeRow, "provider">>): EnvelopeEvent | null;
+export declare function normalizeEnvelopePath(envelope: Pick<EnvelopeRow, "payload"> & Partial<Pick<EnvelopeRow, "provider">>): string | null;
 export declare function applyWebhookEnvelope(storage: StorageAdapter, envelope: EnvelopeRow, options?: ApplyEnvelopeOptions): ApplyEnvelopeResult;

package/dist/webhooks.js

@@ -43,7 +43,7 @@ export function ingestWebhook(storage, input, options = {}) {
     const normalized = normalizeEnvelope(input, now);
     const provider = asOptionalString(normalized.provider) ?? "";
     const payload = asRecord(normalized.payload);
-    const path = normalizeEnvelopePath({ payload });
+    const path = normalizeEnvelopePath({ payload, provider });
     const receivedAt = asOptionalString(normalized.receivedAt) ?? now();
     const workspaceId = storage.getWorkspaceId();
     const deliveryId = asOptionalString(normalized.deliveryId) ??
@@ -69,7 +69,7 @@ export function ingestWebhook(storage, input, options = {}) {
         status: "queued",
         limit: 100,
     }).items;
-    const coalesced = findCoalescedEnvelope(queued, payload, receivedAt, options.coalesceWindowMs ?? DEFAULT_COALESCE_WINDOW_MS);
+    const coalesced = findCoalescedEnvelope(queued, payload, provider, receivedAt, options.coalesceWindowMs ?? DEFAULT_COALESCE_WINDOW_MS);
     if (coalesced) {
         const updated = {
             ...coalesced,
@@ -115,11 +115,13 @@ export function ingestWebhook(storage, input, options = {}) {
 export function normalizeEnvelope(input, now = nowIso) {
     const provider = normalizeProvider(input.provider);
     const eventType = normalizeEventType(input.eventType);
-    const path = normalizePath(input.path ?? "");
+    const canonicalPath = input.path?.trim()
+        ? canonicalProviderEnvelopePath(provider, input.path)
+        : null;
     const correlationId = input.correlationId?.trim() ?? "";
     const receivedAt = normalizeIsoDate(input.timestamp) ?? now();
     const deliveryId = input.deliveryId?.trim();
-    if (!provider || !eventType || !input.path?.trim()) {
+    if (!provider || !eventType || !input.path?.trim() || !canonicalPath) {
         return {
             provider,
             deliveryId,
@@ -137,7 +139,7 @@ export function normalizeEnvelope(input, now = nowIso) {
         payload: {
             provider,
             event_type: eventType,
-            path,
+            path: canonicalPath,
             timestamp: receivedAt,
             data: asRecord(input.data),
             delivery_id: deliveryId,
@@ -151,7 +153,10 @@ export function normalizeEnvelopeEvent(envelope) {
     if (!eventType) {
         return null;
     }
-    const path = normalizePath(asOptionalString(payload.path) ?? "/");
+    const path = normalizeEnvelopePath(envelope);
+    if (!path) {
+        return null;
+    }
     const data = asRecord(payload.data);
     const body = Object.keys(data).length > 0 ? data : payload;
     const timestamp = normalizeIsoDate(asOptionalString(payload.timestamp) ?? envelope.receivedAt) ??
@@ -179,11 +184,13 @@ export function normalizeEnvelopeEvent(envelope) {
 }
 export function normalizeEnvelopePath(envelope) {
     const path = asOptionalString(envelope.payload.path);
-    return path ? normalizePath(path) : null;
+    const provider = asOptionalString(envelope.provider) ??
+        asOptionalString(envelope.payload.provider);
+    return path ? canonicalProviderEnvelopePath(provider, path) : null;
 }
 export function applyWebhookEnvelope(storage, envelope, options = {}) {
-    const event = normalizeEnvelopeEvent(envelope);
-    if (!event) {
+    const normalizedEvent = normalizeEnvelopeEvent(envelope);
+    if (!normalizedEvent) {
         return {
             status: "ignored",
             eventType: null,
@@ -191,6 +198,7 @@ export function applyWebhookEnvelope(storage, envelope, options = {}) {
             revision: null,
         };
     }
+    const event = canonicalizeEnvelopeEventPath(storage, envelope.provider, normalizedEvent);
     if (options.shouldSuppress?.(envelope, event)) {
         const revision = appendSyncEvent(storage, "sync.suppressed", event.path, envelope.provider, envelope.correlationId, options.now?.() ?? event.timestamp);
         return {
@@ -356,14 +364,14 @@ function appendSyncEvent(storage, type, path, provider, correlationId, timestamp
     });
     return revision;
 }
-function findCoalescedEnvelope(envelopes, payload, receivedAt, windowMs) {
-    const key = coalesceObjectKey(payload);
+function findCoalescedEnvelope(envelopes, payload, provider, receivedAt, windowMs) {
+    const key = coalesceObjectKey(payload, provider);
     if (!key) {
         return null;
     }
     let match = null;
     for (const envelope of envelopes) {
-        if (coalesceObjectKey(envelope.payload) !== key) {
+        if (coalesceObjectKey(envelope.payload, envelope.provider) !== key) {
             continue;
         }
         if (!withinCoalesceWindow(envelope.receivedAt, receivedAt, windowMs)) {
@@ -381,7 +389,7 @@ function mergeDeliveryIds(envelope, deliveryId) {
 function deliveryMatches(envelope, deliveryId) {
     return envelope.deliveryId === deliveryId || envelope.deliveryIds?.includes(deliveryId) === true;
 }
-function coalesceObjectKey(payload) {
+function coalesceObjectKey(payload, provider) {
     const data = asRecord(payload.data);
     const providerObjectId = asOptionalString(data.providerObjectId) ??
         asOptionalString(data.provider_object_id) ??
@@ -392,9 +400,77 @@ function coalesceObjectKey(payload) {
     if (providerObjectId) {
         return `object:${providerObjectId}`;
     }
-    const path = normalizeEnvelopePath({ payload });
+    const path = normalizeEnvelopePath({ payload, provider });
     return path && path !== "/" ? `path:${path}` : "";
 }
+const PROVIDER_RELATIVE_PATH_ROOTS = {
+    slack: new Set(["channels", "dms", "teams", "users"]),
+};
+function canonicalProviderEnvelopePath(provider, rawPath) {
+    const path = normalizePath(rawPath);
+    const normalizedProvider = normalizeProvider(provider);
+    if (!normalizedProvider || path === "/") {
+        return path;
+    }
+    const relativeRoots = PROVIDER_RELATIVE_PATH_ROOTS[normalizedProvider];
+    if (!relativeRoots) {
+        return path;
+    }
+    const trimmed = path.slice(1);
+    if (trimmed === normalizedProvider ||
+        trimmed.startsWith(`${normalizedProvider}/`)) {
+        return path;
+    }
+    const [firstSegment] = trimmed.split("/", 1);
+    if (firstSegment && relativeRoots.has(firstSegment)) {
+        return normalizePath(`/${normalizedProvider}/${trimmed}`);
+    }
+    return null;
+}
+function canonicalizeEnvelopeEventPath(storage, provider, event) {
+    const path = canonicalizeExistingProviderAliasPath(storage, provider, event.path);
+    return path === event.path ? event : { ...event, path };
+}
+function canonicalizeExistingProviderAliasPath(storage, provider, rawPath) {
+    const path = normalizePath(rawPath);
+    if (normalizeProvider(provider) !== "slack") {
+        return path;
+    }
+    if (!parseRawSlackChannelAliasPath(path)) {
+        return path;
+    }
+    return canonicalizeSlackChannelAliasPath(storage.listFiles(), path);
+}
+function canonicalizeSlackChannelAliasPath(files, rawPath) {
+    const parsed = parseRawSlackChannelAliasPath(rawPath);
+    if (!parsed) {
+        return normalizePath(rawPath);
+    }
+    const { path, parts, channelSegment } = parsed;
+    const prefix = `/slack/channels/${channelSegment}__`;
+    const candidates = files
+        .map((file) => normalizePath(file.path))
+        .filter((filePath) => filePath.startsWith(prefix))
+        .map((filePath) => filePath.slice(1).split("/")[2])
+        .sort();
+    if (candidates.length === 0) {
+        return path;
+    }
+    parts[2] = candidates[0];
+    return normalizePath(`/${parts.join("/")}`);
+}
+function parseRawSlackChannelAliasPath(rawPath) {
+    const path = normalizePath(rawPath);
+    const parts = path.slice(1).split("/");
+    if (parts.length < 3 || parts[0] !== "slack" || parts[1] !== "channels") {
+        return null;
+    }
+    const channelSegment = parts[2];
+    if (!channelSegment || channelSegment.includes("__")) {
+        return null;
+    }
+    return { path, parts, channelSegment };
+}
 function withinCoalesceWindow(existingReceivedAt, incomingReceivedAt, windowMs) {
     if (windowMs <= 0) {
         return false;

package/dist/webhooks.test.d.ts

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

package/dist/webhooks.test.js

@@ -0,0 +1,265 @@
+import { describe, expect, it } from "vitest";
+import { applyWebhookEnvelope, ingestWebhook, normalizeEnvelopeEvent, normalizeEnvelopePath, } from "./webhooks.js";
+describe("webhook Slack path canonicalization", () => {
+    it("canonicalizes Slack provider-relative envelope paths", () => {
+        const event = normalizeEnvelopeEvent({
+            provider: "slack",
+            receivedAt: "2026-06-07T20:00:00.000Z",
+            payload: {
+                provider: "slack",
+                event_type: "file.updated",
+                path: "/channels/C123/messages/1711111111_000100/meta.json",
+            },
+        });
+        expect(event?.path).toBe("/slack/channels/C123/messages/1711111111_000100/meta.json");
+        expect(normalizeEnvelopePath({
+            provider: "slack",
+            payload: {
+                provider: "slack",
+                path: "/channels/C123/messages/1711111111_000100/meta.json",
+            },
+        })).toBe("/slack/channels/C123/messages/1711111111_000100/meta.json");
+    });
+    it("resolves raw Slack channel IDs to existing channelId__name aliases before writes and events", () => {
+        const storage = new MemoryStorage([
+            fileRow("/slack/channels/C123__engineering/meta.json", {
+                content: '{"id":"C123","name":"engineering"}',
+                provider: "slack",
+            }),
+        ]);
+        const result = applyWebhookEnvelope(storage, {
+            envelopeId: "env_1",
+            workspaceId: "ws_core",
+            provider: "slack",
+            deliveryId: "delivery_1",
+            receivedAt: "2026-06-07T20:00:00.000Z",
+            payload: {
+                provider: "slack",
+                event_type: "file.updated",
+                path: "/slack/channels/C123/messages/1711111111_000100/meta.json",
+                content: '{"text":"hello"}',
+                contentType: "application/json",
+            },
+            correlationId: "corr_1",
+            status: "queued",
+            attemptCount: 0,
+            lastError: null,
+        });
+        const canonicalPath = "/slack/channels/C123__engineering/messages/1711111111_000100/meta.json";
+        expect(result).toMatchObject({
+            status: "processed",
+            path: canonicalPath,
+        });
+        expect(storage.getFile(canonicalPath)?.content).toBe('{"text":"hello"}');
+        expect(storage.getFile("/slack/channels/C123/messages/1711111111_000100/meta.json")).toBeNull();
+        expect(storage.events.at(-1)?.path).toBe(canonicalPath);
+        expect(storage.listFilesCalls).toBe(1);
+    });
+    it("does not scan storage when Slack channel alias resolution is unnecessary", () => {
+        const storage = new MemoryStorage([
+            fileRow("/slack/channels/C123__engineering/meta.json", {
+                content: '{"id":"C123","name":"engineering"}',
+                provider: "slack",
+            }),
+        ]);
+        const aliasedResult = applyWebhookEnvelope(storage, {
+            envelopeId: "env_aliased",
+            workspaceId: "ws_core",
+            provider: "slack",
+            deliveryId: "delivery_aliased",
+            receivedAt: "2026-06-07T20:00:00.000Z",
+            payload: {
+                provider: "slack",
+                event_type: "file.updated",
+                path: "/slack/channels/C123__engineering/messages/1711111111_000100/meta.json",
+                content: '{"text":"hello"}',
+                contentType: "application/json",
+            },
+            correlationId: "corr_aliased",
+            status: "queued",
+            attemptCount: 0,
+            lastError: null,
+        });
+        const dmResult = applyWebhookEnvelope(storage, {
+            envelopeId: "env_dm",
+            workspaceId: "ws_core",
+            provider: "slack",
+            deliveryId: "delivery_dm",
+            receivedAt: "2026-06-07T20:00:01.000Z",
+            payload: {
+                provider: "slack",
+                event_type: "file.updated",
+                path: "/slack/dms/D123/messages/1711111111_000100/meta.json",
+                content: '{"text":"dm"}',
+                contentType: "application/json",
+            },
+            correlationId: "corr_dm",
+            status: "queued",
+            attemptCount: 0,
+            lastError: null,
+        });
+        expect(aliasedResult).toMatchObject({
+            status: "processed",
+            path: "/slack/channels/C123__engineering/messages/1711111111_000100/meta.json",
+        });
+        expect(dmResult).toMatchObject({
+            status: "processed",
+            path: "/slack/dms/D123/messages/1711111111_000100/meta.json",
+        });
+        expect(storage.listFilesCalls).toBe(0);
+    });
+    it("ignores Slack envelopes targeting paths outside the Slack provider root", () => {
+        const storage = new MemoryStorage();
+        const result = applyWebhookEnvelope(storage, {
+            envelopeId: "env_1",
+            workspaceId: "ws_core",
+            provider: "slack",
+            deliveryId: "delivery_1",
+            receivedAt: "2026-06-07T20:00:00.000Z",
+            payload: {
+                provider: "slack",
+                event_type: "file.updated",
+                path: "/github/repos/acme/cloud/issues/1.json",
+                content: '{"title":"wrong provider"}',
+            },
+            correlationId: "corr_1",
+            status: "queued",
+            attemptCount: 0,
+            lastError: null,
+        });
+        expect(result).toEqual({
+            status: "ignored",
+            eventType: null,
+            path: null,
+            revision: null,
+        });
+        expect(storage.listFiles()).toEqual([]);
+        expect(storage.events).toEqual([]);
+    });
+    it("coalesces Slack provider-relative and canonical paths by canonical path", () => {
+        const storage = new MemoryStorage();
+        let nextEnvelopeId = 1;
+        const first = ingestWebhook(storage, {
+            provider: "slack",
+            eventType: "file.updated",
+            path: "/channels/C123/messages/1711111111_000100/meta.json",
+            deliveryId: "delivery_1",
+            timestamp: "2026-06-07T20:00:00.000Z",
+            correlationId: "corr_1",
+        }, {
+            generateEnvelopeId: () => `env_${nextEnvelopeId++}`,
+            coalesceWindowMs: 10_000,
+        });
+        const second = ingestWebhook(storage, {
+            provider: "slack",
+            eventType: "file.updated",
+            path: "/slack/channels/C123/messages/1711111111_000100/meta.json",
+            deliveryId: "delivery_2",
+            timestamp: "2026-06-07T20:00:01.000Z",
+            correlationId: "corr_2",
+        }, {
+            generateEnvelopeId: () => `env_${nextEnvelopeId++}`,
+            coalesceWindowMs: 10_000,
+        });
+        expect(first).toMatchObject({ status: "queued", envelopeId: "env_1" });
+        expect(second).toMatchObject({ status: "queued", envelopeId: "env_1" });
+        expect(Array.from(storage.envelopes)).toHaveLength(1);
+        const envelope = storage.envelopes.get("env_1");
+        expect(envelope?.deliveryIds).toEqual(["delivery_1", "delivery_2"]);
+        expect(envelope?.payload.path).toBe("/slack/channels/C123/messages/1711111111_000100/meta.json");
+    });
+});
+function fileRow(path, overrides = {}) {
+    return {
+        path,
+        revision: "rev_1",
+        contentType: "application/json",
+        content: "{}",
+        encoding: "utf-8",
+        provider: "",
+        lastEditedAt: "2026-06-07T20:00:00.000Z",
+        semantics: {},
+        ...overrides,
+    };
+}
+class MemoryStorage {
+    files = new Map();
+    events = [];
+    envelopes = new Map();
+    deliveryAliases = new Map();
+    revisionCounter = 1;
+    eventCounter = 1;
+    listFilesCalls = 0;
+    constructor(files = []) {
+        for (const file of files) {
+            this.files.set(file.path, file);
+        }
+    }
+    getFile(path) {
+        return this.files.get(path) ?? null;
+    }
+    listFiles() {
+        this.listFilesCalls += 1;
+        return Array.from(this.files.values());
+    }
+    putFile(file) {
+        this.files.set(file.path, file);
+    }
+    deleteFile(path) {
+        this.files.delete(path);
+    }
+    appendEvent(event) {
+        this.events.push(event);
+    }
+    listEvents(_options) {
+        return { items: this.events, nextCursor: null };
+    }
+    getRecentEvents(limit) {
+        return this.events.slice(-limit);
+    }
+    getOperation(_opId) {
+        return null;
+    }
+    putOperation(_op) {
+        return undefined;
+    }
+    listOperations(_options) {
+        return { items: [], nextCursor: null };
+    }
+    nextRevision() {
+        return `rev_${this.revisionCounter++}`;
+    }
+    nextOperationId() {
+        return "op_1";
+    }
+    nextEventId() {
+        return `evt_${this.eventCounter++}`;
+    }
+    enqueueWriteback(_item) {
+        return undefined;
+    }
+    getPendingWritebacks() {
+        return [];
+    }
+    getEnvelopeByDelivery(workspaceId, provider, deliveryId) {
+        const envelopeId = this.deliveryAliases.get(`${workspaceId}|${provider}|${deliveryId}`);
+        return envelopeId ? this.envelopes.get(envelopeId) ?? null : null;
+    }
+    putEnvelope(envelope) {
+        this.envelopes.set(envelope.envelopeId, envelope);
+    }
+    putEnvelopeDeliveryAlias(workspaceId, provider, deliveryId, envelopeId) {
+        this.deliveryAliases.set(`${workspaceId}|${provider}|${deliveryId}`, envelopeId);
+    }
+    listEnvelopes(options) {
+        return {
+            items: Array.from(this.envelopes.values()).filter((envelope) => (!options.workspaceId || envelope.workspaceId === options.workspaceId) &&
+                (!options.provider || envelope.provider === options.provider) &&
+                (!options.status || envelope.status === options.status)),
+            nextCursor: null,
+        };
+    }
+    getWorkspaceId() {
+        return "ws_core";
+    }
+}

package/package.json

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