witnora 0.13.2 → 0.13.4

package/dist/internal/control-client/durable-action-worker.js

@@ -0,0 +1,359 @@
+import { createHash, randomUUID } from "node:crypto";
+import { mkdir, open, readFile, readdir, rename } from "node:fs/promises";
+import { dirname, join, resolve } from "node:path";
+import { canonicalJson } from "./canonical.js";
+export class FileActionCheckpointStore {
+    directory;
+    constructor(directory) { this.directory = resolve(directory); }
+    async load(actionId) {
+        try {
+            return parseCheckpoint(await readFile(this.path(actionId), "utf8"));
+        }
+        catch (error) {
+            if (isMissing(error))
+                return undefined;
+            throw error;
+        }
+    }
+    async save(checkpoint) {
+        const path = this.path(checkpoint.actionId);
+        await mkdir(dirname(path), { recursive: true });
+        const temporary = `${path}.${process.pid}.${randomUUID()}.tmp`;
+        const handle = await open(temporary, "w", 0o600);
+        try {
+            await handle.writeFile(`${JSON.stringify(checkpoint, null, 2)}\n`, "utf8");
+            await handle.sync();
+        }
+        finally {
+            await handle.close();
+        }
+        await rename(temporary, path);
+    }
+    async list() {
+        let names;
+        try {
+            names = await readdir(this.directory);
+        }
+        catch (error) {
+            if (isMissing(error))
+                return [];
+            throw error;
+        }
+        const values = await Promise.all(names.filter((name) => name.endsWith(".json")).map(async (name) => parseCheckpoint(await readFile(join(this.directory, name), "utf8"))));
+        return values.sort((left, right) => left.updatedAt.localeCompare(right.updatedAt));
+    }
+    async claimExecution(actionId, ownerId, claimedAt) {
+        const path = this.claimPath(actionId);
+        await mkdir(dirname(path), { recursive: true });
+        const claimId = randomUUID();
+        try {
+            const handle = await open(path, "wx", 0o600);
+            try {
+                await handle.writeFile(`${JSON.stringify({ schemaVersion: "witnora.execution_claim.v0.1", actionId, claimId, ownerId, claimedAt })}\n`, "utf8");
+                await handle.sync();
+            }
+            finally {
+                await handle.close();
+            }
+            return { acquired: true, claimId };
+        }
+        catch (error) {
+            if (!isAlreadyExists(error))
+                throw error;
+            const existing = JSON.parse(await readFile(path, "utf8"));
+            if (typeof existing.claimId !== "string" || !existing.claimId)
+                throw new Error("Existing execution claim is invalid; refusing to dispatch.");
+            return { acquired: false, claimId: existing.claimId };
+        }
+    }
+    path(actionId) {
+        if (!/^[A-Za-z0-9._:-]+$/.test(actionId))
+            throw new Error("actionId contains unsupported characters.");
+        return join(this.directory, `${actionId}.json`);
+    }
+    claimPath(actionId) {
+        if (!/^[A-Za-z0-9._:-]+$/.test(actionId))
+            throw new Error("actionId contains unsupported characters.");
+        return join(this.directory, `${actionId}.execution-claim`);
+    }
+}
+export class DurableApprovedActionWorker {
+    options;
+    now;
+    chains = new Map();
+    timer;
+    lastHeartbeatAt;
+    lastError;
+    workerId = randomUUID();
+    constructor(options) {
+        this.options = options;
+        this.now = options.now ?? (() => new Date());
+        if (!options.config.adapterId || !validVersion(options.config.adapterVersion))
+            throw new Error("An exact adapter id and semantic version are required.");
+        if (!options.config.probeId || !options.config.probeCredentialHandle || options.probe.id !== options.config.probeId
+            || options.probe.credentialHandle !== options.config.probeCredentialHandle || options.probe.readOnly !== true)
+            throw new Error("An exact separate read-only probe credential is required.");
+        if (options.config.adapterId === options.config.probeId)
+            throw new Error("The adapter and outcome probe must be separate.");
+        if (options.runtime.reconcileReadOnly !== true)
+            throw new Error("Unknown writes require an explicitly read-only reconciliation path.");
+        this.lastHeartbeatAt = this.now().toISOString();
+    }
+    async track(input) {
+        assertProposal(input.proposal);
+        const existing = await this.options.store.load(input.actionId);
+        const digest = sha256(input.proposal);
+        if (existing) {
+            if (existing.proposalSha256 !== digest)
+                throw new Error("Action id was already tracked with a different proposal.");
+            return existing;
+        }
+        const checkpoint = {
+            schemaVersion: "witnora.durable_action_checkpoint.v0.1", actionId: input.actionId, phase: "TRACKED",
+            proposal: structuredClone(input.proposal), proposalSha256: digest, updatedAt: this.now().toISOString(),
+        };
+        await this.options.store.save(checkpoint);
+        return checkpoint;
+    }
+    tick(actionId) {
+        const previous = this.chains.get(actionId) ?? Promise.resolve(undefined);
+        const next = previous.catch(() => undefined).then(() => this.tickOnce(actionId));
+        this.chains.set(actionId, next);
+        return next.finally(() => { if (this.chains.get(actionId) === next)
+            this.chains.delete(actionId); });
+    }
+    start() {
+        if (this.timer)
+            return;
+        const poll = async () => {
+            this.lastHeartbeatAt = this.now().toISOString();
+            const checkpoints = await this.options.store.list();
+            let cycleError;
+            await Promise.all(checkpoints.filter((item) => !terminal(item.phase)).map((item) => this.tick(item.actionId).catch((error) => { cycleError = message(error); })));
+            this.lastError = cycleError;
+        };
+        void poll().catch((error) => { this.lastError = message(error); });
+        this.timer = setInterval(() => void poll().catch((error) => { this.lastError = message(error); }), this.options.config.pollIntervalMs ?? 2_000);
+        this.timer.unref();
+    }
+    stop() { if (this.timer)
+        clearInterval(this.timer); this.timer = undefined; }
+    async status() {
+        const checkpoints = await this.options.store.list();
+        return {
+            schemaVersion: "witnora.durable_action_worker_status.v0.1",
+            ready: Boolean(this.timer) && !this.lastError,
+            trackedActionCount: checkpoints.length,
+            pendingActionCount: checkpoints.filter((item) => !terminal(item.phase)).length,
+            unknownResultCount: checkpoints.filter((item) => item.phase === "UNKNOWN_RESULT").length,
+            lastHeartbeatAt: this.lastHeartbeatAt,
+            ...(this.lastError ? { lastError: this.lastError } : {}),
+        };
+    }
+    async tickOnce(actionId) {
+        let checkpoint = await this.options.store.load(actionId);
+        if (!checkpoint)
+            throw new Error(`Action ${actionId} is not tracked.`);
+        if (terminal(checkpoint.phase))
+            return checkpoint;
+        const action = await this.options.hosted.getAction(actionId);
+        if (!exactActionMatches(action, actionId, checkpoint.proposal, this.options.config.adapterId, this.options.config.adapterVersion)) {
+            return this.persist(checkpoint, "BLOCKED", { limitation: "Hosted action no longer matches the exact locally configured action, adapter, or build binding." });
+        }
+        if ((checkpoint.phase === "EXECUTION_STARTED" || checkpoint.phase === "UNKNOWN_RESULT") && checkpoint.grant) {
+            if (!exactGrantMatches(checkpoint.grant, actionId, checkpoint.proposal, this.options.config.runtimeIdentityId)) {
+                return this.persist(checkpoint, "BLOCKED", { limitation: "Hosted grant does not match the exact approved local action binding." });
+            }
+            const reconciled = await this.options.runtime.reconcile({ action, proposal: checkpoint.proposal, grant: checkpoint.grant });
+            if (!reconciled)
+                return this.persist(checkpoint, "UNKNOWN_RESULT", { limitation: "Write result is unknown. The worker will only use read-only reconciliation and will never redispatch this grant." });
+            checkpoint = await this.persist(checkpoint, "EXECUTED", { execution: reconciled, limitation: undefined });
+        }
+        if (!checkpoint.execution) {
+            if (action.status === "REJECTED" || action.status === "DENIED")
+                return this.persist(checkpoint, "DENIED");
+            if (action.status === "APPROVAL_EXPIRED" || action.status === "GRANT_EXPIRED" || (action.status === "APPROVED" && expired(action.approvalExpiresAt, this.now())))
+                return this.persist(checkpoint, "EXPIRED");
+            if (action.status === "PENDING_APPROVAL")
+                return this.persist(checkpoint, "WAITING_APPROVAL");
+            if (action.status !== "APPROVED" && action.status !== "ALLOWED") {
+                return this.persist(checkpoint, "BLOCKED", { limitation: `Action status ${action.status} is not executable.` });
+            }
+        }
+        if (!checkpoint.grant && !checkpoint.execution) {
+            const intent = checkpoint.proposal.executionIntent;
+            const grant = await this.options.hosted.issueExecutionGrant(actionId, {
+                runtimeIdentityId: this.options.config.runtimeIdentityId,
+                adapterId: intent.adapterId,
+                adapterVersionConstraint: intent.adapterVersionConstraint,
+                allowedOrigins: intent.allowedOrigins,
+                allowedOperation: intent.allowedOperation,
+                allowedResource: intent.allowedResource,
+                approvedParameters: intent.approvedParameters,
+                outcomePredicate: intent.outcomePredicate,
+                agentBuildId: intent.agentBuildId,
+                agentBuildDigest: intent.agentBuildDigest,
+                ttlSeconds: this.options.config.grantTtlSeconds ?? 120,
+            }, `durable-worker:grant:${actionId}`);
+            checkpoint = await this.persist(checkpoint, "GRANT_ISSUED", { grant });
+        }
+        const grant = checkpoint.grant;
+        if (!grant)
+            return this.persist(checkpoint, "BLOCKED", { limitation: "A durable execution result exists without its bound Hosted grant." });
+        const grantPayload = grant.grant.payload ?? {};
+        if (!exactGrantMatches(grant, actionId, checkpoint.proposal, this.options.config.runtimeIdentityId)) {
+            return this.persist(checkpoint, "BLOCKED", { limitation: "Hosted grant does not match the exact approved local action binding." });
+        }
+        if (!checkpoint.execution) {
+            if (grant.status !== "ISSUED" || expired(stringValue(grantPayload.expiresAt), this.now()))
+                return this.persist(checkpoint, "EXPIRED");
+            const claim = await this.options.store.claimExecution(actionId, this.workerId, this.now().toISOString());
+            if (!claim.acquired) {
+                checkpoint = await this.persist(checkpoint, "UNKNOWN_RESULT", {
+                    executionClaimId: claim.claimId,
+                    limitation: "Another Gateway process owns the durable execution claim. This worker will only reconcile and will never dispatch.",
+                });
+                const reconciled = await this.options.runtime.reconcile({ action, proposal: checkpoint.proposal, grant });
+                if (!reconciled)
+                    return checkpoint;
+                checkpoint = await this.persist(checkpoint, "EXECUTED", { execution: reconciled, limitation: undefined });
+            }
+            else {
+                checkpoint = await this.persist(checkpoint, "EXECUTION_STARTED", { executionClaimId: claim.claimId });
+            }
+        }
+        if (!checkpoint.execution && checkpoint.phase === "EXECUTION_STARTED") {
+            if (!checkpoint.hostedReservation) {
+                const reservation = await this.options.runtime.prepareClaim({ action, proposal: checkpoint.proposal, grant });
+                if (!exactHostedReservation(reservation, actionId, grant.id))
+                    return this.persist(checkpoint, "BLOCKED", { limitation: "Runtime claim is not bound to the exact action, grant, and execution session." });
+                const claimed = await this.options.hosted.claimExecutionGrant(grant.id, reservation.claim, `durable-worker:claim:${grant.id}`);
+                if (!claimed.acquired) {
+                    checkpoint = await this.persist(checkpoint, "UNKNOWN_RESULT", {
+                        limitation: "Hosted already has an execution reservation for this grant. This worker will only reconcile and will never dispatch.",
+                    });
+                    const reconciled = await this.options.runtime.reconcile({ action, proposal: checkpoint.proposal, grant });
+                    if (!reconciled)
+                        return checkpoint;
+                    checkpoint = await this.persist(checkpoint, "EXECUTED", { execution: reconciled, limitation: undefined });
+                }
+                else {
+                    checkpoint = await this.persist(checkpoint, "EXECUTION_STARTED", { hostedReservation: reservation });
+                }
+            }
+        }
+        if (!checkpoint.execution && checkpoint.phase === "EXECUTION_STARTED" && checkpoint.hostedReservation) {
+            try {
+                const execution = await this.options.runtime.execute({ action, proposal: checkpoint.proposal, grant, hostedReservation: checkpoint.hostedReservation });
+                checkpoint = await this.persist(checkpoint, "EXECUTED", { execution });
+            }
+            catch {
+                checkpoint = await this.persist(checkpoint, "UNKNOWN_RESULT", { limitation: "Write result is unknown. The worker will only use read-only reconciliation and will never redispatch this grant." });
+                const reconciled = await this.options.runtime.reconcile({ action, proposal: checkpoint.proposal, grant });
+                if (!reconciled)
+                    return checkpoint;
+                checkpoint = await this.persist(checkpoint, "EXECUTED", { execution: reconciled, limitation: undefined });
+            }
+        }
+        if (!checkpoint.observation) {
+            const observation = await this.options.probe.observe({ action, proposal: checkpoint.proposal, grant, execution: checkpoint.execution });
+            if (!observation.observationSource || observation.observationSource !== this.options.config.probeId)
+                throw new Error("Outcome observation did not come from the exact configured probe.");
+            checkpoint = await this.persist(checkpoint, "PROBED", { observation });
+        }
+        const verified = await this.options.hosted.verifyAction(actionId, {
+            ...checkpoint.observation,
+            executionGrantId: grant.id,
+            executionSessionId: checkpoint.execution.executionSessionId,
+        }, `durable-worker:verify:${actionId}:${checkpoint.execution.executionSessionId}`);
+        if (verified.status !== "VERIFIED" || verified.verificationSuccess !== true)
+            throw new Error("Hosted outcome verification did not establish the expected result.");
+        const receipts = await this.options.hosted.listActionReceipts(actionId);
+        const signed = receipts.find((item) => Array.isArray(item.receipt?.signatureSet) && item.receipt.signatureSet.length > 0);
+        if (!signed)
+            throw new Error("Hosted did not automatically issue a signed action receipt.");
+        return this.persist(checkpoint, "COMPLETED", { receiptId: signed.id });
+    }
+    async persist(checkpoint, phase, patch = {}) {
+        const next = { ...checkpoint, ...patch, phase, updatedAt: this.now().toISOString() };
+        if (patch.limitation === undefined && "limitation" in patch)
+            delete next.limitation;
+        await this.options.store.save(next);
+        return next;
+    }
+}
+function exactActionMatches(action, actionId, proposal, adapterId, adapterVersion) {
+    const approved = action.assuranceContext?.executionIntent;
+    const proposed = proposal.executionIntent;
+    return action.id === actionId && action.externalId === proposal.externalId && action.actionType === proposal.actionType
+        && action.targetSystem === proposal.targetSystem && sha256(action.expectedState ?? {}) === sha256(proposal.expectedState ?? {})
+        && proposed.adapterId === adapterId && runtimeAdapterVersionSatisfies(adapterVersion, proposed.adapterVersionConstraint)
+        && approved?.adapterId === proposed.adapterId && approved.adapterVersionConstraint === proposed.adapterVersionConstraint
+        && canonicalJson(approved.allowedOrigins) === canonicalJson(proposed.allowedOrigins)
+        && approved.allowedOperation === proposed.allowedOperation && approved.allowedResource === proposed.allowedResource
+        && approved.approvedParametersDigest === sha256(proposed.approvedParameters)
+        && approved.outcomePredicateDigest === sha256(proposed.outcomePredicate)
+        && approved.agentBuildId === proposed.agentBuildId && approved.agentBuildDigest === proposed.agentBuildDigest;
+}
+function exactGrantMatches(grant, actionId, proposal, runtimeIdentityId) {
+    const payload = grant.grant.payload ?? {};
+    const intent = proposal.executionIntent;
+    return payload.executionGrantId === grant.id && payload.actionId === actionId && payload.adapterId === intent.adapterId
+        && payload.adapterVersionConstraint === intent.adapterVersionConstraint && payload.expectedRuntimeIdentityId === runtimeIdentityId
+        && canonicalJson(payload.allowedOrigins) === canonicalJson(intent.allowedOrigins)
+        && payload.allowedOperation === intent.allowedOperation && payload.allowedResource === intent.allowedResource
+        && payload.agentBuildId === intent.agentBuildId && payload.agentBuildDigest === intent.agentBuildDigest
+        && payload.parametersDigest === sha256(intent.approvedParameters) && payload.outcomePredicateDigest === sha256(intent.outcomePredicate);
+}
+function exactHostedReservation(reservation, actionId, executionGrantId) {
+    if (!reservation || typeof reservation !== "object" || typeof reservation.executionSessionId !== "string"
+        || !reservation.executionSessionId || !reservation.claim || typeof reservation.claim !== "object" || Array.isArray(reservation.claim))
+        return false;
+    const payload = reservation.claim.payload;
+    return Boolean(payload && typeof payload === "object" && !Array.isArray(payload)
+        && payload.actionId === actionId
+        && payload.executionGrantId === executionGrantId
+        && payload.executionSessionId === reservation.executionSessionId);
+}
+function parseCheckpoint(raw) {
+    const value = JSON.parse(raw);
+    if (value.schemaVersion !== "witnora.durable_action_checkpoint.v0.1" || !value.actionId || !value.phase || !value.proposal || !value.proposalSha256 || !value.updatedAt) {
+        throw new Error("Durable action checkpoint is invalid.");
+    }
+    return value;
+}
+function assertProposal(value) {
+    const intent = value?.executionIntent;
+    if (!value?.externalId || !value.actionType || !value.targetSystem || !intent?.adapterId || !intent.adapterVersionConstraint
+        || !Array.isArray(intent.allowedOrigins) || !intent.allowedOrigins.length || !intent.allowedOperation || !intent.allowedResource
+        || !intent.approvedParameters || typeof intent.approvedParameters !== "object" || !intent.outcomePredicate || typeof intent.outcomePredicate !== "object"
+        || !intent.agentBuildId || !/^[a-f0-9]{64}$/.test(intent.agentBuildDigest)) {
+        throw new Error("Tracked action is missing an exact execution intent.");
+    }
+}
+function sha256(value) { return createHash("sha256").update(canonicalJson(value)).digest("hex"); }
+function expired(value, now) { return !value || !Number.isFinite(Date.parse(value)) || Date.parse(value) <= now.getTime(); }
+function stringValue(value) { return typeof value === "string" ? value : undefined; }
+function validVersion(value) { return /^v?\d+\.\d+\.\d+$/.test(value); }
+export function runtimeAdapterVersionSatisfies(version, constraint) {
+    const parsed = /^v?(\d+)\.(\d+)\.(\d+)$/.exec(version);
+    const exact = /^v?(\d+)\.(\d+)\.(\d+)$/.exec(constraint);
+    if (!parsed)
+        return false;
+    if (exact)
+        return parsed.slice(1).join(".") === exact.slice(1).join(".");
+    const compatible = /^\^v?(\d+)\.(\d+)\.(\d+)$/.exec(constraint);
+    if (!compatible)
+        return false;
+    const [major, minor, patch] = parsed.slice(1).map(Number);
+    const [requiredMajor, requiredMinor, requiredPatch] = compatible.slice(1).map(Number);
+    if (requiredMajor > 0)
+        return major === requiredMajor && (minor > requiredMinor || (minor === requiredMinor && patch >= requiredPatch));
+    if (requiredMinor > 0)
+        return major === 0 && minor === requiredMinor && patch >= requiredPatch;
+    return major === 0 && minor === 0 && patch === requiredPatch;
+}
+function terminal(phase) { return phase === "DENIED" || phase === "EXPIRED" || phase === "BLOCKED" || phase === "COMPLETED"; }
+function isMissing(error) { return Boolean(error && typeof error === "object" && "code" in error && error.code === "ENOENT"); }
+function isAlreadyExists(error) { return Boolean(error && typeof error === "object" && "code" in error && error.code === "EEXIST"); }
+function message(error) { return error instanceof Error ? error.message : String(error); }

