@pdpp/local-collector 0.18.2 → 0.18.4

package/dist/polyfill-connectors/src/collector-build-info.js

@@ -1,8 +1,8 @@
 const COLLECTOR_BUILD_SOURCE_SENTINEL = "source";
 const COLLECTOR_BUILD_INFO = {
-    builtAt: "2026-06-26T09:13:45.041Z",
-    revision: "ca887ef84ecc",
-    version: "0.18.2",
+    builtAt: "2026-06-26T14:50:36.407Z",
+    revision: "1f4bad0a8c2b",
+    version: "0.18.4",
 };
 function buildAgentVersion(info = COLLECTOR_BUILD_INFO) {
     return `${info.version}+${info.revision}`;

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

@@ -399,10 +399,10 @@ async function runInBrowser(args) {
             page,
         });
         await watchdog.run(() => establishSession({ ensureSession, probeSession }, {
-            assist,
+            assist: watchdog.wrapAssist(assist),
             capture: baseCtx.capture,
             checkpoint: watchdog.checkpoint,
-            completeAssistance,
+            completeAssistance: watchdog.wrapCompleteAssistance(completeAssistance),
             context: ctx,
             page: page,
             name,
@@ -798,6 +798,7 @@ export function makeSessionEstablishWatchdog(args) {
     const pollIntervalMs = args.pollIntervalMs ?? Math.max(1, Math.min(1000, Math.floor(deadlineMs / 4)));
     let lastProgressAt = now();
     let lastLabel = null;
+    const openAssistance = new Map();
     let openInteractions = 0;
     let tripped = false;
     const markProgress = (label) => {
@@ -816,6 +817,43 @@ export function makeSessionEstablishWatchdog(args) {
             process.stderr.write(`[session-watchdog] checkpoint capture failed for ${label}: ${message}\n`);
         }
     };
+    const assistancePausesWatchdog = (req) => req.progress_posture === "running" && req.response_contract === "none";
+    const pruneExpiredAssistance = () => {
+        const current = now();
+        let pruned = false;
+        for (const [id, expiresAt] of openAssistance) {
+            if (expiresAt > current) {
+                continue;
+            }
+            openAssistance.delete(id);
+            pruned = true;
+        }
+        if (pruned) {
+            markProgress(null);
+        }
+    };
+    const wrapAssist = (assist) => async (req) => {
+        markProgress(null);
+        const assistanceRequestId = await assist(req);
+        if (assistancePausesWatchdog(req)) {
+            const timeoutMs = typeof req.timeout_seconds === "number" && Number.isFinite(req.timeout_seconds) && req.timeout_seconds > 0
+                ? req.timeout_seconds * 1000
+                : deadlineMs;
+            openAssistance.set(assistanceRequestId, now() + timeoutMs + deadlineMs);
+            markProgress(null);
+        }
+        return assistanceRequestId;
+    };
+    const wrapCompleteAssistance = (completeAssistance) => async (assistanceRequestId, status, extra = {}) => {
+        try {
+            await completeAssistance(assistanceRequestId, status, extra);
+        }
+        finally {
+            if (openAssistance.delete(assistanceRequestId)) {
+                markProgress(null);
+            }
+        }
+    };
     const wrapSendInteraction = (send) => async (req) => {
         openInteractions++;
         markProgress(null);
@@ -833,7 +871,8 @@ export function makeSessionEstablishWatchdog(args) {
         const TRIP = Symbol("session-establish-trip");
         const tripPromise = new Promise((resolve) => {
             const onTick = () => {
-                if (tripped || openInteractions > 0) {
+                pruneExpiredAssistance();
+                if (tripped || openInteractions > 0 || openAssistance.size > 0) {
                     return;
                 }
                 const sinceMs = now() - lastProgressAt;
@@ -868,7 +907,7 @@ export function makeSessionEstablishWatchdog(args) {
             }
         }
     };
-    return { checkpoint, wrapSendInteraction, run };
+    return { checkpoint, wrapAssist, wrapCompleteAssistance, wrapSendInteraction, run };
 }
 async function establishSession(hooks, args) {
     const { ensureSession, probeSession } = hooks;

package/dist/polyfill-connectors/src/static-secret-injection.js

@@ -1,4 +1,22 @@
 function freezeStaticSecretDescriptor(descriptor) {
+    const freezeMapping = (mapping) => {
+        if (mapping.secretEnvVars) {
+            Object.freeze(mapping.secretEnvVars);
+        }
+        if (mapping.secretFieldEnvVars) {
+            for (const value of Object.values(mapping.secretFieldEnvVars)) {
+                Object.freeze(value);
+            }
+            Object.freeze(mapping.secretFieldEnvVars);
+        }
+        if (mapping.setupFieldEnvVars) {
+            for (const value of Object.values(mapping.setupFieldEnvVars)) {
+                Object.freeze(value);
+            }
+            Object.freeze(mapping.setupFieldEnvVars);
+        }
+        return Object.freeze(mapping);
+    };
     if (descriptor.secretEnvVars) {
         Object.freeze(descriptor.secretEnvVars);
     }
@@ -14,9 +32,22 @@ function freezeStaticSecretDescriptor(descriptor) {
         }
         Object.freeze(descriptor.setupFieldEnvVars);
     }
+    if (descriptor.acceptedCredentialVariants) {
+        for (const variant of descriptor.acceptedCredentialVariants) {
+            freezeMapping(variant);
+        }
+        Object.freeze(descriptor.acceptedCredentialVariants);
+    }
     return Object.freeze(descriptor);
 }
 export const STATIC_SECRET_CONNECTOR_REGISTRY = Object.freeze({
+    amazon: freezeStaticSecretDescriptor({
+        credentialKind: "username_password",
+        secretFieldEnvVars: {
+            password: ["AMAZON_PASSWORD"],
+            username: ["AMAZON_USERNAME"],
+        },
+    }),
     chatgpt: freezeStaticSecretDescriptor({
         credentialKind: "username_password",
         secretFieldEnvVars: {
@@ -56,12 +87,33 @@ export const STATIC_SECRET_CONNECTOR_REGISTRY = Object.freeze({
         secretEnvVars: ["NOTION_API_TOKEN"],
     }),
     reddit: freezeStaticSecretDescriptor({
-        credentialKind: "secret_bundle",
+        credentialKind: "username_password",
+        acceptedCredentialVariants: [
+            {
+                credentialKind: "secret_bundle",
+                secretFieldEnvVars: {
+                    reddit_password: ["REDDIT_PASSWORD"],
+                    reddit_username: ["REDDIT_USERNAME"],
+                },
+            },
+        ],
         secretFieldEnvVars: {
-            reddit_username: ["REDDIT_USERNAME"],
-            reddit_password: ["REDDIT_PASSWORD"],
-            reddit_client_id: ["REDDIT_CLIENT_ID"],
-            reddit_client_secret: ["REDDIT_CLIENT_SECRET"],
+            password: ["REDDIT_PASSWORD"],
+            username: ["REDDIT_USERNAME"],
+        },
+    }),
+    chase: freezeStaticSecretDescriptor({
+        credentialKind: "username_password",
+        secretFieldEnvVars: {
+            password: ["CHASE_PASSWORD"],
+            username: ["CHASE_USERNAME"],
+        },
+    }),
+    usaa: freezeStaticSecretDescriptor({
+        credentialKind: "username_password",
+        secretFieldEnvVars: {
+            password: ["USAA_PASSWORD"],
+            username: ["USAA_USERNAME"],
         },
     }),
 });
@@ -111,14 +163,26 @@ function secretBundleFields(connectorId, secret) {
     }
     return fields;
 }
-function assertRecoveredSecretMatches(connectorId, descriptor, recovered) {
+function injectionMappingForRecoveredSecret(connectorId, descriptor, recovered) {
     if (!recovered || typeof recovered.secret !== "string" || recovered.secret.length === 0) {
         throw new StaticSecretInjectionError("recovered_secret_invalid", `Cannot inject an empty credential for connector '${connectorId}'.`);
     }
-    if (recovered.credentialKind !== descriptor.credentialKind) {
-        throw new StaticSecretInjectionError("credential_kind_mismatch", `Connector '${connectorId}' expects credential kind '${descriptor.credentialKind}', ` +
+    if (recovered.credentialKind === descriptor.credentialKind) {
+        return descriptor;
+    }
+    const variant = descriptor.acceptedCredentialVariants?.find((candidate) => candidate.credentialKind === recovered.credentialKind);
+    if (variant) {
+        return variant;
+    }
+    const expectedKinds = [
+        descriptor.credentialKind,
+        ...(descriptor.acceptedCredentialVariants ?? []).map((v) => v.credentialKind),
+    ];
+    if (!expectedKinds.includes(recovered.credentialKind)) {
+        throw new StaticSecretInjectionError("credential_kind_mismatch", `Connector '${connectorId}' expects credential kind '${expectedKinds.join("' or '")}', ` +
             `but the recovered credential is '${recovered.credentialKind}'.`);
     }
+    return descriptor;
 }
 function injectSingleSecret(fragment, envVars, secret) {
     for (const envVar of envVars ?? []) {
@@ -157,10 +221,10 @@ export function buildConnectionScopedSecretEnv(connectorId, recovered, sourceBin
     if (!descriptor) {
         throw new StaticSecretInjectionError("not_a_static_secret_connector", `Connector '${connectorId}' is not a known static-secret connector; refusing to invent secret env vars for it.`);
     }
-    assertRecoveredSecretMatches(connectorId, descriptor, recovered);
+    const mapping = injectionMappingForRecoveredSecret(connectorId, descriptor, recovered);
     const fragment = {};
-    injectSingleSecret(fragment, descriptor.secretEnvVars, recovered.secret);
-    injectSecretBundle(fragment, connectorId, recovered.secret, descriptor.secretFieldEnvVars);
-    injectSetupFields(fragment, descriptor.setupFieldEnvVars, sourceBinding);
+    injectSingleSecret(fragment, mapping.secretEnvVars, recovered.secret);
+    injectSecretBundle(fragment, connectorId, recovered.secret, mapping.secretFieldEnvVars);
+    injectSetupFields(fragment, mapping.setupFieldEnvVars, sourceBinding);
     return fragment;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pdpp/local-collector",
-  "version": "0.18.2",
+  "version": "0.18.4",
   "description": "Publishable local collector runtime for PDPP: filesystem-class connectors (Claude Code, Codex) plus the device-exporter ingest client.",
   "type": "module",
   "private": false,