@pdpp/local-collector 0.0.0

package/dist/polyfill-connectors/src/local-device-queue.js

@@ -0,0 +1,133 @@
+import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import { dirname } from "node:path";
+export class LocalDeviceQueue {
+    #clock;
+    #path;
+    #retryBackoffMs;
+    constructor(options) {
+        this.#clock = options.clock ?? (() => new Date());
+        this.#path = options.path;
+        this.#retryBackoffMs = options.retryBackoffMs ?? defaultRetryBackoffMs;
+    }
+    async enqueue(input) {
+        if (input.records.length === 0) {
+            throw new Error("cannot enqueue an empty local device batch");
+        }
+        const items = await this.#readItems();
+        if (items.some((item) => item.batch_id === input.batchId)) {
+            throw new Error(`local device batch already queued: ${input.batchId}`);
+        }
+        const now = this.#clock().toISOString();
+        const item = {
+            available_at: now,
+            batch_id: input.batchId,
+            batch_seq: input.batchSeq,
+            created_at: now,
+            records: input.records,
+            retry_count: 0,
+            source_instance_id: input.sourceInstanceId,
+            status: "pending",
+            updated_at: now,
+        };
+        await this.#writeItems([...items, item]);
+        return item;
+    }
+    async dequeueReady() {
+        const now = this.#clock().toISOString();
+        const items = await this.#readItems();
+        const index = items.findIndex((item) => isReadyHeadOfSource(item, items, now));
+        if (index < 0) {
+            return null;
+        }
+        const item = items[index];
+        if (!item) {
+            return null;
+        }
+        const updated = { ...item, status: "in_flight", updated_at: now };
+        items[index] = updated;
+        await this.#writeItems(items);
+        return updated;
+    }
+    async markSent(batchId) {
+        await this.#updateItem(batchId, (item, now) => ({ ...item, status: "sent", updated_at: now }));
+    }
+    async markRetry(batchId, error) {
+        await this.#updateItem(batchId, (item, now) => {
+            const retryCount = item.retry_count + 1;
+            return {
+                ...item,
+                available_at: new Date(this.#clock().getTime() + this.#retryBackoffMs(retryCount)).toISOString(),
+                last_error: error,
+                retry_count: retryCount,
+                status: "pending",
+                updated_at: now,
+            };
+        });
+    }
+    async markPermanentFailure(batchId, error) {
+        await this.#updateItem(batchId, (item, now) => ({
+            ...item,
+            last_error: error,
+            status: "permanent_failure",
+            updated_at: now,
+        }));
+    }
+    async list() {
+        return await this.#readItems();
+    }
+    async #updateItem(batchId, update) {
+        const items = await this.#readItems();
+        const index = items.findIndex((item) => item.batch_id === batchId);
+        const item = items[index];
+        if (!item) {
+            throw new Error(`local device batch not found: ${batchId}`);
+        }
+        items[index] = update(item, this.#clock().toISOString());
+        await this.#writeItems(items);
+    }
+    async #readItems() {
+        try {
+            const raw = await readFile(this.#path, "utf8");
+            if (!raw.trim()) {
+                return [];
+            }
+            const parsed = JSON.parse(raw);
+            return [...(parsed.items ?? [])].sort(compareQueueItems);
+        }
+        catch (error) {
+            if (isNotFoundError(error)) {
+                return [];
+            }
+            throw error;
+        }
+    }
+    async #writeItems(items) {
+        await mkdir(dirname(this.#path), { recursive: true });
+        const ordered = [...items].sort(compareQueueItems);
+        const tmpPath = `${this.#path}.tmp`;
+        await writeFile(tmpPath, `${JSON.stringify({ items: ordered }, null, 2)}\n`);
+        await rename(tmpPath, this.#path);
+    }
+}
+function compareQueueItems(a, b) {
+    const source = a.source_instance_id.localeCompare(b.source_instance_id);
+    if (source !== 0) {
+        return source;
+    }
+    return a.batch_seq - b.batch_seq;
+}
+function isReadyHeadOfSource(item, items, now) {
+    if (item.status !== "pending" || item.available_at > now) {
+        return false;
+    }
+    return !items.some((other) => other.source_instance_id === item.source_instance_id &&
+        other.batch_seq < item.batch_seq &&
+        other.status !== "sent" &&
+        other.status !== "permanent_failure");
+}
+function defaultRetryBackoffMs(retryCount) {
+    return Math.min(60_000, 1000 * 2 ** Math.max(0, retryCount - 1));
+}
+function isNotFoundError(error) {
+    return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}

package/dist/polyfill-connectors/src/local-source-inventory.js

@@ -0,0 +1,119 @@
+import { createHash } from "node:crypto";
+import { statSync } from "node:fs";
+import { readdir, stat } from "node:fs/promises";
+import { join } from "node:path";
+function pathHash(tool, relativePath) {
+    return createHash("sha256").update(`${tool}:${relativePath}`).digest("hex");
+}
+function inventoryEntryType(st) {
+    if (st.isDirectory()) {
+        return "directory";
+    }
+    if (st.isFile()) {
+        return "file";
+    }
+    return "other";
+}
+function coverageStatus(classification, exists) {
+    if (!exists) {
+        return "missing";
+    }
+    if (classification === "collect") {
+        return "collected";
+    }
+    if (classification === "inventory_only") {
+        return "inventory_only";
+    }
+    if (classification === "exclude") {
+        return "excluded";
+    }
+    if (classification === "defer" || classification === "collect_redacted") {
+        return "deferred";
+    }
+    return "unsupported";
+}
+async function statKind(path) {
+    try {
+        const st = await stat(path);
+        return {
+            exists: true,
+            mtimeEpoch: Math.floor(st.mtimeMs / 1000),
+            sizeBytes: st.isFile() ? st.size : null,
+            type: inventoryEntryType(st),
+        };
+    }
+    catch {
+        return { exists: false, mtimeEpoch: null, sizeBytes: null, type: "missing" };
+    }
+}
+export async function buildLocalSourceInventory(tool, sourceHome, stores) {
+    const recordsByStream = new Map();
+    const coverage = [];
+    for (const store of stores) {
+        const fullPath = join(sourceHome, store.relativePath);
+        const pathMeta = await statKind(fullPath);
+        const status = coverageStatus(store.classification, pathMeta.exists);
+        coverage.push({
+            id: `${store.store}:${status}`,
+            store: store.store,
+            stream: store.stream,
+            status,
+            reason: store.reason,
+        });
+        if (!(pathMeta.exists && store.stream) ||
+            (store.classification !== "inventory_only" && store.classification !== "defer")) {
+            continue;
+        }
+        const records = recordsByStream.get(store.stream) ?? [];
+        records.push({
+            id: `${store.store}:${pathHash(tool, store.relativePath)}`,
+            store: store.store,
+            relative_path: store.relativePath,
+            path_hash: pathHash(tool, store.relativePath),
+            type: pathMeta.type,
+            size_bytes: pathMeta.sizeBytes,
+            mtime_epoch: pathMeta.mtimeEpoch,
+            classification: store.classification,
+            reason: store.reason,
+        });
+        recordsByStream.set(store.stream, records);
+    }
+    return { coverage, recordsByStream };
+}
+export async function listDirectoryInventory(input) {
+    const root = join(input.sourceHome, input.relativeRoot);
+    let entries;
+    try {
+        entries = await readdir(root, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+    const records = [];
+    for (const ent of entries.sort((a, b) => a.name.localeCompare(b.name))) {
+        if (ent.name.startsWith(".")) {
+            continue;
+        }
+        const rel = `${input.relativeRoot}/${ent.name}`;
+        const full = join(root, ent.name);
+        let st;
+        try {
+            st = statSync(full);
+        }
+        catch {
+            continue;
+        }
+        records.push({
+            id: `${input.store}:${pathHash(input.tool, rel)}`,
+            store: input.store,
+            relative_path: rel,
+            path_hash: pathHash(input.tool, rel),
+            type: inventoryEntryType(st),
+            size_bytes: st.isFile() ? st.size : null,
+            mtime_epoch: Math.floor(st.mtimeMs / 1000),
+            classification: "inventory_only",
+            reason: input.reason,
+        });
+    }
+    return records;
+}

package/dist/polyfill-connectors/src/pdpp-safe-text.js

@@ -0,0 +1,13 @@
+import { z } from "zod";
+import { safeTextPreview } from "./safe-text-preview.js";
+export const pdppSafeText = z
+    .string()
+    .refine((s) => {
+    const result = safeTextPreview(s);
+    return result.kind === "text" || result.kind === "empty";
+}, {
+    message: "must be PDPP-safe Unicode text (no U+0000, no forbidden control characters, valid UTF-8). " +
+        "Binary or control-rich payloads MUST be stored in the blobs table.",
+})
+    .brand();
+export const nullablePdppSafeText = pdppSafeText.nullable();

package/dist/polyfill-connectors/src/runner/index.d.ts

@@ -0,0 +1,11 @@
+export { COLLECTOR_PROTOCOL_HEADER, COLLECTOR_PROTOCOL_VERSION } from "../collector-protocol.js";
+export { buildCollectorStartMessage, type CollectorChildContext, type CollectorConnectorSpec, type CollectorEnrollmentConfig, type CollectorRunConfig, type CollectorRunResult, CollectorStateReadError, drainCollectorQueue, enrollCollector, runCollectorConnector, transformRecordsToCollectorEnvelopes, } from "../collector-runner.js";
+export type { AssistanceAttachment, AssistanceAttachmentKind, AssistanceCompletion, AssistanceCompletionStatus, AssistanceOwnerAction, AssistanceProgressPosture, AssistanceRequest, AssistanceResponseContract, AssistanceSensitivity, DetailCoverageMessage, DetailGapMessage, DetailGapRecoveredMessage, DetailGapStartEntry, EmittedMessage, InteractionKind, InteractionRequest, InteractionResponse, RecordData, StartMessage, StreamScope, ValidateRecord, } from "../connector-runtime-protocol.js";
+export { isMainModule } from "../is-main-module.js";
+export { type EnrollmentExchangeRequest, type EnrollmentExchangeResponse, type GetSourceInstanceStateRequest, type HeartbeatRequest, type IngestBatchRequest, LOCAL_DEVICE_ENDPOINTS, LocalDeviceClient, type LocalDeviceClientOptions, LocalDeviceHttpError, type PutSourceInstanceStateRequest, type SourceInstanceStateResponse, } from "../local-device-client.js";
+export { type BuildLocalDeviceRecordEnvelopeInput, buildLocalDeviceRecordEnvelope, canonicalJson, hashCanonicalJson, type LocalDeviceRecordEnvelope, } from "../local-device-envelope.js";
+export { type BuildLocalDeviceOutboxIdInput, buildLocalDeviceOutboxId, LocalDeviceOutbox, type LocalDeviceOutboxClaimInput, type LocalDeviceOutboxDeadLetterInput, type LocalDeviceOutboxEnqueueInput, type LocalDeviceOutboxFailInput, type LocalDeviceOutboxItem, type LocalDeviceOutboxKind, type LocalDeviceOutboxLeaseInput, type LocalDeviceOutboxOptions, type LocalDeviceOutboxRenewInput, type LocalDeviceOutboxStatus, type LocalDeviceOutboxSummary, } from "../local-device-outbox.js";
+export { LocalDeviceQueue, type LocalDeviceQueueItem, type LocalDeviceQueueOptions, type LocalDeviceQueueStatus, } from "../local-device-queue.js";
+export { assertPlacementOrThrow, COLLECTOR_RUNTIME_CAPABILITIES, type ConnectorPlacementInput, type ConnectorRuntimeRequirements, diffRequiredBindings, evaluatePlacement, type PlacementDecision, PROVIDER_RUNTIME_CAPABILITIES, RUNTIME_CAPABILITY_MISMATCH_CODE, type RuntimeBindingName, RuntimeCapabilityMismatchError, type RuntimeCapabilityProfile, } from "../runtime-capabilities.js";
+export { emitToStdout, parseJsonlLine, stringifyForJsonl } from "../safe-emit.js";
+export { type EmitGate, type EmitGateRecord, type EmitTombstonesArgs, emitTombstones, type MakeEmitGateOptions, makeEmitGate, passesResourceFilter, passesTimeRange, type RequireCredentialsOrAskArgs, requireCredentialsOrAsk, resourceSet, type StreamRequest, type TimeRange, } from "../scope-filters.js";

package/dist/polyfill-connectors/src/runner/index.js

@@ -0,0 +1,10 @@
+export { COLLECTOR_PROTOCOL_HEADER, COLLECTOR_PROTOCOL_VERSION } from "../collector-protocol.js";
+export { buildCollectorStartMessage, CollectorStateReadError, drainCollectorQueue, enrollCollector, runCollectorConnector, transformRecordsToCollectorEnvelopes, } from "../collector-runner.js";
+export { isMainModule } from "../is-main-module.js";
+export { LOCAL_DEVICE_ENDPOINTS, LocalDeviceClient, LocalDeviceHttpError, } from "../local-device-client.js";
+export { buildLocalDeviceRecordEnvelope, canonicalJson, hashCanonicalJson, } from "../local-device-envelope.js";
+export { buildLocalDeviceOutboxId, LocalDeviceOutbox, } from "../local-device-outbox.js";
+export { LocalDeviceQueue, } from "../local-device-queue.js";
+export { assertPlacementOrThrow, COLLECTOR_RUNTIME_CAPABILITIES, diffRequiredBindings, evaluatePlacement, PROVIDER_RUNTIME_CAPABILITIES, RUNTIME_CAPABILITY_MISMATCH_CODE, RuntimeCapabilityMismatchError, } from "../runtime-capabilities.js";
+export { emitToStdout, parseJsonlLine, stringifyForJsonl } from "../safe-emit.js";
+export { emitTombstones, makeEmitGate, passesResourceFilter, passesTimeRange, requireCredentialsOrAsk, resourceSet, } from "../scope-filters.js";

package/dist/polyfill-connectors/src/runtime-capabilities.d.ts

@@ -0,0 +1,40 @@
+export type RuntimeBindingName = "network" | "browser" | "filesystem" | "local_device";
+export interface RuntimeCapabilityProfile {
+    readonly bindings: ReadonlySet<RuntimeBindingName>;
+    readonly id: string;
+}
+export declare const PROVIDER_RUNTIME_CAPABILITIES: RuntimeCapabilityProfile;
+export declare const COLLECTOR_RUNTIME_CAPABILITIES: RuntimeCapabilityProfile;
+export interface ConnectorRuntimeRequirements {
+    readonly bindings?: Partial<Record<RuntimeBindingName, {
+        readonly required?: boolean;
+    }>>;
+}
+export interface ConnectorPlacementInput {
+    readonly connector_id: string;
+    readonly runtime_requirements?: ConnectorRuntimeRequirements;
+}
+export type PlacementDecision = {
+    readonly kind: "ok";
+    readonly satisfied: readonly RuntimeBindingName[];
+} | {
+    readonly kind: "missing_capability";
+    readonly missing: readonly RuntimeBindingName[];
+    readonly runtime: string;
+    readonly connectorId: string;
+};
+export declare function diffRequiredBindings(connector: ConnectorPlacementInput, runtime: RuntimeCapabilityProfile): RuntimeBindingName[];
+export declare function evaluatePlacement(connector: ConnectorPlacementInput, runtime: RuntimeCapabilityProfile): PlacementDecision;
+export declare const RUNTIME_CAPABILITY_MISMATCH_CODE = "runtime_capability_mismatch";
+export declare class RuntimeCapabilityMismatchError extends Error {
+    readonly code: typeof RUNTIME_CAPABILITY_MISMATCH_CODE;
+    readonly missing: readonly RuntimeBindingName[];
+    readonly runtime: string;
+    readonly connectorId: string;
+    constructor(args: {
+        connectorId: string;
+        runtime: string;
+        missing: readonly RuntimeBindingName[];
+    });
+}
+export declare function assertPlacementOrThrow(connector: ConnectorPlacementInput, runtime: RuntimeCapabilityProfile): readonly RuntimeBindingName[];

package/dist/polyfill-connectors/src/runtime-capabilities.js

@@ -0,0 +1,59 @@
+export const PROVIDER_RUNTIME_CAPABILITIES = {
+    id: "provider",
+    bindings: new Set(["network", "filesystem"]),
+};
+export const COLLECTOR_RUNTIME_CAPABILITIES = {
+    id: "collector",
+    bindings: new Set(["network", "browser", "filesystem", "local_device"]),
+};
+export function diffRequiredBindings(connector, runtime) {
+    const declared = connector.runtime_requirements?.bindings ?? {};
+    const missing = [];
+    for (const [name, decl] of Object.entries(declared)) {
+        if (decl?.required && !runtime.bindings.has(name)) {
+            missing.push(name);
+        }
+    }
+    return missing;
+}
+export function evaluatePlacement(connector, runtime) {
+    const missing = diffRequiredBindings(connector, runtime);
+    if (missing.length === 0) {
+        const declared = connector.runtime_requirements?.bindings ?? {};
+        const satisfied = Object.keys(declared).filter((name) => declared[name]?.required && runtime.bindings.has(name));
+        return { kind: "ok", satisfied };
+    }
+    return {
+        kind: "missing_capability",
+        missing,
+        runtime: runtime.id,
+        connectorId: connector.connector_id,
+    };
+}
+export const RUNTIME_CAPABILITY_MISMATCH_CODE = "runtime_capability_mismatch";
+export class RuntimeCapabilityMismatchError extends Error {
+    code;
+    missing;
+    runtime;
+    connectorId;
+    constructor(args) {
+        super(`Runtime '${args.runtime}' cannot satisfy connector '${args.connectorId}': missing bindings [${args.missing.join(", ")}]. ` +
+            "Run this connector in a runtime that advertises the required bindings (typically the local collector runtime).");
+        this.name = "RuntimeCapabilityMismatchError";
+        this.code = RUNTIME_CAPABILITY_MISMATCH_CODE;
+        this.missing = args.missing;
+        this.runtime = args.runtime;
+        this.connectorId = args.connectorId;
+    }
+}
+export function assertPlacementOrThrow(connector, runtime) {
+    const decision = evaluatePlacement(connector, runtime);
+    if (decision.kind === "ok") {
+        return decision.satisfied;
+    }
+    throw new RuntimeCapabilityMismatchError({
+        connectorId: decision.connectorId,
+        runtime: decision.runtime,
+        missing: decision.missing,
+    });
+}

package/dist/polyfill-connectors/src/safe-emit.d.ts

@@ -0,0 +1,3 @@
+export declare function stringifyForJsonl(msg: unknown): string;
+export declare function emitToStdout(msg: unknown): Promise<void>;
+export declare function parseJsonlLine(line: string): unknown;

package/dist/polyfill-connectors/src/safe-emit.js

@@ -0,0 +1,30 @@
+const JSONL_TERMINATOR = /[\u2028\u2029]/g;
+const MAX_SAFE = BigInt(Number.MAX_SAFE_INTEGER);
+const MIN_SAFE = BigInt(Number.MIN_SAFE_INTEGER);
+function bigIntSafeReplacer(_key, value) {
+    if (typeof value === "bigint") {
+        return value <= MAX_SAFE && value >= MIN_SAFE ? Number(value) : value.toString();
+    }
+    return value;
+}
+function escapeJsonlTerminator(c) {
+    return c === "\u2028" ? "\\u2028" : "\\u2029";
+}
+export function stringifyForJsonl(msg) {
+    return `${JSON.stringify(msg, bigIntSafeReplacer).replace(JSONL_TERMINATOR, escapeJsonlTerminator)}\n`;
+}
+export function emitToStdout(msg) {
+    const line = stringifyForJsonl(msg);
+    const ok = process.stdout.write(line);
+    if (ok) {
+        return Promise.resolve();
+    }
+    return new Promise((resolve) => {
+        process.stdout.once("drain", () => {
+            resolve();
+        });
+    });
+}
+export function parseJsonlLine(line) {
+    return JSON.parse(line);
+}

package/dist/polyfill-connectors/src/safe-text-preview.js

@@ -0,0 +1,156 @@
+export const PDPP_PREVIEW_MAX_CHARS = 4000;
+function isForbiddenCodePoint(codeUnit) {
+    if (codeUnit === 0x00_00) {
+        return true;
+    }
+    if (codeUnit >= 0x00_01 && codeUnit <= 0x00_08) {
+        return true;
+    }
+    if (codeUnit === 0x00_0b) {
+        return true;
+    }
+    if (codeUnit === 0x00_0c) {
+        return true;
+    }
+    if (codeUnit >= 0x00_0e && codeUnit <= 0x00_1f) {
+        return true;
+    }
+    if (codeUnit === 0x00_7f) {
+        return true;
+    }
+    if (codeUnit >= 0x00_80 && codeUnit <= 0x00_9f) {
+        return true;
+    }
+    return false;
+}
+function checkStringForForbidden(value) {
+    for (let i = 0; i < value.length; i++) {
+        const codeUnit = value.charCodeAt(i);
+        if (isForbiddenCodePoint(codeUnit)) {
+            return {
+                isSafe: false,
+                firstOffendingIndex: i,
+                offendingCodeUnit: codeUnit,
+            };
+        }
+    }
+    return { isSafe: true };
+}
+function decodeBuffer(buf) {
+    const bufferWithUtf8 = Buffer;
+    const isUtf8 = bufferWithUtf8.isUtf8;
+    if (typeof isUtf8 === "function" && buf instanceof Buffer) {
+        if (!isUtf8(buf)) {
+            return { success: false, reason: "invalid UTF-8 sequence in buffer" };
+        }
+        return { success: true, text: buf.toString("utf-8") };
+    }
+    try {
+        const decoder = new TextDecoder("utf-8", { fatal: true });
+        const text = decoder.decode(buf);
+        return { success: true, text };
+    }
+    catch {
+        return { success: false, reason: "invalid UTF-8 sequence in buffer" };
+    }
+}
+function truncateString(text, maxChars) {
+    if (text.length <= maxChars) {
+        return { result: text, wasTruncated: false };
+    }
+    let truncateAt = maxChars;
+    if (truncateAt > 0 && truncateAt < text.length) {
+        const codeUnitAtTruncate = text.charCodeAt(truncateAt - 1);
+        if (codeUnitAtTruncate >= 0xd8_00 && codeUnitAtTruncate <= 0xdb_ff) {
+            truncateAt--;
+        }
+    }
+    const truncated = `${text.slice(0, truncateAt)}…`;
+    return { result: truncated, wasTruncated: true };
+}
+export function safeTextPreview(value, maxChars = PDPP_PREVIEW_MAX_CHARS) {
+    let text = null;
+    let originalLength = 0;
+    if (value === null || value === undefined) {
+        return {
+            kind: "empty",
+            preview: null,
+            truncated: false,
+            originalLength: 0,
+            reason: null,
+        };
+    }
+    if (typeof value === "string") {
+        text = value;
+        originalLength = text.length;
+    }
+    else if (Buffer.isBuffer(value)) {
+        originalLength = value.length;
+        const decoded = decodeBuffer(value);
+        if (!decoded.success) {
+            return {
+                kind: "binary",
+                preview: null,
+                truncated: false,
+                originalLength,
+                reason: decoded.reason || "invalid UTF-8",
+            };
+        }
+        text = decoded.text;
+    }
+    else if (value instanceof Uint8Array) {
+        originalLength = value.length;
+        const decoded = decodeBuffer(value);
+        if (!decoded.success) {
+            return {
+                kind: "binary",
+                preview: null,
+                truncated: false,
+                originalLength,
+                reason: decoded.reason || "invalid UTF-8",
+            };
+        }
+        text = decoded.text;
+    }
+    else {
+        return {
+            kind: "empty",
+            preview: null,
+            truncated: false,
+            originalLength: 0,
+            reason: null,
+        };
+    }
+    if (text === "") {
+        return {
+            kind: "empty",
+            preview: null,
+            truncated: false,
+            originalLength: 0,
+            reason: null,
+        };
+    }
+    const forbidden = checkStringForForbidden(text);
+    if (!forbidden.isSafe) {
+        const offendingIndex = forbidden.firstOffendingIndex;
+        const codeUnit = forbidden.offendingCodeUnit;
+        const reason = codeUnit === 0x00_00
+            ? `U+0000 at offset ${offendingIndex}`
+            : `U+${codeUnit.toString(16).toUpperCase().padStart(4, "0")} at offset ${offendingIndex}`;
+        return {
+            kind: "binary",
+            preview: null,
+            truncated: false,
+            originalLength,
+            reason,
+        };
+    }
+    const truncated = truncateString(text, maxChars);
+    return {
+        kind: "text",
+        preview: truncated.result,
+        truncated: truncated.wasTruncated,
+        originalLength,
+        reason: null,
+    };
+}

package/dist/polyfill-connectors/src/schema-registry.js

@@ -0,0 +1,17 @@
+export function makeValidateRecord(schemas) {
+    return (stream, data) => {
+        const schema = schemas[stream];
+        if (!schema) {
+            return { ok: true, data };
+        }
+        const result = schema.safeParse(data);
+        if (result.success) {
+            return { ok: true, data: result.data };
+        }
+        const issues = result.error.issues.map((i) => ({
+            path: i.path.join("."),
+            message: i.message,
+        }));
+        return { ok: false, issues };
+    };
+}

package/dist/polyfill-connectors/src/scope-filters.d.ts

@@ -0,0 +1,38 @@
+import type { Credentials } from "./auth.js";
+import type { EmittedMessage, InteractionRequest, InteractionResponse } from "./connector-runtime-protocol.js";
+export interface TimeRange {
+    since?: string;
+    until?: string;
+}
+export interface StreamRequest {
+    resources?: readonly unknown[];
+    time_range?: TimeRange;
+}
+export declare function resourceSet(streamRequest: StreamRequest | null | undefined): Set<string> | null;
+export declare function passesResourceFilter(resSet: ReadonlySet<string> | null, primaryKey: unknown): boolean;
+export declare function passesTimeRange(isoValue: string | null | undefined, timeRange: TimeRange | null | undefined): boolean;
+export interface EmitGateRecord {
+    [field: string]: unknown;
+}
+export interface EmitGate {
+    emittedSet: () => Set<string>;
+    (stream: string, data: EmitGateRecord, keyField?: string): boolean;
+}
+export interface MakeEmitGateOptions {
+    consentTimeField?: string;
+}
+export declare function makeEmitGate(emitRecord: (stream: string, data: EmitGateRecord) => void, streamRequest: StreamRequest | null | undefined, { consentTimeField }?: MakeEmitGateOptions): EmitGate;
+export interface EmitTombstonesArgs {
+    currentIds: ReadonlySet<string>;
+    emit: (msg: EmittedMessage) => unknown;
+    emittedAt: string;
+    priorIds: Iterable<string> | null | undefined;
+    stream: string;
+}
+export declare function emitTombstones({ emit, stream, priorIds, currentIds, emittedAt }: EmitTombstonesArgs): number;
+export interface RequireCredentialsOrAskArgs {
+    connectorName: string;
+    required: ReadonlyArray<string | readonly string[]>;
+    sendInteraction: (req: InteractionRequest) => Promise<InteractionResponse>;
+}
+export declare function requireCredentialsOrAsk({ required, connectorName, sendInteraction, }: RequireCredentialsOrAskArgs): Promise<Credentials>;