@mquan/portal 0.0.1

package/dist/src/service.js

@@ -0,0 +1,637 @@
+import { ClaudeProvider } from "./provider/claude.js";
+import { CodexProvider } from "./provider/codex/provider.js";
+import { deriveSessionProfile, normalizeSessionReference, rankSessionCandidates, } from "./session-profile.js";
+import { PortalIndex, redactSecrets } from "./portal-index.js";
+/** Coordinates adapters, the durable index, recall, and the message queue. */
+export class PortalService {
+    index;
+    providers;
+    #closed = false;
+    constructor(options) {
+        this.index = new PortalIndex({ databasePath: options.databasePath });
+        this.providers = options.providers ?? [new CodexProvider(), new ClaudeProvider()];
+    }
+    async close() {
+        this.#closed = true;
+        for (const provider of this.providers) {
+            const close = provider.close;
+            if (close !== undefined)
+                await close.call(provider);
+        }
+        this.index.close();
+    }
+    async refresh(options = {}) {
+        const selected = new Set(options.providers ?? this.providers.map(({ name }) => name));
+        const result = { observed: 0, indexed: 0, unchanged: 0, errors: [], sessions: [] };
+        await Promise.all(this.providers.filter(({ name }) => selected.has(name)).map(async (provider) => {
+            let sessions;
+            try {
+                sessions = await provider.listSessions();
+            }
+            catch (error) {
+                result.errors.push({ provider: provider.name, vendorSessionId: null, message: errorMessage(error) });
+                return;
+            }
+            const observedPortalIds = new Set();
+            for (const observed of sessions) {
+                if (options.workspace !== undefined && observed.workspace !== options.workspace)
+                    continue;
+                result.observed += 1;
+                const existing = this.index.repository.findSession({
+                    provider: observed.provider,
+                    vendorSessionId: observed.vendorSessionId,
+                });
+                const stored = this.index.upsertSession({
+                    provider: observed.provider,
+                    vendorSessionId: observed.vendorSessionId,
+                    workspace: observed.workspace,
+                    title: observed.title,
+                    updatedAt: observed.updatedAt,
+                    state: observed.state,
+                    stateConfidence: observed.stateConfidence,
+                    indexed: existing?.indexed ?? false,
+                    connected: observed.connected,
+                    messageable: observed.messageable,
+                });
+                observedPortalIds.add(stored.portalSessionId);
+                const sourceScope = `session:${stored.portalSessionId}`;
+                const cursor = this.index.repository.getCursor(provider.name, sourceScope);
+                if (isUnchanged(existing, observed, cursor?.watermark ?? null) &&
+                    this.index.repository.getSessionProfile(stored.portalSessionId) !== null) {
+                    result.unchanged += 1;
+                    returnSession(result, stored);
+                    continue;
+                }
+                try {
+                    const transcript = await provider.readTranscript(observed.vendorSessionId);
+                    if (transcript.length === 0 &&
+                        existing?.indexed === true &&
+                        this.index.repository.countTranscriptEntries(stored.portalSessionId) > 0) {
+                        throw new Error("provider returned an empty transcript for a previously non-empty session");
+                    }
+                    await this.index.ingestTranscript(stored.portalSessionId, transcript);
+                    this.saveDerivedProfile(stored, transcript, observed.updatedAt?.toISOString() ?? null);
+                    this.index.repository.upsertCursor({
+                        provider: provider.name,
+                        sourceScope,
+                        cursor: null,
+                        watermark: observed.updatedAt?.toISOString() ?? null,
+                        lastSuccess: new Date(),
+                        lastError: null,
+                    });
+                    result.indexed += 1;
+                }
+                catch (error) {
+                    this.index.repository.upsertCursor({
+                        provider: provider.name,
+                        sourceScope,
+                        cursor: cursor?.cursor ?? null,
+                        watermark: cursor?.watermark ?? null,
+                        lastSuccess: cursor?.lastSuccess ?? null,
+                        lastError: errorMessage(error),
+                    });
+                    result.errors.push({
+                        provider: provider.name,
+                        vendorSessionId: observed.vendorSessionId,
+                        message: errorMessage(error),
+                    });
+                }
+                returnSession(result, this.index.repository.getSession(stored.portalSessionId) ?? stored);
+            }
+            const priorSessions = this.index.repository
+                .listSessions(options.workspace)
+                .filter(({ provider: name }) => name === provider.name);
+            for (const prior of priorSessions) {
+                if (observedPortalIds.has(prior.portalSessionId))
+                    continue;
+                this.index.upsertSession({
+                    provider: prior.provider,
+                    vendorSessionId: prior.vendorSessionId,
+                    workspace: prior.workspace,
+                    title: prior.title,
+                    updatedAt: prior.updatedAt,
+                    state: "unknown",
+                    stateConfidence: "unavailable",
+                    indexed: prior.indexed,
+                    connected: false,
+                    messageable: false,
+                });
+            }
+        }));
+        result.sessions.sort(compareSessions);
+        return result;
+    }
+    listSessions(workspace) {
+        return this.index.repository.listSessions(workspace).map((session) => {
+            const portalConnected = this.index.repository.hasActiveConnectionLease(session.portalSessionId);
+            const resolved = portalConnected
+                ? { ...session, connected: true, messageable: true }
+                : session;
+            return {
+                ...resolved,
+                profile: this.index.repository.getSessionProfile(session.portalSessionId),
+                reachability: this.sessionReachability(session),
+            };
+        });
+    }
+    resolveSession(reference, workspace) {
+        const sessions = this.listSessions(workspace);
+        const portalIdMatches = sessions.filter((session) => session.portalSessionId === reference);
+        if (portalIdMatches.length > 0)
+            return requireUniqueSession(reference, portalIdMatches);
+        const vendorIdMatches = sessions.filter((session) => session.vendorSessionId === reference);
+        if (vendorIdMatches.length > 0)
+            return requireUniqueSession(reference, vendorIdMatches);
+        const exactManaged = sessions.filter((session) => session.managedName === reference);
+        if (exactManaged.length > 0)
+            return requirePreferredSession(reference, exactManaged);
+        const exactTitles = sessions.filter((session) => session.title === reference);
+        if (exactTitles.length > 0)
+            return requirePreferredSession(reference, exactTitles);
+        const normalized = normalizeSessionReference(reference);
+        const normalizedManaged = sessions.filter((session) => session.managedName !== null && normalizeSessionReference(session.managedName) === normalized);
+        if (normalizedManaged.length > 0)
+            return requirePreferredSession(reference, normalizedManaged);
+        const profileMatches = sessions.filter((session) => session.profile !== null && normalizeSessionReference(session.profile.displayName) === normalized);
+        if (profileMatches.length > 0)
+            return requirePreferredSession(reference, profileMatches);
+        const normalizedTitles = sessions.filter((session) => session.title !== null && normalizeSessionReference(session.title) === normalized);
+        if (normalizedTitles.length > 0)
+            return requirePreferredSession(reference, normalizedTitles);
+        throw new Error(`no Portal session matches: ${reference}`);
+    }
+    issueSessionCredential(reference, workspace) {
+        const session = this.resolveSession(reference, workspace);
+        return {
+            sessionId: session.portalSessionId,
+            token: this.index.repository.issueSessionCredential(session.portalSessionId),
+        };
+    }
+    prepareManagedSession(input) {
+        if (input.workspace.trim().length === 0)
+            throw new TypeError("managed session requires a workspace");
+        const managedName = input.managedName ?? input.title ?? null;
+        if (managedName !== null && managedName.trim().length === 0) {
+            throw new TypeError("managed session name cannot be empty");
+        }
+        const session = this.index.upsertSession({
+            provider: input.provider,
+            vendorSessionId: input.vendorSessionId,
+            workspace: input.workspace,
+            title: null,
+            managedName,
+            updatedAt: new Date(),
+            state: "idle",
+            stateConfidence: "inferred",
+            indexed: false,
+            connected: false,
+            messageable: false,
+        });
+        const profile = deriveSessionProfile({
+            managedName,
+            initialPrompt: input.initialPrompt === undefined || input.initialPrompt === null
+                ? null
+                : redactSecrets(input.initialPrompt),
+        });
+        this.index.repository.upsertSessionProfile({
+            sessionId: session.portalSessionId,
+            ...profile,
+            source: managedName === null ? "derived" : "explicit",
+            transcriptWatermark: null,
+        });
+        return {
+            session,
+            token: this.index.repository.issueSessionCredential(session.portalSessionId),
+        };
+    }
+    authenticateSession(sessionId, token) {
+        const session = this.index.repository.authenticateSession(sessionId, token);
+        this.index.repository.touchConnectionLease(sessionId);
+        return session;
+    }
+    disconnectSession(sessionId, token) {
+        this.index.repository.authenticateSession(sessionId, token);
+        this.index.repository.clearConnectionLease(sessionId);
+    }
+    finishManagedSession(sessionId, token) {
+        this.index.repository.authenticateSession(sessionId, token);
+        this.index.repository.clearConnectionLease(sessionId);
+        this.index.repository.clearRunnerLease(sessionId);
+        this.index.repository.revokeSessionCredential(token);
+    }
+    bindManagedSession(sessionId, token, vendorSessionId) {
+        const session = this.index.repository.authenticateSession(sessionId, token);
+        if (session.provider !== "codex" || !session.vendorSessionId.startsWith("pending:")) {
+            throw new Error("managed session is not awaiting a Codex vendor binding");
+        }
+        if (vendorSessionId.trim().length === 0 || vendorSessionId.startsWith("pending:")) {
+            throw new Error("Codex vendor session ID is invalid");
+        }
+        return this.index.repository.bindSessionVendorId(sessionId, vendorSessionId);
+    }
+    async recall(query, options) {
+        if (options.refresh !== false) {
+            await this.refresh({
+                workspace: options.workspace,
+                ...(options.providers === undefined ? {} : { providers: options.providers }),
+            });
+        }
+        const { refresh: _refresh, ...recallOptions } = options;
+        return this.index.recall(query, recallOptions);
+    }
+    async send(input) {
+        if (input.body.trim().length === 0)
+            throw new TypeError("message body cannot be empty");
+        if (Buffer.byteLength(input.body, "utf8") > 32 * 1024) {
+            throw new RangeError("message body exceeds 32 KiB");
+        }
+        const sender = this.index.repository.getSession(input.senderSessionId);
+        if (sender === null)
+            throw new Error(`unknown Portal session: ${input.senderSessionId}`);
+        if (sender.workspace === null)
+            throw new Error("message sender has no workspace");
+        const existing = input.idempotencyKey === undefined
+            ? null
+            : this.index.repository.getMessageByIdempotency(input.senderSessionId, input.idempotencyKey);
+        if (existing === null) {
+            const recent = this.index.repository.countMessagesSince(input.senderSessionId, new Date(Date.now() - 60_000));
+            if (recent >= 20)
+                throw new Error("message rate limit exceeded: 20 messages per minute");
+        }
+        const resolved = existing === null
+            ? this.resolveMessageTarget(sender, input.targetSessionId, input.targetReference, input.body)
+            : {
+                targetSessionId: existing.targetSessionId,
+                resolution: {
+                    status: "resolved",
+                    query: input.targetReference ?? input.body,
+                    strategy: "idempotent",
+                    targetSessionId: existing.targetSessionId,
+                    candidates: [],
+                },
+            };
+        if (resolved.targetSessionId === null) {
+            return { message: null, delivery: "not_sent", resolution: resolved.resolution };
+        }
+        if (resolved.targetSessionId === input.senderSessionId) {
+            throw new Error("a session cannot send a blocking Portal message to itself");
+        }
+        if (this.index.repository.hasRunningDelivery(resolved.targetSessionId, input.senderSessionId)) {
+            throw new Error("Portal rejected a reciprocal delivery cycle while the reverse message is still running");
+        }
+        const message = this.index.repository.enqueueMessage({
+            senderSessionId: input.senderSessionId,
+            targetSessionId: resolved.targetSessionId,
+            body: input.body,
+            idempotencyKey: input.idempotencyKey ?? this.index.repository.createMessageIdempotencyKey(),
+            ...(input.replyTo === undefined ? {} : { replyTo: input.replyTo }),
+        });
+        if (message.state === "delivered") {
+            const receipt = this.index.repository.getMessageReceipt(message.messageId);
+            return receipt === null
+                ? { message, delivery: "delivered", resolution: resolved.resolution }
+                : { message, delivery: "completed", receipt, resolution: resolved.resolution };
+        }
+        if (this.index.repository.hasActiveRunnerLease(resolved.targetSessionId)) {
+            const receipt = await this.waitForRunnerCompletion(message.messageId, resolved.targetSessionId);
+            const updated = this.index.repository.getMessage(message.messageId) ?? message;
+            if (receipt?.status === "completed") {
+                return { message: updated, delivery: "completed", receipt, resolution: resolved.resolution };
+            }
+            if (receipt?.status === "failed") {
+                return { message: updated, delivery: "failed", receipt, resolution: resolved.resolution };
+            }
+        }
+        const inboxConnected = this.index.repository.hasActiveConnectionLease(resolved.targetSessionId);
+        return {
+            message,
+            delivery: inboxConnected ? "queued_inbox" : "queued_unavailable",
+            resolution: resolved.resolution,
+        };
+    }
+    resolveMessageTarget(sender, targetSessionId, targetReference, body) {
+        const query = targetReference ?? body;
+        if (targetSessionId !== undefined) {
+            const target = this.index.repository.getSession(targetSessionId);
+            if (target === null)
+                throw new Error(`unknown Portal session: ${targetSessionId}`);
+            return {
+                targetSessionId,
+                resolution: { status: "resolved", query, strategy: "id", targetSessionId, candidates: [] },
+            };
+        }
+        if (targetReference !== undefined) {
+            try {
+                const target = this.resolveSession(targetReference, sender.workspace ?? undefined);
+                const normalized = normalizeSessionReference(targetReference);
+                const exact = target.portalSessionId === targetReference || target.vendorSessionId === targetReference;
+                const strategy = exact ? "id" :
+                    target.managedName === targetReference || target.title === targetReference ? "exact" :
+                        target.managedName !== null && normalizeSessionReference(target.managedName) === normalized
+                            ? "normalized"
+                            : "profile";
+                return {
+                    targetSessionId: target.portalSessionId,
+                    resolution: {
+                        status: "resolved", query, strategy, targetSessionId: target.portalSessionId, candidates: [],
+                    },
+                };
+            }
+            catch (error) {
+                if (!errorMessage(error).startsWith("no Portal session matches:"))
+                    throw error;
+            }
+        }
+        const ranked = this.rankedRoutingCandidates(query, sender);
+        const active = ranked.filter(({ reachability }) => reachability === "active_runner");
+        const top = active[0];
+        const second = active[1];
+        const sufficientlyRelevant = top !== undefined && top.score >= 0.3;
+        const clearlySeparated = top !== undefined && (second === undefined || top.score - second.score >= 0.15);
+        const candidates = ranked.slice(0, 5).map(toResolutionCandidate);
+        if (sufficientlyRelevant && clearlySeparated) {
+            return {
+                targetSessionId: top.portalSessionId,
+                resolution: {
+                    status: "resolved",
+                    query,
+                    strategy: "intent",
+                    targetSessionId: top.portalSessionId,
+                    candidates: [toResolutionCandidate(top)],
+                },
+            };
+        }
+        return {
+            targetSessionId: null,
+            resolution: {
+                status: sufficientlyRelevant ? "ambiguous" : "unresolved",
+                query,
+                candidates,
+            },
+        };
+    }
+    rankedRoutingCandidates(query, sender) {
+        const sessions = this.listSessions(sender.workspace ?? undefined);
+        return rankSessionCandidates(query, sessions.map((session) => ({
+            portalSessionId: session.portalSessionId,
+            workspace: session.workspace,
+            displayName: session.profile?.displayName ?? session.managedName ?? session.title ?? "unnamed-session",
+            description: session.profile?.description ?? session.title ?? "Unidentified session",
+            topics: session.profile?.topics ?? [],
+            reachability: session.reachability,
+        })), { workspace: sender.workspace, excludeSessionId: sender.portalSessionId });
+    }
+    saveDerivedProfile(session, entries, transcriptWatermark) {
+        const profile = deriveSessionProfile({
+            managedName: session.managedName,
+            title: session.title === null ? null : redactSecrets(session.title),
+            entries: entries.map((entry) => ({ ...entry, text: redactSecrets(entry.text) })),
+        });
+        this.index.repository.upsertSessionProfile({
+            sessionId: session.portalSessionId,
+            ...profile,
+            source: session.managedName === null ? "derived" : "explicit",
+            transcriptWatermark,
+        });
+    }
+    sessionReachability(session) {
+        if (this.index.repository.hasActiveRunnerLease(session.portalSessionId))
+            return "active_runner";
+        if (this.index.repository.hasActiveConnectionLease(session.portalSessionId))
+            return "inbox_only";
+        return session.state === "historical" || session.state === "unknown" ? "historical" : "unavailable";
+    }
+    async nextRunnerMessage(sessionId, token, waitMs = 25_000) {
+        this.index.repository.authenticateSession(sessionId, token);
+        const deadline = Date.now() + Math.min(Math.max(waitMs, 0), 25_000);
+        do {
+            this.index.repository.touchRunnerLease(sessionId);
+            const message = this.index.repository.claimNextRunnerMessage(sessionId);
+            if (message !== null) {
+                const sender = this.index.repository.getSession(message.senderSessionId);
+                return {
+                    source: "local",
+                    message,
+                    senderLabel: sender?.managedName ?? sender?.title ?? sender?.provider ?? "unknown",
+                    senderReference: message.senderSessionId,
+                    authenticated: true,
+                };
+            }
+            const remoteEvent = this.index.repository.claimNextRemoteTaskEvent(sessionId);
+            if (remoteEvent !== null) {
+                return {
+                    source: "remote",
+                    message: remoteEventMessage(remoteEvent),
+                    senderLabel: remoteEvent.senderLabel,
+                    senderReference: remoteEvent.senderReference,
+                    authenticated: remoteEvent.authenticated,
+                    remoteEvent,
+                };
+            }
+            if (this.#closed || Date.now() >= deadline)
+                return null;
+            await delay(Math.min(100, deadline - Date.now()));
+        } while (!this.#closed);
+        return null;
+    }
+    runnerMessageReceived(sessionId, token, messageId, turnId) {
+        this.index.repository.authenticateSession(sessionId, token);
+        this.index.repository.touchRunnerLease(sessionId);
+        const remote = decodeRemoteDeliveryId(messageId);
+        return remote === null
+            ? this.index.repository.markRunnerMessageReceived(messageId, sessionId, turnId)
+            : this.index.repository.markRemoteTaskEventReceived(remote.serverUrl, remote.eventId, sessionId, turnId);
+    }
+    runnerMessageStarting(sessionId, token, messageId) {
+        this.index.repository.authenticateSession(sessionId, token);
+        this.index.repository.touchRunnerLease(sessionId);
+        const remote = decodeRemoteDeliveryId(messageId);
+        return remote === null
+            ? this.index.repository.markRunnerMessageStarting(messageId, sessionId)
+            : this.index.repository.markRemoteTaskEventStarting(remote.serverUrl, remote.eventId, sessionId);
+    }
+    heartbeatRunner(sessionId, token) {
+        this.index.repository.authenticateSession(sessionId, token);
+        this.index.repository.touchRunnerLease(sessionId);
+        return { active: true };
+    }
+    runnerMessageCompleted(sessionId, token, messageId, input) {
+        this.index.repository.authenticateSession(sessionId, token);
+        this.index.repository.touchRunnerLease(sessionId);
+        const remote = decodeRemoteDeliveryId(messageId);
+        return remote === null
+            ? this.index.repository.completeRunnerMessage(messageId, sessionId, input)
+            : this.index.repository.completeRemoteTaskEvent(remote.serverUrl, remote.eventId, sessionId, input);
+    }
+    runnerMessageFailed(sessionId, token, messageId, error) {
+        this.index.repository.authenticateSession(sessionId, token);
+        this.index.repository.touchRunnerLease(sessionId);
+        const remote = decodeRemoteDeliveryId(messageId);
+        return remote === null
+            ? this.index.repository.failRunnerMessage(messageId, sessionId, error)
+            : this.index.repository.failRemoteTaskEvent(remote.serverUrl, remote.eventId, sessionId, error);
+    }
+    disconnectRunner(sessionId, token) {
+        this.index.repository.authenticateSession(sessionId, token);
+        this.index.repository.clearRunnerLease(sessionId);
+    }
+    async waitForRunnerCompletion(messageId, targetSessionId) {
+        const deadline = Date.now() + 15 * 60_000;
+        while (!this.#closed && Date.now() < deadline) {
+            const receipt = this.index.repository.getMessageReceipt(messageId);
+            if (receipt?.status === "completed" || receipt?.status === "failed")
+                return receipt;
+            if (!this.index.repository.hasActiveRunnerLease(targetSessionId)) {
+                if (receipt?.status === "running") {
+                    return this.index.repository.failRunnerMessage(messageId, targetSessionId, "managed runner disconnected after accepting the message; delivery outcome is unknown");
+                }
+                return receipt;
+            }
+            await delay(100);
+        }
+        return this.index.repository.getMessageReceipt(messageId);
+    }
+    inbox(targetSessionId) {
+        if (this.index.repository.getSession(targetSessionId) === null) {
+            throw new Error(`unknown Portal session: ${targetSessionId}`);
+        }
+        return this.index.repository.listInbox(targetSessionId);
+    }
+    receiveInbox(targetSessionId, acknowledgements = []) {
+        if (this.index.repository.getSession(targetSessionId) === null) {
+            throw new Error(`unknown Portal session: ${targetSessionId}`);
+        }
+        return this.index.repository.receiveQueuedMessages(targetSessionId, acknowledgements);
+    }
+}
+function requireUniqueSession(reference, matches) {
+    if (matches.length > 1) {
+        throw new Error(`session reference is ambiguous: ${reference}; use a Portal session ID`);
+    }
+    return matches[0];
+}
+function requirePreferredSession(reference, matches) {
+    const active = matches.filter(({ reachability }) => reachability === "active_runner");
+    if (active.length > 0)
+        return requireUniqueSession(reference, active);
+    const connected = matches.filter(({ connected }) => connected);
+    return requireUniqueSession(reference, connected.length > 0 ? connected : matches);
+}
+function toResolutionCandidate(candidate) {
+    return {
+        portalSessionId: candidate.portalSessionId,
+        displayName: candidate.displayName,
+        description: candidate.description,
+        reachability: candidate.reachability,
+        score: candidate.score,
+        reasons: candidate.reasons,
+    };
+}
+function isUnchanged(existing, observed, indexedWatermark) {
+    return (existing?.indexed === true &&
+        observed.updatedAt !== null &&
+        indexedWatermark === observed.updatedAt.toISOString());
+}
+function returnSession(result, session) {
+    const index = result.sessions.findIndex(({ portalSessionId }) => portalSessionId === session.portalSessionId);
+    if (index < 0)
+        result.sessions.push(session);
+    else
+        result.sessions[index] = session;
+}
+function compareSessions(left, right) {
+    return (right.updatedAt?.getTime() ?? 0) - (left.updatedAt?.getTime() ?? 0) ||
+        left.portalSessionId.localeCompare(right.portalSessionId);
+}
+function remoteEventMessage(event) {
+    return {
+        messageId: encodeRemoteDeliveryId(event.serverUrl, event.eventId),
+        senderSessionId: `remote:${event.senderReference}`,
+        targetSessionId: event.localSessionId,
+        body: formatRemoteEvent(event),
+        state: "delivering",
+        createdAt: event.occurredAt,
+        deliveredAt: null,
+        replyTo: null,
+        idempotencyKey: event.eventId,
+        error: event.error,
+    };
+}
+function formatRemoteEvent(event) {
+    const payload = event.payload;
+    const heading = `Portal · ${event.senderLabel} (unverified; sandbox and approval policy still apply) · ${event.kind} · ${event.taskId}`;
+    switch (event.kind) {
+        case "offer":
+            return [
+                heading,
+                field(payload, "objective"),
+                optionalField(payload, "Context", "context"),
+                optionalField(payload, "Expected", "expectedResult"),
+                "Use portal.task.update to accept or decline before starting material work.",
+            ].filter(Boolean).join("\n");
+        case "accepted":
+            return [heading, optionalField(payload, "", "message")].filter(Boolean).join("\n");
+        case "declined":
+            return [heading, optionalField(payload, "Reason", "reason")].filter(Boolean).join("\n");
+        case "running":
+        case "progress":
+            return [heading, optionalField(payload, "", "message")].filter(Boolean).join("\n");
+        case "question":
+            return [heading, optionalField(payload, "Question", "question")].filter(Boolean).join("\n");
+        case "answer":
+            return [heading, optionalField(payload, "Answer", "answer")].filter(Boolean).join("\n");
+        case "completed":
+            return [
+                heading,
+                field(payload, "result"),
+                listField(payload, "Artifacts", "artifactReferences"),
+            ].filter(Boolean).join("\n");
+        case "failed":
+            return [heading, optionalField(payload, "Error", "error")].filter(Boolean).join("\n");
+    }
+}
+function field(payload, key) {
+    return typeof payload[key] === "string" ? payload[key] : "";
+}
+function optionalField(payload, label, key) {
+    const value = field(payload, key);
+    if (!value)
+        return "";
+    return label ? `${label}: ${value}` : value;
+}
+function listField(payload, label, key) {
+    const values = payload[key];
+    if (!Array.isArray(values) || values.length === 0)
+        return "";
+    return `${label}: ${values.filter((value) => typeof value === "string").join(", ")}`;
+}
+function encodeRemoteDeliveryId(serverUrl, eventId) {
+    return `remote_${Buffer.from(JSON.stringify({ serverUrl, eventId }), "utf8").toString("base64url")}`;
+}
+function decodeRemoteDeliveryId(value) {
+    if (!value.startsWith("remote_"))
+        return null;
+    try {
+        const decoded = JSON.parse(Buffer.from(value.slice("remote_".length), "base64url").toString("utf8"));
+        if (typeof decoded !== "object" || decoded === null)
+            throw new Error("not an object");
+        const { serverUrl, eventId } = decoded;
+        if (typeof serverUrl !== "string" || typeof eventId !== "string" || !serverUrl || !eventId) {
+            throw new Error("missing fields");
+        }
+        return { serverUrl, eventId };
+    }
+    catch {
+        throw new Error("invalid remote runner delivery ID");
+    }
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function delay(milliseconds) {
+    return new Promise((resolve) => {
+        const timer = setTimeout(resolve, milliseconds);
+        timer.unref();
+    });
+}
+//# sourceMappingURL=service.js.map