package/dist/internal/control-client/remote-collector.d.ts

@@ -0,0 +1,132 @@
+export interface CustomerSourceSigner {
+    keyId: string;
+    privateKeyPem: string;
+    publicKeyPem: string;
+}
+export interface RemoteTrustedSourceRecord {
+    schemaVersion: "agentcert.trusted_action_record.v0.1";
+    recordId: string;
+    runId: string;
+    sequence: number;
+    occurredAt: string;
+    type: string;
+    collector: {
+        id: string;
+        version: string;
+        environment: string;
+        keyId: string;
+        publicKeySha256: string;
+    };
+    previousEventHash?: string;
+    payload: Record<string, unknown>;
+    payloadSha256: string;
+    eventHash: string;
+    sourceSignature: {
+        algorithm: "Ed25519";
+        keyId: string;
+        signature: string;
+    };
+}
+export interface RemoteCollectorAck {
+    schemaVersion: "agentcert.remote_collector_ack.v0.2";
+    accepted: number;
+    replayed: number;
+    ack: {
+        sequence: number;
+        eventHash: string;
+    };
+    alerts: Array<Record<string, unknown>>;
+    run: Record<string, unknown>;
+}
+export interface RemoteCollectorClientOptions {
+    baseUrl: string;
+    projectId: string;
+    apiKey: string;
+    fetch?: typeof fetch;
+}
+export declare class CustomerSourceKeyRing {
+    readonly filePath: string;
+    private value;
+    private constructor();
+    static create(filePath: string, collectorId: string, keyId?: string): Promise<CustomerSourceKeyRing>;
+    static open(filePath: string): Promise<CustomerSourceKeyRing>;
+    get collectorId(): string;
+    activeSigner(): CustomerSourceSigner;
+    signerFor(keyId: string): CustomerSourceSigner;
+    registration(previousKeyId?: string): {
+        collectorId: string;
+        keyId: string;
+        publicKeyPem: string;
+        previousKeyId?: string;
+    };
+    rotate(keyId?: string): Promise<{
+        previousKeyId: string;
+        signer: CustomerSourceSigner;
+    }>;
+    private persist;
+}
+export declare class RemoteCollectorClient {
+    readonly baseUrl: string;
+    readonly projectId: string;
+    private readonly apiKey;
+    private readonly requestFetch;
+    constructor(options: RemoteCollectorClientOptions);
+    registerSourceKey(input: {
+        collectorId: string;
+        keyId: string;
+        publicKeyPem: string;
+        previousKeyId?: string;
+    }): Promise<Record<string, unknown>>;
+    append(runId: string, records: RemoteTrustedSourceRecord[], idempotencyKey?: string): Promise<RemoteCollectorAck>;
+    heartbeat(input: {
+        collectorId: string;
+        signer: CustomerSourceSigner;
+        runId?: string;
+        pendingRecordCount: number;
+        lastAckSequence?: number;
+        occurredAt?: string;
+    }): Promise<Record<string, unknown>>;
+    reconcile(runId: string, receipt: Record<string, unknown>): Promise<Record<string, unknown>>;
+    proposeAction(proposal: Record<string, unknown>, idempotencyKey: string): Promise<Record<string, unknown>>;
+    getAction(actionId: string): Promise<Record<string, unknown>>;
+    issueExecutionGrant(actionId: string, grant: Record<string, unknown>, idempotencyKey: string): Promise<Record<string, unknown>>;
+    status(): Promise<Record<string, unknown>>;
+    revokeSourceKey(keyId: string): Promise<Record<string, unknown>>;
+    sink(): {
+        name: string;
+        write(record: RemoteTrustedSourceRecord): Promise<void>;
+    };
+    private json;
+}
+export declare class DurableRemoteCollectorQueue {
+    readonly runId: string;
+    readonly journalPath: string;
+    readonly ackPath: string;
+    private replayChain;
+    constructor(directory: string, runId: string);
+    enqueue(record: RemoteTrustedSourceRecord): Promise<void>;
+    pending(): Promise<RemoteTrustedSourceRecord[]>;
+    all(): Promise<RemoteTrustedSourceRecord[]>;
+    currentAck(): Promise<{
+        sequence: number;
+        eventHash?: string;
+    }>;
+    replay(client: {
+        append(runId: string, records: RemoteTrustedSourceRecord[], idempotencyKey?: string): Promise<RemoteCollectorAck>;
+    }): Promise<{
+        delivered: number;
+        ack?: {
+            sequence: number;
+            eventHash: string;
+        };
+    }>;
+    private readAck;
+    private writeAck;
+}
+export declare class RemoteCollectorApiError extends Error {
+    readonly status: number;
+    readonly code: string;
+    readonly recovery?: string | undefined;
+    constructor(status: number, code: string, message: string, recovery?: string | undefined);
+}
+//# sourceMappingURL=remote-collector.d.ts.map

