@pdpp/local-collector 0.1.0-beta.6 → 0.1.0-beta.8

package/dist/polyfill-connectors/src/local-device-outbox.d.ts

@@ -66,6 +66,50 @@ export interface LocalDeviceOutboxDeadLetterInput extends LocalDeviceOutboxLease
 export interface LocalDeviceOutboxRenewInput extends LocalDeviceOutboxLeaseInput {
     leaseMs: number;
 }
+export interface LocalDeviceOutboxRequeueDeadLettersInput {
+    dryRun?: boolean;
+    kind?: LocalDeviceOutboxKind;
+    limit?: number;
+    sourceInstanceId?: string;
+}
+export interface LocalDeviceOutboxRequeueDeadLettersResult {
+    matched: number;
+    requeued: number;
+}
+export interface LocalDeviceOutboxPruneSentInput {
+    dryRun?: boolean;
+    keepCount?: number;
+    olderThanIso?: string;
+    sourceInstanceId?: string;
+}
+export interface LocalDeviceOutboxPruneSentResult {
+    matched: number;
+    pruned: number;
+}
+export interface LocalDeviceOutboxPageStats {
+    freelistPages: number;
+    pageCount: number;
+    pageSizeBytes: number;
+    reclaimableBytes: number;
+}
+export interface LocalDeviceOutboxCompactResult {
+    after: LocalDeviceOutboxPageStats;
+    before: LocalDeviceOutboxPageStats;
+    reclaimedBytes: number;
+}
+export interface LocalDeviceOutboxDeadLetterErrorClass {
+    count: number;
+    error_class: string;
+}
+export interface LocalDeviceOutboxDeadLetterErrorSummary {
+    dead_letter_count: number;
+    null_error_count: number;
+    top_classes: LocalDeviceOutboxDeadLetterErrorClass[];
+}
+export interface LocalDeviceOutboxDeadLetterErrorSummaryInput {
+    limit?: number;
+    sourceInstanceId?: string;
+}
 export declare class LocalDeviceOutbox {
     #private;
     constructor(options: LocalDeviceOutboxOptions);
@@ -84,6 +128,12 @@ export declare class LocalDeviceOutbox {
     }): number;
     get(id: string): LocalDeviceOutboxItem | null;
     deleteSucceeded(id: string): boolean;
