@agentworkforce/sage 1.1.3 → 1.2.1

package/dist/app.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"app.d.ts","sourceRoot":"","sources":["../src/app.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,IAAI,EAAE,MAAM,MAAM,CAAC;AA0C5B,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAwB/C,UAAU,YAAY;IACpB,YAAY,EAAE,MAAM,CAAC;IACrB,YAAY,EAAE,OAAO,CAAC;CACvB;AAED,KAAK,MAAM,GAAG;IACZ,QAAQ,EAAE,YAAY,CAAC;IACvB,SAAS,EAAE,YAAY,CAAC;CACzB,CAAC;AA8tCF,wBAAgB,aAAa,IAAI,IAAI,CAAC,MAAM,CAAC,CAshB5C"}
+{"version":3,"file":"app.d.ts","sourceRoot":"","sources":["../src/app.ts"],"names":[],"mappings":"AAUA,OAAO,EAAE,IAAI,EAAE,MAAM,MAAM,CAAC;AA0C5B,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAwB/C,UAAU,YAAY;IACpB,YAAY,EAAE,MAAM,CAAC;IACrB,YAAY,EAAE,OAAO,CAAC;CACvB;AAED,KAAK,MAAM,GAAG;IACZ,QAAQ,EAAE,YAAY,CAAC;IACvB,SAAS,EAAE,YAAY,CAAC;CACzB,CAAC;AAivCF,wBAAgB,aAAa,IAAI,IAAI,CAAC,MAAM,CAAC,CAmiB5C"}

package/dist/app.js

@@ -1,5 +1,6 @@
 import { Buffer } from "node:buffer";
 import { timingSafeEqual } from "node:crypto";
+import { SlackThreadGate, } from "@agent-assistant/surfaces";
 import { RelayFileClient } from "@relayfile/sdk";
 import { Hono } from "hono";
 import { createSageRuntime } from "./assistant/index.js";