package/dist/internal/control-client/remote-collector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"remote-collector.d.ts","sourceRoot":"","sources":["../../../../agentcert-sdk/src/remote-collector.ts"],"names":[],"mappings":"AAKA,MAAM,WAAW,oBAAoB;IACnC,KAAK,EAAE,MAAM,CAAC;IACd,aAAa,EAAE,MAAM,CAAC;IACtB,YAAY,EAAE,MAAM,CAAC;CACtB;AAeD,MAAM,WAAW,yBAAyB;IACxC,aAAa,EAAE,sCAAsC,CAAC;IACtD,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,eAAe,EAAE,MAAM,CAAA;KAAE,CAAC;IACxG,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACjC,aAAa,EAAE,MAAM,CAAC;IACtB,SAAS,EAAE,MAAM,CAAC;IAClB,eAAe,EAAE;QAAE,SAAS,EAAE,SAAS,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE,CAAC;CAC7E;AAED,MAAM,WAAW,kBAAkB;IACjC,aAAa,EAAE,qCAAqC,CAAC;IACrD,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,GAAG,EAAE;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE,CAAC;IAC7C,MAAM,EAAE,KAAK,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IACvC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAC9B;AAED,MAAM,WAAW,4BAA4B;IAC3C,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,OAAO,KAAK,CAAC;CACtB;AAED,qBAAa,qBAAqB;IACZ,QAAQ,CAAC,QAAQ,EAAE,MAAM;IAAE,OAAO,CAAC,KAAK;IAA5D,OAAO;WAEM,MAAM,CAAC,QAAQ,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,KAAK,SAAwF,GAAG,OAAO,CAAC,qBAAqB,CAAC;WAY5K,IAAI,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,qBAAqB,CAAC;IAOnE,IAAI,WAAW,IAAI,MAAM,CAAmC;IAE5D,YAAY,IAAI,oBAAoB;IAMpC,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,oBAAoB;IAM9C,YAAY,CAAC,aAAa,CAAC,EAAE,MAAM,GAAG;QAAE,WAAW,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,YAAY,EAAE,MAAM,CAAC;QAAC,aAAa,CAAC,EAAE,MAAM,CAAA;KAAE;IAMpH,MAAM,CAAC,KAAK,SAA6F,GAAG,OAAO,CAAC;QAAE,aAAa,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,oBAAoB,CAAA;KAAE,CAAC;YAcpK,OAAO;CAOtB;AAED,qBAAa,qBAAqB;IAChC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAS;IAChC,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAe;gBAEhC,OAAO,EAAE,4BAA4B;IAQjD,iBAAiB,CAAC,KAAK,EAAE;QAAE,WAAW,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,YAAY,EAAE,MAAM,CAAC;QAAC,aAAa,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAIhJ,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,yBAAyB,EAAE,EAAE,cAAc,SAAoD,GAAG,OAAO,CAAC,kBAAkB,CAAC;IAQ5J,SAAS,CAAC,KAAK,EAAE;QAAE,WAAW,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,oBAAoB,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAC;QAAC,kBAAkB,EAAE,MAAM,CAAC;QAAC,eAAe,CAAC,EAAE,MAAM,CAAC;QAAC,UAAU,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAiBpM,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAQ5F,aAAa,CAAC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,cAAc,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAQ1G,SAAS,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAI7D,mBAAmB,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,cAAc,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAQ/H,MAAM,IAAI,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAEpC,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAItE,IAAI,IAAI;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,MAAM,EAAE,yBAAyB,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;KAAE;YAOnE,IAAI;CASnB;AAED,qBAAa,2BAA2B;IAKP,QAAQ,CAAC,KAAK,EAAE,MAAM;IAJrD,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,OAAO,CAAC,WAAW,CAAoC;gBAE3C,SAAS,EAAE,MAAM,EAAW,KAAK,EAAE,MAAM;IAK/C,OAAO,CAAC,MAAM,EAAE,yBAAyB,GAAG,OAAO,CAAC,IAAI,CAAC;IAQzD,OAAO,IAAI,OAAO,CAAC,yBAAyB,EAAE,CAAC;IAO/C,GAAG,IAAI,OAAO,CAAC,yBAAyB,EAAE,CAAC;IAU3C,UAAU,IAAI,OAAO,CAAC;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,SAAS,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IAO/D,MAAM,CAAC,MAAM,EAAE;QAAE,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,yBAAyB,EAAE,EAAE,cAAc,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAAA;KAAE,GAAG,OAAO,CAAC;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,GAAG,CAAC,EAAE;YAAE,QAAQ,EAAE,MAAM,CAAC;YAAC,SAAS,EAAE,MAAM,CAAA;SAAE,CAAA;KAAE,CAAC;YAkB5M,OAAO;YAWP,QAAQ;CAcvB;AAUD,qBAAa,uBAAwB,SAAQ,KAAK;IACpC,QAAQ,CAAC,MAAM,EAAE,MAAM;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM;IAAmB,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM;gBAAlF,MAAM,EAAE,MAAM,EAAW,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAW,QAAQ,CAAC,EAAE,MAAM,YAAA;CAIxG"}