+    backupTo(path: string): void;
+    requeueDeadLetters(input?: LocalDeviceOutboxRequeueDeadLettersInput): LocalDeviceOutboxRequeueDeadLettersResult;
+    pruneSent(input?: LocalDeviceOutboxPruneSentInput): LocalDeviceOutboxPruneSentResult;
+    countNonSucceeded(): number;
+    pageStats(): LocalDeviceOutboxPageStats;
+    compact(): LocalDeviceOutboxCompactResult;
     hasNonSucceededWork(input: {
         excludeKinds?: readonly LocalDeviceOutboxKind[];
         kinds?: readonly LocalDeviceOutboxKind[];
@@ -111,5 +161,14 @@ export declare class LocalDeviceOutbox {
     summary(input?: {
         sourceInstanceId?: string;
     }): LocalDeviceOutboxSummary;
+    hasObservedStream(input: {
+        sourceInstanceId: string;
+        stream: string;
+    }): boolean | null;
+    countRecordBatches(input: {
+        sourceInstanceId: string;
+    }): number;
+    deadLetterErrorSummary(input?: LocalDeviceOutboxDeadLetterErrorSummaryInput): LocalDeviceOutboxDeadLetterErrorSummary;
 }
 export declare function buildLocalDeviceOutboxId(input: BuildLocalDeviceOutboxIdInput): string;
+export declare function classifyDeadLetterError(raw: string): string;

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

@@ -2,7 +2,8 @@ import { mkdirSync } from "node:fs";
 import { dirname } from "node:path";
 import { DatabaseSync } from "node:sqlite";
 import { hashCanonicalJson } from "./local-device-envelope.js";
-const CURRENT_SCHEMA_VERSION = 1;
+const CURRENT_SCHEMA_VERSION = 2;
+const LEGACY_COVERAGE_SCAN_BUDGET = 5000;
 export class LocalDeviceOutbox {
     #clock;
     #db;
@@ -67,12 +68,19 @@ export class LocalDeviceOutbox {
           updated_at
         ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
             .run(row.id, row.source_instance_id, row.kind, row.status, row.payload_json, row.body_hash, row.attempt_count, row.next_attempt_at, row.lease_holder, row.lease_epoch, row.lease_until, row.last_error, row.acknowledged_at, row.created_at, row.updated_at);
+        this.#indexObservedStreams(row.id, row.source_instance_id, row.kind, input.payload);
         const inserted = this.get(row.id);
         if (!inserted) {
             throw new Error(`local outbox insert disappeared before readback: ${row.id}`);
         }
         return inserted;
     }
+    #indexObservedStreams(outboxId, sourceInstanceId, kind, payload) {
+        if (kind !== "record_batch") {
+            return;
+        }
+        this.#backfillObservedStreamIndex(outboxId, sourceInstanceId, distinctRecordStreams(payload));
+    }
     claimReady(input) {
         const now = this.#now();
         const leaseUntil = new Date(this.#clock().getTime() + input.leaseMs).toISOString();
@@ -204,6 +212,158 @@ export class LocalDeviceOutbox {
         const result = this.#db.prepare("DELETE FROM local_device_outbox WHERE id = ? AND status = 'succeeded'").run(id);
         return Number(result.changes) === 1;
     }
+    backupTo(path) {
+        this.#db.exec(`VACUUM INTO ${sqlStringLiteral(path)}`);
+    }
+    requeueDeadLetters(input = {}) {
+        const limit = normalizeLimit(input.limit);
+        const { clauses, params } = deadLetterWhere(input);
+        const matched = this.#countWhere(clauses, params, limit);
+        if (input.dryRun || matched === 0) {
+            return { matched, requeued: 0 };
+        }
+        const now = this.#now();
+        const limitSql = limit == null ? "" : " LIMIT ?";
+        const selected = this.#db
+            .prepare(`SELECT id
+           FROM local_device_outbox
+          WHERE ${clauses.join(" AND ")}
+          ORDER BY rowid${limitSql}`)
+            .all(...(limit == null ? params : [...params, limit]));
+        const ids = selected.map((row) => {
+            if (!isRecord(row) || typeof row.id !== "string") {
+                throw new Error("local outbox dead-letter id query returned an invalid row");
+            }
+            return row.id;
+        });
+        if (ids.length === 0) {
+            return { matched, requeued: 0 };
+        }
+        this.#db.exec("BEGIN IMMEDIATE");
+        try {
+            let requeued = 0;
+            for (const chunk of chunkArray(ids, SQLITE_IN_CLAUSE_CHUNK)) {
+                const result = this.#db
+                    .prepare(`UPDATE local_device_outbox
+                SET status = 'ready',
+                    attempt_count = 0,
+                    next_attempt_at = ?,
+                    lease_holder = NULL,
+                    lease_until = NULL,
+                    last_error = NULL,
+                    updated_at = ?
+              WHERE id IN (${chunk.map(() => "?").join(", ")})
+                AND status = 'dead_letter'`)
+                    .run(now, now, ...chunk);
+                requeued += Number(result.changes);
+            }
+            this.#db.exec("COMMIT");
+            return { matched, requeued };
+        }
+        catch (error) {
+            this.#db.exec("ROLLBACK");
+            throw error;
+        }
+    }
+    pruneSent(input = {}) {
+        if (input.keepCount !== undefined && (!Number.isSafeInteger(input.keepCount) || input.keepCount < 0)) {
+            throw new Error("pruneSent keepCount must be a non-negative safe integer");
+        }
+        const clauses = ["status = 'succeeded'"];
+        const params = [];
+        if (input.sourceInstanceId) {
+            clauses.push("source_instance_id = ?");
+            params.push(input.sourceInstanceId);
+        }
+        if (input.olderThanIso) {
+            clauses.push("COALESCE(acknowledged_at, updated_at) < ?");
+            params.push(input.olderThanIso);
+        }
+        if (input.keepCount !== undefined) {
+            const scopeClause = input.sourceInstanceId
+                ? "source_instance_id = ? AND status = 'succeeded'"
+                : "status = 'succeeded'";
+            const scopeParams = input.sourceInstanceId ? [input.sourceInstanceId] : [];
+            clauses.push(`id NOT IN (
+           SELECT id FROM local_device_outbox
+            WHERE ${scopeClause}
+            ORDER BY rowid DESC
+            LIMIT ?
+         )`);
+            params.push(...scopeParams, input.keepCount);
+        }
+        const whereClause = clauses.join(" AND ");
+        const countRow = this.#db
+            .prepare(`SELECT COUNT(*) AS total FROM local_device_outbox WHERE ${whereClause}`)
+            .get(...params);
+        const matched = isRecord(countRow) ? numberFrom(countRow.total) : 0;
+        if (input.dryRun !== false || matched === 0) {
+            return { matched, pruned: 0 };
+        }
+        const idRows = this.#db
+            .prepare(`SELECT id FROM local_device_outbox WHERE ${whereClause} ORDER BY rowid`)
+            .all(...params);
+        const ids = idRows.map((row) => {
+            if (!isRecord(row) || typeof row.id !== "string") {
+                throw new Error("local outbox prune-sent id query returned an invalid row");
+            }
+            return row.id;
+        });
+        if (ids.length === 0) {
+            return { matched, pruned: 0 };
+        }
+        this.#db.exec("BEGIN IMMEDIATE");
+        try {
+            let pruned = 0;
+            for (const chunk of chunkArray(ids, SQLITE_IN_CLAUSE_CHUNK)) {
+                const placeholders = chunk.map(() => "?").join(", ");
+                this.#db.prepare(`DELETE FROM local_device_observed_stream WHERE outbox_id IN (${placeholders})`).run(...chunk);
+                const result = this.#db
+                    .prepare(`DELETE FROM local_device_outbox WHERE id IN (${placeholders}) AND status = 'succeeded'`)
+                    .run(...chunk);
+                pruned += Number(result.changes);
+            }
+            this.#db.exec("COMMIT");
+            return { matched, pruned };
+        }
+        catch (error) {
+            this.#db.exec("ROLLBACK");
+            throw error;
+        }
+    }
+    countNonSucceeded() {
+        const row = this.#db.prepare("SELECT COUNT(*) AS total FROM local_device_outbox WHERE status != 'succeeded'").get();
+        return isRecord(row) ? numberFrom(row.total) : 0;
+    }
+    pageStats() {
+        return this.#readPageStats();
+    }
+    compact() {
+        const before = this.#readPageStats();
+        this.#db.exec("VACUUM");
+        this.#db.exec("PRAGMA wal_checkpoint(TRUNCATE)");
+        const after = this.#readPageStats();
+        const reclaimedPages = Math.max(0, before.pageCount - after.pageCount);
+        return { after, before, reclaimedBytes: reclaimedPages * before.pageSizeBytes };
+    }
+    #readPageStats() {
+        const pageSizeBytes = this.#pragmaInt("page_size");
+        const pageCount = this.#pragmaInt("page_count");
+        const freelistPages = this.#pragmaInt("freelist_count");
+        return {
+            freelistPages,
+            pageCount,
+            pageSizeBytes,
+            reclaimableBytes: freelistPages * pageSizeBytes,
+        };
+    }
+    #pragmaInt(pragma) {
+        const row = this.#db.prepare(`PRAGMA ${pragma}`).get();
+        if (!isRecord(row)) {
+            return 0;
+        }
+        return numberFrom(row[pragma]);
+    }
     hasNonSucceededWork(input) {
         const clauses = ["source_instance_id = ?", "status != 'succeeded'"];
         const params = [input.sourceInstanceId];
@@ -331,6 +491,155 @@ export class LocalDeviceOutbox {
         }
         return summary;
     }
+    hasObservedStream(input) {
+        const indexed = this.#db
+            .prepare(`SELECT 1 AS found
+           FROM local_device_observed_stream AS idx
+           JOIN local_device_outbox AS o ON o.id = idx.outbox_id
+          WHERE idx.source_instance_id = ?
+            AND idx.stream = ?
+            AND o.status != 'dead_letter'
+          LIMIT 1`)
+            .get(input.sourceInstanceId, input.stream);
+        if (indexed) {
+            return true;
+        }
+        const unindexed = this.#unindexedRecordBatchIds(input.sourceInstanceId, LEGACY_COVERAGE_SCAN_BUDGET + 1);
+        if (unindexed.length === 0) {
+            return false;
+        }
+        if (unindexed.length > LEGACY_COVERAGE_SCAN_BUDGET) {
+            return null;
+        }
+        return this.#legacyHasObservedStream(unindexed, input.stream);
+    }
+    countRecordBatches(input) {
+        const row = this.#db
+            .prepare(`SELECT COUNT(*) AS total
+           FROM local_device_outbox
+          WHERE source_instance_id = ?
+            AND kind = 'record_batch'
+            AND status != 'dead_letter'`)
+            .get(input.sourceInstanceId);
+        return isRecord(row) ? numberFrom(row.total) : 0;
+    }
+    #unindexedRecordBatchIds(sourceInstanceId, limit) {
+        const rows = this.#db
+            .prepare(`SELECT o.id AS id
+           FROM local_device_outbox AS o
+          WHERE o.source_instance_id = ?
+            AND o.kind = 'record_batch'
+            AND o.status != 'dead_letter'
+            AND NOT EXISTS (
+              SELECT 1 FROM local_device_observed_stream AS idx
+               WHERE idx.outbox_id = o.id
+            )
+          ORDER BY o.rowid
+          LIMIT ?`)
+            .all(sourceInstanceId, limit);
+        return rows.map((row) => {
+            if (!isRecord(row) || typeof row.id !== "string") {
+                throw new Error("local outbox unindexed record-batch query returned an invalid row");
+            }
+            return row.id;
+        });
+    }
+    #legacyHasObservedStream(outboxIds, stream) {
+        let found = false;
+        for (const id of outboxIds) {
+            const row = this.#db
+                .prepare("SELECT payload_json, source_instance_id FROM local_device_outbox WHERE id = ?")
+                .get(id);
+            if (!isRecord(row) || typeof row.payload_json !== "string" || typeof row.source_instance_id !== "string") {
+                continue;
+            }
+            let payload;
+            try {
+                payload = JSON.parse(row.payload_json);
+            }
+            catch {
+                continue;
+            }
+            const streams = distinctRecordStreams(payload);
+            this.#backfillObservedStreamIndex(id, row.source_instance_id, streams);
+            if (streams.includes(stream)) {
+                found = true;
+            }
+        }
+        return found;
+    }
+    #backfillObservedStreamIndex(outboxId, sourceInstanceId, streams) {
+        const insert = this.#db.prepare(`INSERT OR IGNORE INTO local_device_observed_stream (outbox_id, source_instance_id, stream)
+         VALUES (?, ?, ?)`);
+        if (streams.length === 0) {
+            insert.run(outboxId, sourceInstanceId, EMPTY_STREAM_SENTINEL);
+            return;
+        }
+        for (const stream of streams) {
+            insert.run(outboxId, sourceInstanceId, stream);
+        }
+    }
+    deadLetterErrorSummary(input = {}) {
+        const limit = input.limit && input.limit > 0 ? input.limit : 5;
+        const rows = input.sourceInstanceId
+            ? this.#db
+                .prepare(`SELECT last_error AS last_error, COUNT(*) AS total
+               FROM local_device_outbox
+              WHERE status = 'dead_letter' AND source_instance_id = ?
+              GROUP BY last_error`)
+                .all(input.sourceInstanceId)
+            : this.#db
+                .prepare(`SELECT last_error AS last_error, COUNT(*) AS total
+               FROM local_device_outbox
+              WHERE status = 'dead_letter'
+              GROUP BY last_error`)
+                .all();
+        const classCounts = new Map();
+        let deadLetterCount = 0;
+        let nullErrorCount = 0;
+        for (const rowLike of rows) {
+            if (!isRecord(rowLike)) {
+                continue;
+            }
+            const total = numberFrom(rowLike.total);
+            deadLetterCount += total;
+            const raw = rowLike.last_error;
+            if (typeof raw !== "string" || raw.trim() === "") {
+                nullErrorCount += total;
+                continue;
+            }
+            const errorClass = classifyDeadLetterError(raw);
+            classCounts.set(errorClass, (classCounts.get(errorClass) ?? 0) + total);
+        }
+        const top_classes = [...classCounts.entries()]
+            .sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0]))
+            .slice(0, limit)
+            .map(([error_class, count]) => ({ count, error_class }));
+        return {
+            dead_letter_count: deadLetterCount,
+            null_error_count: nullErrorCount,
+            top_classes,
+        };
+    }
+    #countWhere(clauses, params, limit) {
+        if (limit == null) {
+            const row = this.#db
+                .prepare(`SELECT COUNT(*) AS total FROM local_device_outbox WHERE ${clauses.join(" AND ")}`)
+                .get(...params);
+            return isRecord(row) ? numberFrom(row.total) : 0;
+        }
+        const row = this.#db
+            .prepare(`SELECT COUNT(*) AS total
+           FROM (
+             SELECT 1
+               FROM local_device_outbox
+              WHERE ${clauses.join(" AND ")}
+              ORDER BY rowid
+              LIMIT ?
+           )`)
+            .get(...params, limit);
+        return isRecord(row) ? numberFrom(row.total) : 0;
+    }
     #initialize() {
         this.#db.exec(`
       PRAGMA journal_mode = WAL;