@@ -576,17 +577,30 @@ async function markEventSeen(kv, eventId) {
 function getSlackDeduplicationKey(event) {
     return event.eventId ?? event.ts;
 }
-async function isActiveThread(kv, threadTs) {
-    if (!threadTs) {
-        return false;
-    }
-    return (await kv.get(threadTs)) !== null;
+function createThreadStore(kv) {
+    const keyOf = (key) => `${key.workspaceId}:${key.channel}:${key.threadTs}`;
+    return {
+        async isActive(key) {
+            return (await kv.get(keyOf(key))) !== null;
+        },
+        async markActive(key, ttlSeconds) {
+            await kv.put(keyOf(key), JSON.stringify({ workspaceId: key.workspaceId, channel: key.channel }), { expirationTtl: ttlSeconds });
+        },
+    };
 }
-async function markActiveThread(kv, threadTs, ctx) {
-    if (!threadTs) {
-        return;
-    }
-    await kv.put(threadTs, JSON.stringify(ctx), { expirationTtl: ACTIVE_THREAD_TTL_SECONDS });
+// KV keys produced by createThreadStore have the shape
+// `${workspaceId}:${channel}:${threadTs}`. Slack workspace IDs (T…),
+// channel IDs (C…/G…) and thread timestamps (numeric with a dot) never
+// contain `:`, so the last `:` unambiguously separates channel from
+// threadTs. Legacy entries written before the composite-key refactor had
+// the raw threadTs as the key — fall back to that when no `:` is present.
+function parseActiveThreadKey(name) {
+    const lastColon = name.lastIndexOf(":");
+    if (lastColon === -1) {
+        return name || undefined;
+    }
+    const threadTs = name.slice(lastColon + 1);
+    return threadTs || undefined;
 }
 async function loadActiveThreadsMap(kv) {
     const activeThreads = new Map();
@@ -602,8 +616,12 @@ async function loadActiveThreadsMap(kv) {
                 const parsed = JSON.parse(raw);
                 const workspaceId = readNonEmptyString(parsed.workspaceId);
                 const channel = readNonEmptyString(parsed.channel);
-                if (workspaceId && channel) {
-                    activeThreads.set(name, {
+                const threadTs = parseActiveThreadKey(name);
+                if (workspaceId && channel && threadTs) {
+                    // Key by the raw Slack thread_ts so downstream consumers
+                    // (detectStaleThreads, proactive dashboards) can pass it back
+                    // to the Slack API without re-parsing.
+                    activeThreads.set(threadTs, {
                         workspaceId,
                         channel,
                     });
@@ -677,6 +695,10 @@ async function processSlackEvent(event, workspaceId, env, slack, options = {}) {
     const memory = getMemory(workspaceId);
     const orgMemory = getOrgMemory(workspaceId);
     const nangoClient = getNango(env);
+    const threadGate = new SlackThreadGate({
+        store: createThreadStore(env.THREADS),
+        ttlSeconds: ACTIVE_THREAD_TTL_SECONDS,
+    });
     const workspaceSlackBotUserId = options.slackBotUserId ?? await detectSlackBotUserId(slack);
     const { connectionId: githubConnectionId, providerConfigKey: githubProviderConfigKey, } = await resolveGitHubConnection(workspaceId, env);
     const relayfileReader = await getRelayFileReader(workspaceId, env);
@@ -745,10 +767,7 @@ async function processSlackEvent(event, workspaceId, env, slack, options = {}) {
         }
         console.log(`[sage] Reply posted: threadTs=${replyThreadTs} replyTs=${postResult.ts ?? ""}`);
         if (replyThreadTs) {
-            await markActiveThread(env.THREADS, replyThreadTs, {
-                workspaceId,
-                channel: event.channel,
-            });
+            await threadGate.refresh({ workspaceId, channel: event.channel, threadTs: replyThreadTs });
         }
         try {
             const summary = truncate(`User asked: ${event.text}\nSage answered: ${reply}`, 600);
@@ -1319,24 +1338,30 @@ export function createSageApp() {
         const workspaceId = getWorkspaceId(event, c.env);
         const cloudProxyProvider = getCloudProxyProvider(c.env);
         const { slack, slackBotUserId: workspaceSlackBotUserId } = await resolveWorkspaceSlackContext(workspaceId, cloudProxyProvider);
-        if (event.type === "message" && event.threadTs) {
-            const isActive = await isActiveThread(c.env.THREADS, event.threadTs);
-            if (!isActive) {
-                console.log(`[sage] Dropping thread reply on inactive thread: threadTs=${event.threadTs}`);
-                return c.json({ ok: true });
-            }
+        const threadGate = new SlackThreadGate({
+            store: createThreadStore(c.env.THREADS),
+            ttlSeconds: ACTIVE_THREAD_TTL_SECONDS,
+        });
+        const gateDecision = await threadGate.shouldProcess({
+            type: event.type === "mention" ? "mention" : "message",
+            channel: event.channel,
+            ts: event.ts,
+            threadTs: event.threadTs,
+        }, workspaceId);
+        if (!gateDecision.proceed) {
+            console.log(`[sage] Dropping thread reply on inactive thread: threadTs=${event.threadTs ?? ""}`);
+            return c.json({ ok: true });
         }
         if (!event.userId || (workspaceSlackBotUserId && event.userId === workspaceSlackBotUserId)) {
             return c.json({ ok: true });
         }
         if (event.type === "mention") {
-            const mentionThreadTs = event.threadTs ?? event.ts;
-            if (mentionThreadTs) {
-                await markActiveThread(c.env.THREADS, mentionThreadTs, {
-                    workspaceId,
-                    channel: event.channel,
-                });
-            }
+            await threadGate.onEngaged({
+                type: "mention",
+                channel: event.channel,
+                ts: event.ts,
+                threadTs: event.threadTs,
+            }, workspaceId);
         }
         const rateLimitResult = await getRateLimiter(c.env).limit({ key: `${workspaceId}:${event.userId}` });
         if (!rateLimitResult.success) {

package/dist/e2e/e2e-harness.d.ts

@@ -0,0 +1,36 @@
+import { ProviderWriteFacade, type WriteMode } from "../integrations/provider-write-facade.js";
+import { RecentActionsOverlay } from "../integrations/recent-actions-overlay.js";
+import { SageRelayFileReader } from "../integrations/relayfile-reader.js";
+import { type MockCloudProxyServer } from "./mock-cloud-proxy-server.js";
+import { type MockRelayfileServer, type SeedFileData } from "./mock-relayfile-server.js";
+export interface HarnessOptions {
+    overlayTtlMs?: number;
+    overlayMaxEntries?: number;
+    readerCacheTtlMs?: number;
+    defaultWriteMode?: WriteMode;
+}
+export interface E2EHarness {
+    reader: SageRelayFileReader;
+    facade: ProviderWriteFacade;
+    overlay: RecentActionsOverlay;
+    mockRelayfile: MockRelayfileServer;
+    mockCloudProxy: MockCloudProxyServer;
+    teardown(): Promise<void>;
+}
+export interface SlackMessageFixture {
+    channel: string;
+    text: string;
+    threadTs?: string;
+}
+export interface GitHubPRCommentFixture {
+    owner: string;
+    repo: string;
+    number: number;
+    body: string;
+}
+export declare function buildHarness(options?: HarnessOptions): Promise<E2EHarness>;
+export declare function makeSlackMessage(overrides?: Partial<SlackMessageFixture>): SlackMessageFixture;
+export declare function makeGitHubPRComment(overrides?: Partial<GitHubPRCommentFixture>): GitHubPRCommentFixture;
+export declare function makeRelayfileSeedEntry(path: string, overrides?: Partial<SeedFileData>): SeedFileData;
+export type { MockCloudProxyServer, MockRelayfileServer, SeedFileData };
+//# sourceMappingURL=e2e-harness.d.ts.map

package/dist/e2e/e2e-harness.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"e2e-harness.d.ts","sourceRoot":"","sources":["../../src/e2e/e2e-harness.ts"],"names":[],"mappings":"AAIA,OAAO,EACL,mBAAmB,EAMnB,KAAK,SAAS,EACf,MAAM,0CAA0C,CAAC;AAClD,OAAO,EAAE,oBAAoB,EAAE,MAAM,2CAA2C,CAAC;AACjF,OAAO,EAAE,mBAAmB,EAAE,MAAM,qCAAqC,CAAC;AAC1E,OAAO,EAEL,KAAK,oBAAoB,EAC1B,MAAM,8BAA8B,CAAC;AACtC,OAAO,EAEL,KAAK,mBAAmB,EACxB,KAAK,YAAY,EAClB,MAAM,4BAA4B,CAAC;AAMpC,MAAM,WAAW,cAAc;IAC7B,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,gBAAgB,CAAC,EAAE,SAAS,CAAC;CAC9B;AAED,MAAM,WAAW,UAAU;IACzB,MAAM,EAAE,mBAAmB,CAAC;IAC5B,MAAM,EAAE,mBAAmB,CAAC;IAC5B,OAAO,EAAE,oBAAoB,CAAC;IAC9B,aAAa,EAAE,mBAAmB,CAAC;IACnC,cAAc,EAAE,oBAAoB,CAAC;IACrC,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CAC3B;AAED,MAAM,WAAW,mBAAmB;IAClC,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,sBAAsB;IACrC,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;CACd;AAoRD,wBAAsB,YAAY,CAAC,OAAO,GAAE,cAAmB,GAAG,OAAO,CAAC,UAAU,CAAC,CAuDpF;AAED,wBAAgB,gBAAgB,CAAC,SAAS,GAAE,OAAO,CAAC,mBAAmB,CAAM,GAAG,mBAAmB,CAMlG;AAED,wBAAgB,mBAAmB,CACjC,SAAS,GAAE,OAAO,CAAC,sBAAsB,CAAM,GAC9C,sBAAsB,CAQxB;AAED,wBAAgB,sBAAsB,CACpC,IAAI,EAAE,MAAM,EACZ,SAAS,GAAE,OAAO,CAAC,YAAY,CAAM,GACpC,YAAY,CAQd;AAED,YAAY,EAAE,oBAAoB,EAAE,mBAAmB,EAAE,YAAY,EAAE,CAAC"}

package/dist/e2e/e2e-harness.js

@@ -0,0 +1,278 @@
+import { randomBytes } from "node:crypto";
+import { RelayFileClient } from "@relayfile/sdk";
+import { ProviderWriteFacade, } from "../integrations/provider-write-facade.js";
+import { RecentActionsOverlay } from "../integrations/recent-actions-overlay.js";
+import { SageRelayFileReader } from "../integrations/relayfile-reader.js";
+import { createMockCloudProxyServer, } from "./mock-cloud-proxy-server.js";
+import { createMockRelayfileServer, } from "./mock-relayfile-server.js";
+const WORKSPACE_ID = "test-workspace";
+const CLOUD_PROXY_TOKEN = "test";
+const RELAYFILE_FETCH_TIMEOUT_MS = 1_000;
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readString(value) {
+    return typeof value === "string" ? value : undefined;
+}
+function readNumber(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+function randomHex(byteLength = 8) {
+    return randomBytes(byteLength).toString("hex");
+}
+function normalizeVfsPath(value) {
+    const trimmed = value.trim();
+    if (!trimmed) {
+        return "/";
+    }
+    const withLeadingSlash = trimmed.startsWith("/") ? trimmed : `/${trimmed}`;
+    return withLeadingSlash === "/" ? withLeadingSlash : withLeadingSlash.replace(/\/+$/g, "");
+}
+function detectProviderFromPath(path) {
+    const [provider] = normalizeVfsPath(path).split("/").filter(Boolean);
+    return provider || undefined;
+}
+function createTimeoutFetch(timeoutMs) {
+    return async (input, init = {}) => {
+        if (init.signal) {
+            return fetch(input, init);
+        }
+        const controller = new AbortController();
+        const timer = setTimeout(() => {
+            controller.abort();
+        }, timeoutMs);
+        timer.unref?.();
+        try {
+            return await fetch(input, {
+                ...init,
+                signal: controller.signal,
+            });
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    };
+}
+async function readJson(response) {
+    try {
+        return await response.json();
+    }
+    catch {
+        throw new Error("Mock cloud proxy returned invalid JSON");
+    }
+}
+function parseProxyEnvelope(payload) {
+    if (!isRecord(payload) || typeof payload.ok !== "boolean") {
+        throw new Error("Mock cloud proxy returned an invalid envelope");
+    }
+    if (payload.ok) {
+        return {
+            ok: true,
+            data: payload.data,
+        };
+    }
+    return {
+        ok: false,
+        ...(readString(payload.error) ? { error: readString(payload.error) } : {}),
+    };
+}
+async function postCloudProxy(baseUrl, route, body) {
+    const response = await fetch(`${baseUrl}${route}`, {
+        method: "POST",
+        headers: {
+            Authorization: `Bearer ${CLOUD_PROXY_TOKEN}`,
+            "Content-Type": "application/json",
+        },
+        body: JSON.stringify(body),
+    });
+    const payload = await readJson(response);
+    if (!response.ok) {
+        const message = isRecord(payload) && readString(payload.error)
+            ? readString(payload.error)
+            : `${response.status} ${response.statusText}`.trim();
+        throw new Error(`Mock cloud proxy request failed: ${message}`);
+    }
+    const envelope = parseProxyEnvelope(payload);
+    if (!envelope.ok) {
+        throw new Error(envelope.error ?? "Mock cloud proxy returned an error");
+    }
+    return envelope.data;
+}
+function readSlackResult(data) {
+    if (!isRecord(data)) {
+        throw new Error("Slack proxy returned an invalid response");
+    }
+    return {
+        ok: data.ok === true,
+        ...(readString(data.ts) ? { ts: readString(data.ts) } : {}),
+        ...(readString(data.error) ? { error: readString(data.error) } : {}),
+    };
+}
+function createMockSlackEgress(mockCloudProxy) {
+    return {
+        async postMessage(channel, text, threadTs) {
+            const data = await postCloudProxy(mockCloudProxy.baseUrl, "/api/v1/proxy/slack", {
+                workspaceId: WORKSPACE_ID,
+                endpoint: "/chat.postMessage",
+                method: "POST",
+                data: {
+                    channel,
+                    text,
+                    ...(threadTs ? { thread_ts: threadTs } : {}),
+                },
+            });
+            return readSlackResult(data);
+        },
+        async addReaction(channel, timestamp, emoji) {
+            const data = await postCloudProxy(mockCloudProxy.baseUrl, "/api/v1/proxy/slack", {
+                workspaceId: WORKSPACE_ID,
+                endpoint: "/reactions.add",
+                method: "POST",
+                data: {
+                    channel,
+                    timestamp,
+                    name: emoji,
+                },
+            });
+            if (isRecord(data) && data.ok === false) {
+                throw new Error(readString(data.error) ?? "Slack addReaction failed");
+            }
+        },
+    };
+}
+function normalizeGithubResource(data) {
+    if (!isRecord(data)) {
+        throw new Error("GitHub proxy returned an invalid response");
+    }
+    const id = readNumber(data.id);
+    const url = readString(data.url) ?? readString(data.html_url);
+    if (id === undefined || !url) {
+        throw new Error("GitHub proxy response is missing id or url");
+    }
+    return { id, url };
+}
+function createMockGitHubIntegration(mockCloudProxy) {
+    return {
+        async createIssueComment(owner, repo, number, body) {
+            const endpoint = `/repos/${owner}/${repo}/issues/${number}/comments`;
+            const data = await postCloudProxy(mockCloudProxy.baseUrl, "/api/v1/proxy/github", {
+                connectionId: "test-connection",
+                providerConfigKey: "github",
+                method: "POST",
+                endpoint,
+                data: { body },
+            });
+            return { data: normalizeGithubResource(data) };
+        },
+        async createPRReview(owner, repo, number, body, event) {
+            const endpoint = `/repos/${owner}/${repo}/pulls/${number}/reviews`;
+            const data = await postCloudProxy(mockCloudProxy.baseUrl, "/api/v1/proxy/github", {
+                connectionId: "test-connection",
+                providerConfigKey: "github",
+                method: "POST",
+                endpoint,
+                data: {
+                    body,
+                    ...(event ? { event } : {}),
+                },
+            });
+            return { data: normalizeGithubResource(data) };
+        },
+    };
+}
+async function startMockServers() {
+    const [relayfileResult, cloudProxyResult] = await Promise.allSettled([
+        createMockRelayfileServer(),
+        createMockCloudProxyServer(),
+    ]);
+    if (relayfileResult.status === "fulfilled" && cloudProxyResult.status === "fulfilled") {
+        return {
+            mockRelayfile: relayfileResult.value,
+            mockCloudProxy: cloudProxyResult.value,
+        };
+    }
+    await Promise.allSettled([
+        relayfileResult.status === "fulfilled" ? relayfileResult.value.close() : Promise.resolve(),
+        cloudProxyResult.status === "fulfilled" ? cloudProxyResult.value.close() : Promise.resolve(),
+    ]);
+    if (relayfileResult.status === "rejected") {
+        throw relayfileResult.reason;
+    }
+    if (cloudProxyResult.status === "rejected") {
+        throw cloudProxyResult.reason;
+    }
+    throw new Error("Mock servers failed to start");
+}
+export async function buildHarness(options = {}) {
+    const { mockRelayfile, mockCloudProxy } = await startMockServers();
+    const overlay = new RecentActionsOverlay({
+        ttlMs: options.overlayTtlMs,
+        maxEntries: options.overlayMaxEntries,
+    });
+    const relayFileClient = new RelayFileClient({
+        baseUrl: mockRelayfile.baseUrl,
+        token: "test-token",
+        fetchImpl: createTimeoutFetch(RELAYFILE_FETCH_TIMEOUT_MS),
+        retry: { maxRetries: 0 },
+    });
+    const reader = new SageRelayFileReader({
+        client: relayFileClient,
+        workspaceId: WORKSPACE_ID,
+        cacheTtlMs: options.readerCacheTtlMs ?? 0,
+        overlay,
+    });
+    const facade = new ProviderWriteFacade({
+        slackEgress: createMockSlackEgress(mockCloudProxy),
+        githubIntegration: createMockGitHubIntegration(mockCloudProxy),
+        overlay,
+        defaultMode: options.defaultWriteMode ?? "sync",
+    });
+    let tornDown = false;
+    return {
+        reader,
+        facade,
+        overlay,
+        mockRelayfile,
+        mockCloudProxy,
+        async teardown() {
+            if (tornDown) {
+                return;
+            }
+            tornDown = true;
+            const results = await Promise.allSettled([
+                mockRelayfile.close(),
+                mockCloudProxy.close(),
+            ]);
+            overlay.clear();
+            const failure = results.find((result) => result.status === "rejected");
+            if (failure) {
+                throw failure.reason;
+            }
+        },
+    };
+}
+export function makeSlackMessage(overrides = {}) {
+    return {
+        channel: "C-test-001",
+        text: "Hello from test",
+        ...overrides,
+    };
+}
+export function makeGitHubPRComment(overrides = {}) {
+    return {
+        owner: "test-org",
+        repo: "test-repo",
+        number: 42,
+        body: "LGTM",
+        ...overrides,
+    };
+}
+export function makeRelayfileSeedEntry(path, overrides = {}) {
+    return {
+        content: JSON.stringify({ seeded: true }),
+        contentType: "application/json",
+        revision: `rev-${randomHex()}`,
+        provider: detectProviderFromPath(path),
+        ...overrides,
+    };
+}

package/dist/e2e/mock-cloud-proxy-server.d.ts

@@ -0,0 +1,25 @@
+export interface ProxyResponseOverride {
+    status?: number;
+    body?: unknown;
+    ok?: boolean;
+    delayMs?: number;
+    error?: string;
+}
+export interface ProxyRequestLogEntry {
+    provider: "slack" | "github";
+    method: string;
+    endpoint: string;
+    body?: unknown;
+    timestamp: number;
+}
+export interface MockCloudProxyServer {
+    port: number;
+    baseUrl: string;
+    setSlackResponse(endpoint: string, override: ProxyResponseOverride): void;
+    setGithubResponse(endpoint: string, override: ProxyResponseOverride): void;
+    getRequestLog(): ProxyRequestLogEntry[];
+    clear(): void;
+    close(): Promise<void>;
+}
+export declare function createMockCloudProxyServer(): Promise<MockCloudProxyServer>;
+//# sourceMappingURL=mock-cloud-proxy-server.d.ts.map

package/dist/e2e/mock-cloud-proxy-server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mock-cloud-proxy-server.d.ts","sourceRoot":"","sources":["../../src/e2e/mock-cloud-proxy-server.ts"],"names":[],"mappings":"AAKA,MAAM,WAAW,qBAAqB;IACpC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,EAAE,CAAC,EAAE,OAAO,CAAC;IACb,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,oBAAoB;IACnC,QAAQ,EAAE,OAAO,GAAG,QAAQ,CAAC;IAC7B,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,oBAAoB;IACnC,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,qBAAqB,GAAG,IAAI,CAAC;IAC1E,iBAAiB,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,qBAAqB,GAAG,IAAI,CAAC;IAC3E,aAAa,IAAI,oBAAoB,EAAE,CAAC;IACxC,KAAK,IAAI,IAAI,CAAC;IACd,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACxB;AAoGD,wBAAsB,0BAA0B,IAAI,OAAO,CAAC,oBAAoB,CAAC,CA2FhF"}

package/dist/e2e/mock-cloud-proxy-server.js

@@ -0,0 +1,149 @@
+import { createServer } from "node:http";
+import express from "express";
+const DEFAULT_SLACK_TS_PREFIX = "1700000000";
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readString(value) {
+    return typeof value === "string" ? value : undefined;
+}
+function readProxyRequestBody(body) {
+    return isRecord(body) ? body : {};
+}
+function normalizeEndpoint(endpoint) {
+    return endpoint.startsWith("/") ? endpoint : `/${endpoint}`;
+}
+function randomGithubId() {
+    return Math.floor(Math.random() * 900_000) + 100_000;
+}
+function defaultSlackData() {
+    const suffix = Math.floor(Math.random() * 1_000_000)
+        .toString()
+        .padStart(6, "0");
+    return {
+        ok: true,
+        ts: `${DEFAULT_SLACK_TS_PREFIX}.${suffix}`,
+    };
+}
+function defaultGithubData() {
+    const id = randomGithubId();
+    const path = `mock-${id}`;
+    const htmlUrl = `https://github.com/test/test/${path}`;
+    return {
+        id,
+        url: htmlUrl,
+        html_url: htmlUrl,
+    };
+}
+function respondWithEnvelope(res, override, defaultData) {
+    const status = override?.status ?? 200;
+    const ok = override?.ok ?? true;
+    if (!ok) {
+        res.status(status).json({
+            ok: false,
+            error: override?.error ?? "Mock cloud proxy error",
+        });
+        return;
+    }
+    res.status(status).json({
+        ok: true,
+        data: override && "body" in override ? override.body : defaultData(),
+    });
+}
+function delayed(delayMs, callback) {
+    if (delayMs !== undefined && delayMs > 0) {
+        setTimeout(callback, delayMs);
+        return;
+    }
+    callback();
+}
+function closeServer(server) {
+    return new Promise((resolve, reject) => {
+        server.close((error) => {
+            if (error) {
+                reject(error);
+                return;
+            }
+            resolve();
+        });
+        server.closeIdleConnections?.();
+        server.closeAllConnections?.();
+    });
+}
+export async function createMockCloudProxyServer() {
+    const app = express();
+    const slackOverrides = new Map();
+    const githubOverrides = new Map();
+    const requestLog = [];
+    app.use(express.json({ limit: "1mb" }));
+    const recordRequest = (provider, req) => {
+        const body = readProxyRequestBody(req.body);
+        const endpoint = normalizeEndpoint(readString(body.endpoint) ?? "");
+        const method = readString(body.method) ?? req.method;
+        const overrides = provider === "slack" ? slackOverrides : githubOverrides;
+        requestLog.push({
+            provider,
+            method,
+            endpoint,
+            body: req.body,
+            timestamp: Date.now(),
+        });
+        return {
+            endpoint,
+            override: overrides.get(endpoint),
+        };
+    };
+    app.get("/api/health", (_req, res) => {
+        res.status(200).json({ ok: true });
+    });
+    app.post("/api/v1/proxy/slack", (req, res) => {
+        const { override } = recordRequest("slack", req);
+        delayed(override?.delayMs, () => {
+            respondWithEnvelope(res, override, defaultSlackData);
+        });
+    });
+    app.post("/api/v1/proxy/github", (req, res) => {
+        const { override } = recordRequest("github", req);
+        delayed(override?.delayMs, () => {
+            respondWithEnvelope(res, override, defaultGithubData);
+        });
+    });
+    const server = createServer(app);
+    server.keepAliveTimeout = 0;
+    server.headersTimeout = 0;
+    await new Promise((resolve, reject) => {
+        server.once("error", reject);
+        server.listen(0, "127.0.0.1", () => {
+            server.off("error", reject);
+            resolve();
+        });
+    });
+    const address = server.address();
+    if (!address || typeof address === "string") {
+        await closeServer(server);
+        throw new Error("Mock cloud proxy server did not bind to a TCP port");
+    }
+    const port = address.port;
+    const baseUrl = `http://127.0.0.1:${port}`;
+    return {
+        port,
+        baseUrl,
+        setSlackResponse(endpoint, override) {
+            slackOverrides.set(normalizeEndpoint(endpoint), override);
+        },
+        setGithubResponse(endpoint, override) {
+            githubOverrides.set(normalizeEndpoint(endpoint), override);
+        },
+        getRequestLog() {
+            return requestLog.map((entry) => ({ ...entry }));
+        },
+        clear() {
+            slackOverrides.clear();
+            githubOverrides.clear();
+            requestLog.length = 0;
+        },
+        async close() {
+            await closeServer(server);
+        },
+    };
+}

package/dist/e2e/mock-relayfile-server.d.ts

@@ -0,0 +1,35 @@
+export interface SeedFileData {
+    content: string;
+    contentType?: string;
+    encoding?: "utf-8" | "base64";
+    revision?: string;
+    provider?: string;
+    providerObjectId?: string;
+    lastEditedAt?: string;
+    properties?: Record<string, string>;
+    asOf?: number;
+}
+export interface ResponseOverride {
+    status?: number;
+    body?: unknown;
+    delayMs?: number;
+    malformedJson?: boolean;
+}
+export interface RequestLogEntry {
+    method: string;
+    path: string;
+    timestamp: number;
+    headers: Record<string, string>;
+    body?: unknown;
+}
+export interface MockRelayfileServer {
+    port: number;
+    baseUrl: string;
+    seedFile(path: string, data: SeedFileData): void;
+    setResponse(path: string, override: ResponseOverride): void;
+    clear(): void;
+    getRequestLog(): RequestLogEntry[];
+    close(): Promise<void>;
+}
+export declare function createMockRelayfileServer(): Promise<MockRelayfileServer>;
+//# sourceMappingURL=mock-relayfile-server.d.ts.map

package/dist/e2e/mock-relayfile-server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mock-relayfile-server.d.ts","sourceRoot":"","sources":["../../src/e2e/mock-relayfile-server.ts"],"names":[],"mappings":"AAMA,MAAM,WAAW,YAAY;IAC3B,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,EAAE,OAAO,GAAG,QAAQ,CAAC;IAC9B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACpC,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,gBAAgB;IAC/B,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB;AAED,MAAM,WAAW,eAAe;IAC9B,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAChC,IAAI,CAAC,EAAE,OAAO,CAAC;CAChB;AAED,MAAM,WAAW,mBAAmB;IAClC,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,YAAY,GAAG,IAAI,CAAC;IACjD,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,gBAAgB,GAAG,IAAI,CAAC;IAC5D,KAAK,IAAI,IAAI,CAAC;IACd,aAAa,IAAI,eAAe,EAAE,CAAC;IACnC,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACxB;AAudD,wBAAsB,yBAAyB,IAAI,OAAO,CAAC,mBAAmB,CAAC,CA+K9E"}