mirror of
https://github.com/paperclipai/paperclip.git
synced 2026-11-16 03:31:44 +01:00
## Thinking Path > - Paperclip is the open source app people use to manage AI agents for work > - The board UI keeps its caches fresh from live events in `LiveUpdatesProvider` > - Each task activity event invalidates the whole `["issues", companyId]` query prefix > - That prefix also holds the `@task` mention pool: the 100 most recently updated tasks, about 315 KB per response > - A chat turn emits many comment, status and run events, so an open task page downloads that list again for almost every event > - This pull request keeps the pool fresh from push events without a refetch per event: a closed server flag marks real membership or title changes, progress on pooled tasks reorders the cache in place, and other progress refetches at most once per 30 seconds > - The benefit is less bandwidth and CPU for users with an open task or chat, and smaller eval traces ## Linked Issues or Issue Description **What happened** While a task chat page is open, the browser repeats `GET /api/companies/:id/issues?limit=100&sortField=updated&sortDir=desc` (about 315 KB each). One 10-minute chat-eval attempt recorded about 194 of these requests. The trigger is `invalidateActivityQueries` in `ui/src/context/LiveUpdatesProvider.tsx`. For every `entityType: "issue"` activity event, it invalidates `queryKeys.issues.list(companyId)`. That prefix matches `queryKeys.issues.mentionPool(companyId)`, which `IssueDetail` (and `NewIssueDialog`) keep active for the `@task` picker. Invalidation refetches active queries and ignores `staleTime`. **Expected behavior** Comments, run progress and status changes on any task do not download the full mention pool again. The pool still updates when a task that the picker can show is created, deleted or renamed. **Steps to reproduce** 1. Run `pnpm dev` and create a company with about 140 tasks. 2. Open a task page, for example `/REF/issues/REF-1`. 3. Every 4 seconds for 15 rounds, post comments on the open task, on a task in the top 100, and on a task outside the top 100, and change the open task's priority (60 events). 4. Count requests to `issues?limit=100&sortField=updated`. Before this change there are 15 (about 3.3 MB). After this change there are 2 (about 480 KB). ## What Changed - New shared helper `issueActivityChangesTaskIdentity` (`packages/shared/src/issue-activity-identity.ts`). It is true for a created, deleted, hidden, unhidden or renamed task. - `server/src/realtime/live-events-ws.ts`: task `activity.logged` events now carry the closed boolean `taskIdentityChanged`. Authenticated sockets still get no `details`; the flag carries no task content. - `ui/src/context/LiveUpdatesProvider.tsx` refreshes the mention pool this way: - The task identity flag is true (or full details show a create, delete, hide, unhide or rename): the pool refetches at once. - Other events on a task already in the pool: the task moves to the front of the cached list. There is no request. The freshness clock does not change, and a pending invalidation is never overwritten. - Other events on a task outside the pool: one trailing refetch at most every 30 seconds, because the task can now be in the top 100. - The picker is closed: the pool is only marked stale. - `ui/src/lib/query-invalidation-batcher.ts`: new `excludingQueryKeys()` keyed exclusion predicate. The batcher coalesces it and uses it for prefix coverage. The broad `["issues", companyId]` invalidation uses it to skip the pool, so a burst is again one broad refresh per batch. - Tests: `ui/src/context/LiveUpdatesProvider.mention-pool.test.ts` (authenticated event shape, hide and unhide, the 30-second window, reorder safety, a burst through the batcher), new batcher tests, `packages/shared/src/issue-activity-identity.test.ts`, and socket assertions in `server/src/__tests__/live-events-toast.test.ts`. ## Verification - `cd ui && npx vitest run src/context/LiveUpdatesProvider src/lib/query-invalidation-batcher`: 231 tests pass. - `cd server && npx vitest run src/__tests__/live-events-toast.test.ts`: 11 tests pass. In authenticated mode the socket keeps `details` off and sends `taskIdentityChanged` (false for routine updates, true for a create, rename or hide). - `cd packages/shared && npx vitest run src/issue-activity-identity.test.ts`: 14 tests pass. - The new UI tests fail against the first commit of this PR: the authenticated burst, hide, unhide, the 30-second window and the batcher burst. - `tsc --noEmit` for ui, server and shared: no new errors. - Browser measurement: a local `pnpm dev` instance (local trusted), headless Chromium on a task page, 141 tasks, 60 events over about 63 seconds (the reproduction steps above): - Before (master UI): **15** mention-pool requests, about 3.3 MB. - After: **2** requests, about 480 KB (one per 30-second window). - Freshness after the fix: one rename, hide, unhide or create each caused **1** refetch. A priority change caused **0**. - I did not run a browser session in authenticated mode. The authenticated event shape is covered by the socket test and the UI unit tests. ## Risks - A task that moves into the top 100 can be missing from the `@task` picker for up to 30 seconds. - The cached order is approximate between refetches: a moved task goes to the front, but its `updatedAt` value is not changed. - Other queries under `["issues", companyId]` (descendants, created-from, summaries, onboarding first task) still refresh for each event batch. They are small, but they can get the same treatment later. ## Model Used - Anthropic Claude Opus 5.5 (`claude-opus-5-5`), with tool use and code execution in Claude Code. ## Checklist - [x] I have included a thinking path that traces from project context to this change - [x] I have specified the model used (with version and capability details) - [x] I have checked ROADMAP.md and confirmed this PR does not duplicate planned core work - [x] I have searched GitHub for duplicate or related PRs and linked them above - [x] I have either (a) linked existing issues with `Fixes: #` / `Closes #` / `Refs #` OR (b) described the issue in-PR following the relevant issue template - [x] I have not referenced internal/instance-local Paperclip issues or links (only public GitHub `#NNN` / `github.com/paperclipai/paperclip` URLs) - [x] My branch name describes the change (e.g. `docs/...`, `fix/...`) and contains no internal Paperclip ticket id or instance-derived details - [x] I have run tests locally and they pass - [x] I have added or updated tests where applicable - [x] I have updated relevant documentation to reflect my changes - [x] I have considered and documented any risks above - [ ] All Paperclip CI gates are green - [ ] Greptile is 5/5 with no open P2s, recommendations, or follow-ups - [x] I will address all Greptile and reviewer comments before requesting merge 🤖 Generated with [Claude Code](https://claude.com/claude-code) --------- Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
477 lines
19 KiB
TypeScript
477 lines
19 KiB
TypeScript
import { createLiveEventDelivery } from "./live-event-delivery.js";
|
|
import { skillAccessService } from "../services/skill-access.js";
|
|
import { createHash } from "node:crypto";
|
|
import type { IncomingMessage, Server as HttpServer } from "node:http";
|
|
import { createRequire } from "node:module";
|
|
import type { Duplex } from "node:stream";
|
|
import { and, eq, isNull } from "drizzle-orm";
|
|
import type { Db } from "@paperclipai/db";
|
|
import { agentApiKeys, companyMemberships, instanceUserRoles, heartbeatRuns, projects } from "@paperclipai/db";
|
|
import { issueActivityChangesTaskIdentity, type DeploymentMode, type LiveEvent } from "@paperclipai/shared";
|
|
import type { BetterAuthSessionResult } from "../auth/better-auth.js";
|
|
import { logger } from "../middleware/logger.js";
|
|
import { activityToastIdentity } from "./activity-toast-identity.js";
|
|
import { taskToastEligible } from "./task-toast-eligibility.js";
|
|
import { subscribeCompanyLiveEvents } from "../services/live-events.js";
|
|
import { trackIdleWork } from "../services/task-admission.js";
|
|
import { createLiveRunEventRedactor } from "../services/live-run-event-redaction.js";
|
|
|
|
interface WsSocket {
|
|
readyState: number;
|
|
ping(): void;
|
|
bufferedAmount?: number;
|
|
send(data: string, callback?: (error?: Error) => void): void;
|
|
on(event: "message", listener: (data: Buffer, isBinary: boolean) => void): void;
|
|
terminate(): void;
|
|
close(code?: number, reason?: string): void;
|
|
on(event: "pong", listener: () => void): void;
|
|
on(event: "close", listener: () => void): void;
|
|
on(event: "error", listener: (err: Error) => void): void;
|
|
}
|
|
|
|
interface WsServer {
|
|
clients: Set<WsSocket>;
|
|
close(): void;
|
|
on(event: "connection", listener: (socket: WsSocket, req: IncomingMessage) => void): void;
|
|
on(event: "close", listener: () => void): void;
|
|
handleUpgrade(
|
|
req: IncomingMessage,
|
|
socket: Duplex,
|
|
head: Buffer,
|
|
callback: (ws: WsSocket) => void,
|
|
): void;
|
|
emit(event: "connection", ws: WsSocket, req: IncomingMessage): boolean;
|
|
}
|
|
|
|
const require = createRequire(import.meta.url);
|
|
const { WebSocket, WebSocketServer } = require("ws") as {
|
|
WebSocket: { OPEN: number };
|
|
WebSocketServer: new (opts: { noServer: boolean; maxPayload: number }) => WsServer;
|
|
};
|
|
|
|
import { authorizationService, type AuthorizationActor } from "../services/authorization.js";
|
|
import { getHeartbeatRunReadDecisions } from "../services/heartbeat-run-privacy.js";
|
|
import { canActorReadCase } from "../services/case-access.js";
|
|
|
|
interface UpgradeContext {
|
|
actor: AuthorizationActor;
|
|
apiKeyId?: string;
|
|
companyId: string;
|
|
actorType: "board" | "agent";
|
|
actorId: string;
|
|
}
|
|
|
|
/** Cloud-proxied browser identity resolved from trusted x-paperclip-cloud-* headers. */
|
|
export interface CloudUpgradeActor {
|
|
userId: string;
|
|
/** Companies this actor may subscribe to (primary stack company + real memberships). */
|
|
companyIds: string[];
|
|
}
|
|
|
|
interface IncomingMessageWithContext extends IncomingMessage {
|
|
paperclipWebSocketHandled?: boolean;
|
|
paperclipUpgradeContext?: UpgradeContext;
|
|
}
|
|
|
|
function hashToken(token: string) {
|
|
return createHash("sha256").update(token).digest("hex");
|
|
}
|
|
|
|
function isWritableUpgradeSocket(socket: Duplex) {
|
|
const maybeWritableState = socket as Duplex & { writable?: boolean; writableEnded?: boolean; writableDestroyed?: boolean };
|
|
return !socket.destroyed && maybeWritableState.writable !== false && !maybeWritableState.writableEnded && !maybeWritableState.writableDestroyed;
|
|
}
|
|
|
|
function closeUpgradeSocket(socket: Duplex) {
|
|
if (!socket.destroyed) {
|
|
socket.destroy();
|
|
}
|
|
}
|
|
|
|
function rejectUpgrade(socket: Duplex, statusLine: string, message: string) {
|
|
const safe = message.replace(/[\r\n]+/g, " ").trim();
|
|
if (!isWritableUpgradeSocket(socket)) {
|
|
closeUpgradeSocket(socket);
|
|
return;
|
|
}
|
|
|
|
try {
|
|
socket.once("finish", () => closeUpgradeSocket(socket));
|
|
socket.end(`HTTP/1.1 ${statusLine}\r\nConnection: close\r\nContent-Type: text/plain\r\n\r\n${safe}`);
|
|
} catch (err) {
|
|
logger.warn({ err }, "failed to reject live websocket upgrade");
|
|
closeUpgradeSocket(socket);
|
|
}
|
|
}
|
|
|
|
function parseCompanyId(pathname: string) {
|
|
const match = pathname.match(/^\/api\/companies\/([^/]+)\/events\/ws$/);
|
|
if (!match) return null;
|
|
|
|
try {
|
|
return decodeURIComponent(match[1] ?? "");
|
|
} catch {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
function parseBearerToken(rawAuth: string | string[] | undefined) {
|
|
const auth = Array.isArray(rawAuth) ? rawAuth[0] : rawAuth;
|
|
if (!auth) return null;
|
|
if (!auth.toLowerCase().startsWith("bearer ")) return null;
|
|
const token = auth.slice("bearer ".length).trim();
|
|
return token.length > 0 ? token : null;
|
|
}
|
|
|
|
function headersFromIncomingMessage(req: IncomingMessage): Headers {
|
|
const headers = new Headers();
|
|
for (const [key, raw] of Object.entries(req.headers)) {
|
|
if (!raw) continue;
|
|
if (Array.isArray(raw)) {
|
|
for (const value of raw) headers.append(key, value);
|
|
continue;
|
|
}
|
|
headers.set(key, raw);
|
|
}
|
|
return headers;
|
|
}
|
|
|
|
async function authorizeUpgrade(
|
|
db: Db,
|
|
req: IncomingMessage,
|
|
companyId: string,
|
|
url: URL,
|
|
opts: {
|
|
deploymentMode: DeploymentMode;
|
|
resolveSessionFromHeaders?: (headers: Headers) => Promise<BetterAuthSessionResult | null>;
|
|
resolveCloudActor?: (req: IncomingMessage) => Promise<CloudUpgradeActor | null>;
|
|
},
|
|
): Promise<UpgradeContext | null> {
|
|
const queryToken = url.searchParams.get("token")?.trim() ?? "";
|
|
const authToken = parseBearerToken(req.headers.authorization);
|
|
const token = authToken ?? (queryToken.length > 0 ? queryToken : null);
|
|
|
|
// Browser board context has no bearer token in local_trusted and authenticated modes.
|
|
if (!token) {
|
|
if (opts.deploymentMode === "local_trusted") {
|
|
return {
|
|
companyId,
|
|
actorType: "board",
|
|
actorId: "board",
|
|
actor: { type: "board", userId: "local-board", source: "local_implicit" },
|
|
};
|
|
}
|
|
|
|
// Cloud-managed deployments authenticate proxied browsers with trusted
|
|
// x-paperclip-cloud-* headers, never a local Better Auth session — the
|
|
// session fallback below can only 403 them, which left the live-events
|
|
// socket permanently unreachable behind the Cloud front door. A resolved
|
|
// cloud actor is authoritative: authorize against its membership scope.
|
|
// Absent/invalid cloud headers fall through to the session path, so
|
|
// self-hosted behavior is unchanged.
|
|
if (opts.resolveCloudActor) {
|
|
const cloudActor = await opts.resolveCloudActor(req);
|
|
if (cloudActor) {
|
|
if (!cloudActor.companyIds.includes(companyId)) return null;
|
|
return {
|
|
companyId,
|
|
actorType: "board",
|
|
actorId: cloudActor.userId,
|
|
actor: { type: "board", userId: cloudActor.userId, source: "cloud_tenant", companyIds: cloudActor.companyIds },
|
|
};
|
|
}
|
|
}
|
|
|
|
if (opts.deploymentMode !== "authenticated" || !opts.resolveSessionFromHeaders) {
|
|
return null;
|
|
}
|
|
|
|
const session = await opts.resolveSessionFromHeaders(headersFromIncomingMessage(req));
|
|
const userId = session?.user?.id;
|
|
if (!userId) return null;
|
|
|
|
const [roleRow, memberships] = await Promise.all([
|
|
db
|
|
.select({ id: instanceUserRoles.id })
|
|
.from(instanceUserRoles)
|
|
.where(and(eq(instanceUserRoles.userId, userId), eq(instanceUserRoles.role, "instance_admin")))
|
|
.then((rows) => rows[0] ?? null),
|
|
db
|
|
.select({ companyId: companyMemberships.companyId })
|
|
.from(companyMemberships)
|
|
.where(
|
|
and(
|
|
eq(companyMemberships.principalType, "user"),
|
|
eq(companyMemberships.principalId, userId),
|
|
eq(companyMemberships.status, "active"),
|
|
),
|
|
),
|
|
]);
|
|
|
|
const hasCompanyMembership = memberships.some((row) => row.companyId === companyId);
|
|
if (!roleRow && !hasCompanyMembership) return null;
|
|
|
|
return {
|
|
companyId,
|
|
actorType: "board",
|
|
actorId: userId,
|
|
actor: { type: "board", userId, source: "session", companyIds: memberships.map(m => m.companyId) },
|
|
};
|
|
}
|
|
|
|
const tokenHash = hashToken(token);
|
|
const key = await db
|
|
.select()
|
|
.from(agentApiKeys)
|
|
.where(and(eq(agentApiKeys.keyHash, tokenHash), isNull(agentApiKeys.revokedAt)))
|
|
.then((rows) => rows[0] ?? null);
|
|
|
|
if (!key || key.companyId !== companyId || key.scopeConfig) {
|
|
return null;
|
|
}
|
|
|
|
await db
|
|
.update(agentApiKeys)
|
|
.set({ lastUsedAt: new Date() })
|
|
.where(eq(agentApiKeys.id, key.id));
|
|
|
|
return {
|
|
companyId,
|
|
actorType: "agent",
|
|
actorId: key.agentId,
|
|
apiKeyId: key.id,
|
|
actor: { type: "agent", agentId: key.agentId, companyId, source: "agent_key", onBehalfOfUserId: key.responsibleUserId },
|
|
};
|
|
}
|
|
|
|
export function setupLiveEventsWebSocketServer(
|
|
server: HttpServer,
|
|
db: Db,
|
|
opts: {
|
|
deploymentMode: DeploymentMode;
|
|
subscribeInvalidation?: (companyId: string, resync: () => void) => () => void;
|
|
resolveSessionFromHeaders?: (headers: Headers) => Promise<BetterAuthSessionResult | null>;
|
|
/**
|
|
* Resolves a Cloud-proxied browser's identity from the trusted
|
|
* x-paperclip-cloud-* headers on the upgrade request. Wired by managed
|
|
* deployments; self-hosted instances leave it unset.
|
|
*/
|
|
resolveCloudActor?: (req: IncomingMessage) => Promise<CloudUpgradeActor | null>;
|
|
},
|
|
) {
|
|
const wss = new WebSocketServer({ noServer: true, maxPayload: 64 * 1024 });
|
|
const redactRunEvent = createLiveRunEventRedactor(db);
|
|
const cleanupByClient = new Map<WsSocket, () => void>();
|
|
const aliveByClient = new Map<WsSocket, boolean>();
|
|
|
|
const pingInterval = setInterval(() => {
|
|
for (const socket of wss.clients) {
|
|
if (!aliveByClient.get(socket)) {
|
|
socket.terminate();
|
|
continue;
|
|
}
|
|
aliveByClient.set(socket, false);
|
|
socket.ping();
|
|
}
|
|
}, 30000);
|
|
|
|
wss.on("connection", (socket: WsSocket, req: IncomingMessage) => {
|
|
const context = (req as IncomingMessageWithContext).paperclipUpgradeContext;
|
|
if (!context) {
|
|
socket.close(1008, "missing context");
|
|
return;
|
|
}
|
|
|
|
const access = authorizationService(db);
|
|
async function visibleEvent(event: LiveEvent): Promise<LiveEvent | null> {
|
|
if (event.payload.entityType === "case" && (typeof event.payload.entityId !== "string"
|
|
|| !(await canActorReadCase(db, context!.actor, { id: event.payload.entityId, companyId: event.companyId })))) return null;
|
|
if (context!.actor.source === "local_implicit") {
|
|
if (event.type === "activity.logged" && event.payload.entityType === "issue") {
|
|
return { ...event, payload: { ...event.payload,
|
|
taskIdentityChanged: issueActivityChangesTaskIdentity(event.payload.action, event.payload.details),
|
|
...await activityToastIdentity(db, event.companyId, event.payload) } };
|
|
}
|
|
return event;
|
|
}
|
|
if (context!.apiKeyId) {
|
|
const active = await db.select({ id: agentApiKeys.id }).from(agentApiKeys)
|
|
.where(and(eq(agentApiKeys.id, context!.apiKeyId), isNull(agentApiKeys.revokedAt))).limit(1);
|
|
if (!active.length) return null;
|
|
} else {
|
|
const membership = await db.select({ id: companyMemberships.id }).from(companyMemberships)
|
|
.where(and(eq(companyMemberships.companyId, context!.companyId), eq(companyMemberships.principalType, "user"),
|
|
eq(companyMemberships.principalId, context!.actorId), eq(companyMemberships.status, "active"))).limit(1);
|
|
const admin = context!.actor.source !== "cloud_tenant" && await db.select({ id: instanceUserRoles.id }).from(instanceUserRoles)
|
|
.where(and(eq(instanceUserRoles.userId, context!.actorId), eq(instanceUserRoles.role, "instance_admin"))).limit(1).then(rows => rows.length > 0);
|
|
if (!membership.length && !admin) return null;
|
|
}
|
|
const payload = event.payload;
|
|
const issueId = typeof payload.issueId === "string" ? payload.issueId
|
|
: payload.entityType === "issue" && typeof payload.entityId === "string" ? payload.entityId : null;
|
|
const runId = typeof payload.runId === "string" ? payload.runId
|
|
: payload.entityType === "heartbeat_run" && typeof payload.entityId === "string" ? payload.entityId : null;
|
|
if (event.type === "heartbeat.run.event" || event.type === "heartbeat.run.log") {
|
|
const decision = await access.decide({ actor: context!.actor, action: "company_scope:read",
|
|
resource: { type: "company", companyId: event.companyId } });
|
|
if (!decision.allowed) return null;
|
|
}
|
|
const readBindings: Parameters<typeof getHeartbeatRunReadDecisions>[3][number][] = [];
|
|
if (issueId) {
|
|
readBindings.push({ companyId: event.companyId, scopeKind: "issue", issueId });
|
|
}
|
|
if (runId) {
|
|
const [run] = await db.select({
|
|
companyId: heartbeatRuns.companyId,
|
|
scopeKind: heartbeatRuns.scopeKind,
|
|
issueId: heartbeatRuns.issueId,
|
|
}).from(heartbeatRuns).where(and(eq(heartbeatRuns.id, runId), eq(heartbeatRuns.companyId, event.companyId)));
|
|
if (!run) return null;
|
|
readBindings.push(run);
|
|
}
|
|
if ((await getHeartbeatRunReadDecisions(db, access, context!.actor, readBindings)).some(allowed => !allowed)) return null;
|
|
if (["company_skill", "company_skill_source"].includes(String(payload.entityType)) && typeof payload.entityId === "string") {
|
|
try {
|
|
const skills = skillAccessService(db, context!.actor);
|
|
if (payload.entityType === "company_skill") await skills.assertSkill(event.companyId, payload.entityId);
|
|
else await skills.assertSource(event.companyId, payload.entityId);
|
|
} catch { return null; }
|
|
}
|
|
if (payload.entityType === "project" && typeof payload.entityId === "string") {
|
|
const [project] = await db.select({ id: projects.id }).from(projects)
|
|
.where(and(eq(projects.id, payload.entityId), eq(projects.companyId, event.companyId))).limit(1);
|
|
if (!project || !(await access.decide({ actor: context!.actor, action: "project:read",
|
|
resource: { type: "project", companyId: event.companyId, projectId: project.id } })).allowed) return null;
|
|
}
|
|
if (event.type.startsWith("heartbeat.run.")) return runId ? event : null;
|
|
if (event.type === "agent.session.goal.changed") return issueId ? event : null;
|
|
// Company-wide invalidations carry no task-derived content. Authorized
|
|
// clients obtain details through viewer-filtered HTTP reads.
|
|
if (event.type === "activity.logged") return { ...event, payload: {
|
|
action: payload.action, entityType: payload.entityType, entityId: payload.entityId,
|
|
// A handoff can attach the first case to a task. Its already-authorized
|
|
// task identity lets an empty cases panel refresh without exposing content.
|
|
...(payload.entityType === "case" && String(payload.action).startsWith("case.handoff_") && issueId ? { issueId } : {}),
|
|
// A closed boolean derived from details, so task pickers can tell a
|
|
// created, deleted, hidden or renamed task from routine progress.
|
|
...(payload.entityType === "issue"
|
|
? { taskIdentityChanged: issueActivityChangesTaskIdentity(payload.action, payload.details) }
|
|
: {}),
|
|
// The task read check above authorizes attribution, but not arbitrary details.
|
|
...(issueId ? await activityToastIdentity(db, event.companyId, payload) : {}),
|
|
} };
|
|
if (event.type === "agent.status") return { ...event, payload: { agentId: payload.agentId, status: payload.status } };
|
|
if (event.type === "agent.runtime_state.updated") return { ...event, payload: { agentId: payload.agentId } };
|
|
if (event.type === "external_object.updated") return { ...event, payload: { externalObjectId: payload.externalObjectId } };
|
|
if (event.type.startsWith("plugin.")) return event;
|
|
return null;
|
|
}
|
|
const delivery = createLiveEventDelivery({ socket, authorize: async event => {
|
|
const visible = await visibleEvent(event);
|
|
if (!visible || visible.type !== "heartbeat.run.event") return visible;
|
|
const payload = visible.payload.payload;
|
|
if (!payload || typeof payload !== "object" || Array.isArray(payload) || !("prpEvent" in payload)) return visible;
|
|
return redactRunEvent(visible);
|
|
},
|
|
decorate: async visible => {
|
|
let toastEligible = false;
|
|
try {
|
|
toastEligible = await taskToastEligible(db, visible,
|
|
context.actor.type === "board" ? context.actor.userId ?? null : null);
|
|
} catch (err) { logger.warn({ err, companyId: context.companyId }, "task toast eligibility failed"); }
|
|
return { ...visible, toastEligible };
|
|
},
|
|
onError: err => logger.warn({ err, companyId: context.companyId }, "live event authorization failed"),
|
|
});
|
|
const unsubscribe = subscribeCompanyLiveEvents(context.companyId, event => delivery.enqueue(event));
|
|
const unsubscribeInvalidation = opts.subscribeInvalidation?.(context.companyId, delivery.requestResync);
|
|
socket.on("message", (data, isBinary) => {
|
|
if (isBinary) { socket.close(1003, "text messages required"); return; }
|
|
delivery.receive(data.toString());
|
|
});
|
|
cleanupByClient.set(socket, () => { unsubscribe(); unsubscribeInvalidation?.(); delivery.dispose(); });
|
|
aliveByClient.set(socket, true);
|
|
|
|
socket.on("pong", () => {
|
|
aliveByClient.set(socket, true);
|
|
});
|
|
|
|
socket.on("close", () => {
|
|
const cleanup = cleanupByClient.get(socket);
|
|
if (cleanup) cleanup();
|
|
cleanupByClient.delete(socket);
|
|
aliveByClient.delete(socket);
|
|
});
|
|
|
|
socket.on("error", (err: Error) => {
|
|
logger.warn({ err, companyId: context.companyId }, "live websocket client error");
|
|
});
|
|
});
|
|
|
|
wss.on("close", () => {
|
|
clearInterval(pingInterval);
|
|
});
|
|
|
|
server.on("upgrade", (req, socket, head) => {
|
|
if ((req as IncomingMessageWithContext).paperclipWebSocketHandled) {
|
|
return;
|
|
}
|
|
|
|
const onRawSocketError = (err: Error) => {
|
|
logger.warn({ err, path: req.url }, "live websocket upgrade socket error");
|
|
};
|
|
const cleanupRawSocketListeners = () => {
|
|
socket.off("error", onRawSocketError);
|
|
socket.off("close", cleanupRawSocketListeners);
|
|
};
|
|
|
|
socket.on("error", onRawSocketError);
|
|
socket.once("close", cleanupRawSocketListeners);
|
|
|
|
if (!req.url) {
|
|
rejectUpgrade(socket, "400 Bad Request", "missing url");
|
|
return;
|
|
}
|
|
|
|
const url = new URL(req.url, "http://localhost");
|
|
const companyId = parseCompanyId(url.pathname);
|
|
if (!companyId) {
|
|
closeUpgradeSocket(socket);
|
|
return;
|
|
}
|
|
|
|
// Upgrade admission precedes this async authentication. An idle hold or
|
|
// socket close must not make its accepted database writes disappear.
|
|
void trackIdleWork(authorizeUpgrade(db, req, companyId, url, {
|
|
deploymentMode: opts.deploymentMode,
|
|
resolveSessionFromHeaders: opts.resolveSessionFromHeaders,
|
|
resolveCloudActor: opts.resolveCloudActor,
|
|
})
|
|
.then((context) => {
|
|
if (!context) {
|
|
rejectUpgrade(socket, "403 Forbidden", "forbidden");
|
|
return;
|
|
}
|
|
|
|
if (!isWritableUpgradeSocket(socket)) {
|
|
cleanupRawSocketListeners();
|
|
return;
|
|
}
|
|
|
|
const reqWithContext = req as IncomingMessageWithContext;
|
|
reqWithContext.paperclipUpgradeContext = context;
|
|
|
|
cleanupRawSocketListeners();
|
|
wss.handleUpgrade(req, socket, head, (ws: WsSocket) => {
|
|
wss.emit("connection", ws, reqWithContext);
|
|
});
|
|
})
|
|
.catch((err) => {
|
|
logger.error({ err, path: req.url }, "failed websocket upgrade authorization");
|
|
rejectUpgrade(socket, "500 Internal Server Error", "upgrade failed");
|
|
}));
|
|
});
|
|
|
|
return wss;
|
|
}
|