@@ -341,12 +650,11 @@ export class LocalDeviceOutbox {
         if (version > CURRENT_SCHEMA_VERSION) {
             throw new Error(`local outbox schema version ${version} is newer than supported version ${CURRENT_SCHEMA_VERSION}`);
         }
-        if (version < 1) {
-            this.#applySchemaV1();
+        this.#applySchemaV1();
+        this.#applySchemaV2();
+        if (version < CURRENT_SCHEMA_VERSION) {
             this.#db.exec(`PRAGMA user_version = ${CURRENT_SCHEMA_VERSION}`);
-            return;
         }
-        this.#applySchemaV1();
     }
     #applySchemaV1() {
         this.#db.exec(`
@@ -375,6 +683,18 @@ export class LocalDeviceOutbox {
         ON local_device_outbox (source_instance_id, status);
     `);
     }
+    #applySchemaV2() {
+        this.#db.exec(`
+      CREATE TABLE IF NOT EXISTS local_device_observed_stream (
+        outbox_id TEXT NOT NULL,
+        source_instance_id TEXT NOT NULL,
+        stream TEXT NOT NULL,
+        PRIMARY KEY (source_instance_id, stream, outbox_id)
+      ) WITHOUT ROWID;
+      CREATE INDEX IF NOT EXISTS local_device_observed_stream_outbox_idx
+        ON local_device_observed_stream (outbox_id);
+    `);
+    }
     #selectReady(sourceInstanceId, now, limit, excludeKinds = []) {
         const kindClause = excludeKinds.length > 0 ? `AND kind NOT IN (${excludeKinds.map(() => "?").join(", ")})` : "";
         if (sourceInstanceId) {
@@ -418,6 +738,19 @@ export function buildLocalDeviceOutboxId(input) {
         source_instance_id: input.sourceInstanceId,
     })}`;
 }
+const EMPTY_STREAM_SENTINEL = " :pdpp-empty-record-batch";
+function distinctRecordStreams(payload) {
+    if (!(isRecord(payload) && Array.isArray(payload.records))) {
+        return [];
+    }
+    const streams = new Set();
+    for (const record of payload.records) {
+        if (isRecord(record) && typeof record.stream === "string" && record.stream !== "") {
+            streams.add(record.stream);
+        }
+    }
+    return [...streams];
+}
 function rowToItem(rowLike) {
     const row = asOutboxRow(rowLike);
     return {
@@ -444,6 +777,62 @@ function assertOneChange(changes, message) {
         throw new Error(message);
     }
 }
+function deadLetterWhere(input) {
+    const clauses = ["status = 'dead_letter'"];
+    const params = [];
+    if (input.sourceInstanceId) {
+        clauses.push("source_instance_id = ?");
+        params.push(input.sourceInstanceId);
+    }
+    if (input.kind) {
+        clauses.push("kind = ?");
+        params.push(input.kind);
+    }
+    return { clauses, params };
+}
+function normalizeLimit(value) {
+    if (value == null) {
+        return null;
+    }
+    if (!Number.isSafeInteger(value) || value <= 0) {
+        throw new Error("dead-letter requeue limit must be a positive safe integer");
+    }
+    return value;
+}
+function sqlStringLiteral(value) {
+    return `'${value.replaceAll("'", "''")}'`;
+}
+const SQLITE_IN_CLAUSE_CHUNK = 500;
+function chunkArray(items, size) {
+    const chunks = [];
+    for (let i = 0; i < items.length; i += size) {
+        chunks.push(items.slice(i, i + size));
+    }
+    return chunks;
+}
+const DEAD_LETTER_SECRET_RE = /\b(authorization|bearer|token|password|passwd|cookie|secret|otp|api[_-]?key)\b\s*[:=]\s*\S+/gi;
+const DEAD_LETTER_OTP_RE = /\b\d{6}\b/g;
+const DEAD_LETTER_LONG_OPAQUE_RE = /\b[A-Za-z0-9_-]{24,}\b/g;
+const DEAD_LETTER_PATH_RE = /(?:\/home|\/Users|\/root)\/[^\s"',)]+|[A-Za-z]:\\Users\\[^\s"',)]+/g;
+const DEAD_LETTER_URL_RE = /https?:\/\/[^\s"',)]+/gi;
+const DEAD_LETTER_HEX_ID_RE = /\b[0-9a-f]{8,}\b/gi;
+const DEAD_LETTER_NUMBER_RE = /\b\d{4,}\b/g;
+const DEAD_LETTER_MAX_LENGTH = 160;
+export function classifyDeadLetterError(raw) {
+    let s = raw.split("\n", 1)[0] ?? "";
+    s = s.replace(DEAD_LETTER_PATH_RE, "[PATH]");
+    s = s.replace(DEAD_LETTER_URL_RE, "[URL]");
+    s = s.replace(DEAD_LETTER_SECRET_RE, (_match, marker) => `${marker}=[REDACTED]`);
+    s = s.replace(DEAD_LETTER_OTP_RE, "[REDACTED_OTP]");
+    s = s.replace(DEAD_LETTER_LONG_OPAQUE_RE, "[REDACTED]");
+    s = s.replace(DEAD_LETTER_HEX_ID_RE, "[ID]");
+    s = s.replace(DEAD_LETTER_NUMBER_RE, "[N]");
+    s = s.replace(/\s+/g, " ").trim();
+    if (s === "") {
+        return "(unclassified)";
+    }
+    return s.length > DEAD_LETTER_MAX_LENGTH ? `${s.slice(0, DEAD_LETTER_MAX_LENGTH - 1)}…` : s;
+}
 function asOutboxRow(row) {
     if (!isRecord(row)) {
         throw new Error("local outbox query returned a non-object row");

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

@@ -2,6 +2,7 @@ import { createHash } from "node:crypto";
 import { statSync } from "node:fs";
 import { readdir, stat } from "node:fs/promises";
 import { join } from "node:path";
+import { openFingerprintCursor } from "./fingerprint-cursor.js";
 function pathHash(tool, relativePath) {
     return createHash("sha256").update(`${tool}:${relativePath}`).digest("hex");
 }
@@ -54,7 +55,7 @@ export async function buildLocalSourceInventory(tool, sourceHome, stores) {
         const pathMeta = await statKind(fullPath);
         const status = coverageStatus(store.classification, pathMeta.exists);
         coverage.push({
-            id: `${store.store}:${status}`,
+            id: `coverage:${store.store}`,
             store: store.store,
             stream: store.stream,
             status,
@@ -117,3 +118,9 @@ export async function listDirectoryInventory(input) {
     }
     return records;
 }
+export const INVENTORY_FINGERPRINT_EXCLUDE_KEYS = ["mtime_epoch", "size_bytes"];
+export function openInventoryFingerprintCursor(priorState) {
+    return openFingerprintCursor(priorState, {
+        excludeFromFingerprint: INVENTORY_FINGERPRINT_EXCLUDE_KEYS,
+    });
+}

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

@@ -1,11 +1,12 @@
 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 { buildCollectorStartMessage, COLLECTOR_COVERAGE_STATUSES, type CollectorChildContext, type CollectorCompletenessSummary, type CollectorConnectorSpec, type CollectorCoverageStatus, type CollectorEnrollmentConfig, type CollectorRunConfig, type CollectorRunResult, CollectorStateReadError, deriveLocalCollectorLifecycleState, drainCollectorQueue, enrollCollector, LOCAL_COLLECTOR_LIFECYCLE_STATES, type LocalCollectorLifecycleInput, type LocalCollectorLifecycleState, runCollectorConnector, summarizeCollectorCompleteness, 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 { DEFAULT_LOCAL_DEVICE_REQUEST_TIMEOUT_MS, type EnrollmentExchangeRequest, type EnrollmentExchangeResponse, type GetSourceInstanceStateRequest, type HeartbeatRequest, type IngestBatchRequest, LOCAL_DEVICE_ENDPOINTS, LocalDeviceClient, type LocalDeviceClientOptions, LocalDeviceHttpError, LocalDeviceRequestTimeoutError, 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 { type BuildLocalDeviceOutboxIdInput, buildLocalDeviceOutboxId, classifyDeadLetterError, LocalDeviceOutbox, type LocalDeviceOutboxClaimInput, type LocalDeviceOutboxCompactResult, type LocalDeviceOutboxDeadLetterErrorClass, type LocalDeviceOutboxDeadLetterErrorSummary, type LocalDeviceOutboxDeadLetterErrorSummaryInput, type LocalDeviceOutboxDeadLetterInput, type LocalDeviceOutboxEnqueueInput, type LocalDeviceOutboxFailInput, type LocalDeviceOutboxItem, type LocalDeviceOutboxKind, type LocalDeviceOutboxLeaseInput, type LocalDeviceOutboxOptions, type LocalDeviceOutboxPageStats, type LocalDeviceOutboxPruneSentInput, type LocalDeviceOutboxPruneSentResult, type LocalDeviceOutboxRenewInput, type LocalDeviceOutboxRequeueDeadLettersInput, type LocalDeviceOutboxRequeueDeadLettersResult, 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";
+export { buildConnectionScopedSecretEnv, isStaticSecretConnector, type RecoveredStaticSecret, STATIC_SECRET_CONNECTOR_REGISTRY, type StaticSecretCredentialKind, StaticSecretInjectionError, } from "../static-secret-injection.js";

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

@@ -1,10 +1,11 @@
 export { COLLECTOR_PROTOCOL_HEADER, COLLECTOR_PROTOCOL_VERSION } from "../collector-protocol.js";
-export { buildCollectorStartMessage, CollectorStateReadError, drainCollectorQueue, enrollCollector, runCollectorConnector, transformRecordsToCollectorEnvelopes, } from "../collector-runner.js";
+export { buildCollectorStartMessage, COLLECTOR_COVERAGE_STATUSES, CollectorStateReadError, deriveLocalCollectorLifecycleState, drainCollectorQueue, enrollCollector, LOCAL_COLLECTOR_LIFECYCLE_STATES, runCollectorConnector, summarizeCollectorCompleteness, transformRecordsToCollectorEnvelopes, } from "../collector-runner.js";
 export { isMainModule } from "../is-main-module.js";
-export { LOCAL_DEVICE_ENDPOINTS, LocalDeviceClient, LocalDeviceHttpError, } from "../local-device-client.js";
+export { DEFAULT_LOCAL_DEVICE_REQUEST_TIMEOUT_MS, LOCAL_DEVICE_ENDPOINTS, LocalDeviceClient, LocalDeviceHttpError, LocalDeviceRequestTimeoutError, } from "../local-device-client.js";
 export { buildLocalDeviceRecordEnvelope, canonicalJson, hashCanonicalJson, } from "../local-device-envelope.js";
-export { buildLocalDeviceOutboxId, LocalDeviceOutbox, } from "../local-device-outbox.js";
+export { buildLocalDeviceOutboxId, classifyDeadLetterError, 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";
+export { buildConnectionScopedSecretEnv, isStaticSecretConnector, STATIC_SECRET_CONNECTOR_REGISTRY, StaticSecretInjectionError, } from "../static-secret-injection.js";

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

@@ -23,6 +23,19 @@ function isForbiddenCodePoint(codeUnit) {
     }
     return false;
 }
+export function stripForbiddenControlChars(text) {
+    if (checkStringForForbidden(text).isSafe) {
+        return text;
+    }
+    let out = "";
+    for (let i = 0; i < text.length; i++) {
+        const codeUnit = text.charCodeAt(i);
+        if (!isForbiddenCodePoint(codeUnit)) {
+            out += text[i];
+        }
+    }
+    return out;
+}
 function checkStringForForbidden(value) {
     for (let i = 0; i < value.length; i++) {
         const codeUnit = value.charCodeAt(i);