@1mcp/agent 0.40.0-beta.0 → 0.40.0-beta.1

package/build/productTelemetry/index.d.ts

@@ -0,0 +1,15 @@
+import { InstallationStore } from './installationStore.js';
+import { type CommandCompletion, type CommandName, type FeatureName, type OperationName } from './producer.js';
+export { PRODUCT_NOTICE } from './notice.js';
+export declare function localInstallationStore(background?: boolean): InstallationStore;
+export declare function beginProductCommand(name: CommandName): CommandCompletion;
+export declare function beginProductFeature(name: FeatureName): CommandCompletion;
+export declare function recordProductFeature(name: FeatureName, outcome: 'success' | 'failure'): void;
+export declare function beginProductOperation(name: OperationName, transport: 'none' | 'stdio' | 'http' | 'sse', client: 'none' | 'claude' | 'codex' | 'cursor' | 'vscode' | 'other'): CommandCompletion;
+export declare function recordProductOperation(name: OperationName, outcome: 'success' | 'failure', transport: 'none' | 'stdio' | 'http' | 'sse', client: 'none' | 'claude' | 'codex' | 'cursor' | 'vscode' | 'other'): void;
+export declare function observeProductRuntimeConfiguration(name: 'servers' | 'tools', count: number): void;
+/** Snapshot only: attaches finite buckets to the next genuine activity. */
+export declare function observeProductConfiguration(name: 'servers' | 'tools', count: number): void;
+/** One invocation owns readiness/failure/cancellation; shutdown creates no outcome. */
+export declare function beginProductStartup(name: 'serve' | 'proxy' | 'runtime_start'): CommandCompletion;
+//# sourceMappingURL=index.d.ts.map

package/build/productTelemetry/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/productTelemetry/index.ts"],"names":[],"mappings":"AAWA,OAAO,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAE3D,OAAO,EACL,KAAK,iBAAiB,EACtB,KAAK,WAAW,EAChB,KAAK,WAAW,EAChB,KAAK,aAAa,EAEnB,MAAM,eAAe,CAAC;AAGvB,OAAO,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAE7C,wBAAgB,sBAAsB,CAAC,UAAU,UAAQ,GAAG,iBAAiB,CAK5E;AA4BD,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,WAAW,GAAG,iBAAiB,CAExE;AAED,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,WAAW,GAAG,iBAAiB,CAExE;AAED,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,WAAW,EAAE,OAAO,EAAE,SAAS,GAAG,SAAS,GAAG,IAAI,CAE5F;AAED,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,aAAa,EACnB,SAAS,EAAE,MAAM,GAAG,OAAO,GAAG,MAAM,GAAG,KAAK,EAC5C,MAAM,EAAE,MAAM,GAAG,QAAQ,GAAG,OAAO,GAAG,QAAQ,GAAG,QAAQ,GAAG,OAAO,GAClE,iBAAiB,CAEnB;AAED,wBAAgB,sBAAsB,CACpC,IAAI,EAAE,aAAa,EACnB,OAAO,EAAE,SAAS,GAAG,SAAS,EAC9B,SAAS,EAAE,MAAM,GAAG,OAAO,GAAG,MAAM,GAAG,KAAK,EAC5C,MAAM,EAAE,MAAM,GAAG,QAAQ,GAAG,OAAO,GAAG,QAAQ,GAAG,QAAQ,GAAG,OAAO,GAClE,IAAI,CAEN;AAED,wBAAgB,kCAAkC,CAAC,IAAI,EAAE,SAAS,GAAG,OAAO,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,CAEjG;AAED,2EAA2E;AAC3E,wBAAgB,2BAA2B,CAAC,IAAI,EAAE,SAAS,GAAG,OAAO,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,CAE1F;AAED,uFAAuF;AACvF,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,OAAO,GAAG,OAAO,GAAG,eAAe,GAAG,iBAAiB,CAyBhG"}

package/build/productTelemetry/index.js

@@ -0,0 +1,118 @@
+import path from 'node:path';
+import { getProductCollectionPolicy, initializeProductTelemetry, productCollectionEnabled, } from '../config/productTelemetryBootstrap.js';
+import { MCP_SERVER_VERSION } from '../constants.js';
+import { getGlobalConfigDir } from '../constants/paths.js';
+import { abortProductDelivery, dispatchProductBatch, prepareProductDelivery } from './delivery.js';
+import { InstallationStore } from './installationStore.js';
+import { writeProductNotice } from './notice.js';
+import { ProductUsageProducer, } from './producer.js';
+let producer;
+export { PRODUCT_NOTICE } from './notice.js';
+export function localInstallationStore(background = false) {
+    return new InstallationStore(path.join(getGlobalConfigDir(), 'product-telemetry'), {
+        background,
+        notice: writeProductNotice,
+    });
+}
+function collection() {
+    if (!productCollectionEnabled())
+        return;
+    try {
+        return initializeProductTelemetry(() => {
+            const policy = getProductCollectionPolicy();
+            producer ??= new ProductUsageProducer({
+                store: localInstallationStore(true),
+                now: Date.now,
+                dispatch: dispatchProductBatch,
+                prepareDelivery: prepareProductDelivery,
+                abortDelivery: abortProductDelivery,
+                dimensions: {
+                    version: MCP_SERVER_VERSION,
+                    os: platform(),
+                    arch: architecture(),
+                    node_major: Number(process.versions.node.split('.')[0]),
+                    ci: policy.ci,
+                },
+            });
+            return producer;
+        });
+    }
+    catch {
+        return;
+    }
+}
+export function beginProductCommand(name) {
+    return collection()?.beginCommand(name) ?? { finish: () => { } };
+}
+export function beginProductFeature(name) {
+    return collection()?.beginFeature(name) ?? { finish: () => { } };
+}
+export function recordProductFeature(name, outcome) {
+    collection()?.recordFeature(name, outcome);
+}
+export function beginProductOperation(name, transport, client) {
+    return collection()?.beginOperation(name, transport, client) ?? { finish: () => { } };
+}
+export function recordProductOperation(name, outcome, transport, client) {
+    collection()?.recordOperation(name, outcome, transport, client);
+}
+export function observeProductRuntimeConfiguration(name, count) {
+    producer?.observeRuntimeConfiguration(name, count);
+}
+/** Snapshot only: attaches finite buckets to the next genuine activity. */
+export function observeProductConfiguration(name, count) {
+    producer?.observeConfiguration(name, count);
+}
+/** One invocation owns readiness/failure/cancellation; shutdown creates no outcome. */
+export function beginProductStartup(name) {
+    const runtime = collection();
+    if (!runtime)
+        return { finish: () => { } };
+    runtime.startRuntime();
+    const command = name === 'runtime_start' ? runtime.beginRuntimeStartup() : runtime.beginCommand(name);
+    let finished = false;
+    const signals = ['SIGINT', 'SIGTERM', 'SIGHUP'];
+    const handlers = signals.map((signal) => {
+        const handler = () => {
+            completion.finish('failure');
+            // Preserve the default signal action when no lifecycle owner installed a handler yet.
+            if (process.listenerCount(signal) === 0)
+                process.kill(process.pid, signal);
+        };
+        process.prependOnceListener(signal, handler);
+        return handler;
+    });
+    const completion = {
+        finish(outcome) {
+            if (finished)
+                return;
+            finished = true;
+            signals.forEach((signal, index) => process.removeListener(signal, handlers[index]));
+            command.finish(outcome);
+        },
+    };
+    return completion;
+}
+function platform() {
+    switch (process.platform) {
+        case 'linux':
+        case 'darwin':
+        case 'win32':
+        case 'freebsd':
+            return process.platform;
+        default:
+            return 'other';
+    }
+}
+function architecture() {
+    switch (process.arch) {
+        case 'x64':
+        case 'arm64':
+        case 'arm':
+        case 'ia32':
+            return process.arch;
+        default:
+            return 'other';
+    }
+}
+//# sourceMappingURL=index.js.map

package/build/productTelemetry/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/productTelemetry/index.ts"],"names":[],"mappings":"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"}

package/build/productTelemetry/installationStore.d.ts

@@ -0,0 +1,117 @@
+import { z } from 'zod';
+import { type Summary } from './contract.js';
+declare const stateSchema: z.ZodObject<{
+    format: z.ZodLiteral<1>;
+    epoch: z.ZodUUID;
+    generation: z.ZodNumber;
+    preference: z.ZodEnum<{
+        default: "default";
+        disabled: "disabled";
+        enabled: "enabled";
+    }>;
+    installationId: z.ZodOptional<z.ZodUUID>;
+    noticed: z.ZodBoolean;
+    queue: z.ZodArray<z.ZodObject<{
+        installation_id: z.ZodUUID;
+        occurred_at: z.ZodISODateTime;
+        version: z.ZodString;
+        os: z.ZodEnum<{
+            darwin: "darwin";
+            freebsd: "freebsd";
+            linux: "linux";
+            win32: "win32";
+            other: "other";
+        }>;
+        arch: z.ZodEnum<{
+            other: "other";
+            x64: "x64";
+            arm64: "arm64";
+            arm: "arm";
+            ia32: "ia32";
+        }>;
+        node_major: z.ZodNumber;
+        ci: z.ZodBoolean;
+        counters: z.ZodArray<z.ZodObject<{
+            kind: z.ZodEnum<{
+                command: "command";
+                configuration: "configuration";
+                feature: "feature";
+                operation: "operation";
+            }>;
+            name: z.ZodString;
+            outcome: z.ZodEnum<{
+                failure: "failure";
+                success: "success";
+                observation: "observation";
+            }>;
+            transport: z.ZodEnum<{
+                http: "http";
+                sse: "sse";
+                stdio: "stdio";
+                none: "none";
+            }>;
+            client: z.ZodEnum<{
+                other: "other";
+                none: "none";
+                claude: "claude";
+                codex: "codex";
+                cursor: "cursor";
+                vscode: "vscode";
+            }>;
+            bucket: z.ZodEnum<{
+                1: "1";
+                0: "0";
+                none: "none";
+                "2-5": "2-5";
+                "6-20": "6-20";
+                "21-100": "21-100";
+                "101+": "101+";
+            }>;
+            count: z.ZodNumber;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+type State = z.infer<typeof stateSchema>;
+export interface PreparedDelivery {
+    dispatch(body: string): void;
+    cancel(): void;
+    isReady(): boolean;
+}
+export type PrepareDelivery = () => Promise<PreparedDelivery | undefined>;
+export interface AdmissionTicket {
+    readonly epoch: string;
+    readonly generation: number;
+    readonly installationId: string;
+}
+export interface InstallationStatus {
+    preference: State['preference'];
+    identityPresent: boolean;
+    queuedSummaries: number;
+    coordination: 'available' | 'busy-or-ambiguous';
+}
+export declare class InstallationStore {
+    private readonly root;
+    private readonly options;
+    constructor(root: string, options: {
+        notice: () => void | Promise<void>;
+        now?: () => number;
+        background?: boolean;
+    });
+    status(): Promise<InstallationStatus>;
+    control(action: 'enable' | 'disable' | 'reset'): Promise<void>;
+    admit(): Promise<AdmissionTicket | undefined>;
+    /** Read-only live-control observation; never creates an identity or admits activity. */
+    isCurrent(ticket: AdmissionTicket): Promise<boolean>;
+    append(ticket: AdmissionTicket, facts: Omit<Summary, 'installation_id'>): Promise<boolean>;
+    /** A durable final claim precedes payload handoff, within the generation lock. Prepare outside that lock. */
+    attemptSend(ticket: AdmissionTicket, dispatch: (body: string) => void | Promise<void>, prepare?: PrepareDelivery): Promise<void>;
+    private now;
+    private checkRoot;
+    private read;
+    private commit;
+    private cleanOrphanedWrites;
+    /** All acquisitions and dead-owner reclamation honor the same guard. An abandoned guard fails closed. */
+    private transaction;
+}
+export {};
+//# sourceMappingURL=installationStore.d.ts.map

package/build/productTelemetry/installationStore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"installationStore.d.ts","sourceRoot":"","sources":["../../src/productTelemetry/installationStore.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAiC,KAAK,OAAO,EAAiB,MAAM,eAAe,CAAC;AAI3F,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAQf,CAAC;AACH,KAAK,KAAK,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AACzC,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,MAAM,IAAI,IAAI,CAAC;IACf,OAAO,IAAI,OAAO,CAAC;CACpB;AACD,MAAM,MAAM,eAAe,GAAG,MAAM,OAAO,CAAC,gBAAgB,GAAG,SAAS,CAAC,CAAC;AAE1E,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;CACjC;AACD,MAAM,WAAW,kBAAkB;IACjC,UAAU,EAAE,KAAK,CAAC,YAAY,CAAC,CAAC;IAChC,eAAe,EAAE,OAAO,CAAC;IACzB,eAAe,EAAE,MAAM,CAAC;IACxB,YAAY,EAAE,WAAW,GAAG,mBAAmB,CAAC;CACjD;AAGD,qBAAa,iBAAiB;IAE1B,OAAO,CAAC,QAAQ,CAAC,IAAI;IACrB,OAAO,CAAC,QAAQ,CAAC,OAAO;gBADP,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE;QAAE,MAAM,EAAE,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;QAAC,GAAG,CAAC,EAAE,MAAM,MAAM,CAAC;QAAC,UAAU,CAAC,EAAE,OAAO,CAAA;KAAE;IAGtG,MAAM,IAAI,OAAO,CAAC,kBAAkB,CAAC;IAYrC,OAAO,CAAC,MAAM,EAAE,QAAQ,GAAG,SAAS,GAAG,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC;IAc9D,KAAK,IAAI,OAAO,CAAC,eAAe,GAAG,SAAS,CAAC;IAcnD,wFAAwF;IAClF,SAAS,CAAC,MAAM,EAAE,eAAe,GAAG,OAAO,CAAC,OAAO,CAAC;IAKpD,MAAM,CAAC,MAAM,EAAE,eAAe,EAAE,KAAK,EAAE,IAAI,CAAC,OAAO,EAAE,iBAAiB,CAAC,GAAG,OAAO,CAAC,OAAO,CAAC;IAyChG,6GAA6G;IACvG,WAAW,CACf,MAAM,EAAE,eAAe,EACvB,QAAQ,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,EAChD,OAAO,CAAC,EAAE,eAAe,GACxB,OAAO,CAAC,IAAI,CAAC;IAgDhB,OAAO,CAAC,GAAG;YAIG,SAAS;YAaT,IAAI;YAqBJ,MAAM;YA0BN,mBAAmB;IAWjC,yGAAyG;YAC3F,WAAW;CA6C1B"}

package/build/productTelemetry/installationStore.js

@@ -0,0 +1,400 @@
+import { randomUUID } from 'node:crypto';
+import { constants } from 'node:fs';
+import { lstat, mkdir, open, readdir, readFile, rename, rm } from 'node:fs/promises';
+import path from 'node:path';
+import { setTimeout as delay } from 'node:timers/promises';
+import { z } from 'zod';
+import { DAY, envelopeSchema, MAX_BODY, summarySchema } from './contract.js';
+import { secureNewInstallationEntry, verifyInstallationPrivacy } from './permissions.js';
+const MAX_QUEUE = 256 * 1024;
+const stateSchema = z.strictObject({
+    format: z.literal(1),
+    epoch: z.uuid(),
+    generation: z.number().int().nonnegative().safe(),
+    preference: z.enum(['default', 'enabled', 'disabled']),
+    installationId: z.uuid().optional(),
+    noticed: z.boolean(),
+    queue: z.array(summarySchema),
+});
+const ownerSchema = z.strictObject({ pid: z.number().int().positive(), nonce: z.uuid() });
+export class InstallationStore {
+    root;
+    options;
+    constructor(root, options) {
+        this.root = root;
+        this.options = options;
+    }
+    async status() {
+        await this.checkRoot(false);
+        const state = await this.read();
+        const busy = (await exists(path.join(this.root, 'guard'))) || (await exists(path.join(this.root, 'lock')));
+        return {
+            preference: state?.preference ?? 'default',
+            identityPresent: Boolean(state?.installationId),
+            queuedSummaries: state?.queue.length ?? 0,
+            coordination: busy ? 'busy-or-ambiguous' : 'available',
+        };
+    }
+    async control(action) {
+        await this.transaction(async () => {
+            const state = (await this.read()) ?? freshState();
+            if (action === 'enable')
+                state.preference = 'enabled';
+            if (action === 'disable')
+                state.preference = 'disabled';
+            if (action !== 'enable') {
+                state.generation++;
+                state.queue = [];
+            }
+            if (action === 'reset')
+                delete state.installationId;
+            await this.commit(state);
+        });
+    }
+    async admit() {
+        return this.transaction(async () => {
+            const state = (await this.read()) ?? freshState();
+            if (state.preference === 'disabled')
+                return undefined;
+            if (!state.noticed) {
+                await this.options.notice();
+                state.noticed = true;
+            }
+            state.installationId ??= randomUUID();
+            await this.commit(state);
+            return { epoch: state.epoch, generation: state.generation, installationId: state.installationId };
+        });
+    }
+    /** Read-only live-control observation; never creates an identity or admits activity. */
+    async isCurrent(ticket) {
+        await this.checkRoot(false);
+        return matches(await this.read(), ticket);
+    }
+    async append(ticket, facts) {
+        const incoming = summarySchema.omit({ installation_id: true }).parse(facts);
+        return this.transaction(async () => {
+            const state = await this.read();
+            if (!matches(state, ticket))
+                return false;
+            const now = this.now();
+            const pruned = prune(state, now);
+            if (now - Date.parse(incoming.occurred_at) > 7 * DAY) {
+                if (pruned)
+                    await this.commit(state);
+                return false;
+            }
+            if (Date.parse(incoming.occurred_at) - now > 300_000) {
+                if (pruned)
+                    await this.commit(state);
+                return false;
+            }
+            for (const counter of incoming.counters) {
+                let remaining = counter.count;
+                while (remaining > 0) {
+                    let summary = state.queue.find((s) => sameDimensions(s, incoming) && s.counters.some((c) => sameCounter(c, counter) && c.count < 1_000_000));
+                    summary ??= state.queue.find((s) => sameDimensions(s, incoming) && s.counters.length < 16);
+                    if (!summary) {
+                        summary = { ...incoming, installation_id: ticket.installationId, counters: [] };
+                        state.queue.push(summary);
+                    }
+                    const existing = summary.counters.find((c) => sameCounter(c, counter) && c.count < 1_000_000);
+                    const increment = Math.min(remaining, 1_000_000 - (existing?.count ?? 0));
+                    if (existing)
+                        existing.count += increment;
+                    else
+                        summary.counters.push({ ...counter, count: increment });
+                    if (incoming.occurred_at < summary.occurred_at)
+                        summary.occurred_at = incoming.occurred_at;
+                    remaining -= increment;
+                }
+            }
+            prune(state, now);
+            await this.commit(state);
+            return true;
+        });
+    }
+    /** A durable final claim precedes payload handoff, within the generation lock. Prepare outside that lock. */
+    async attemptSend(ticket, dispatch, prepare) {
+        let prepared;
+        let handedOff = false;
+        if (prepare) {
+            const hasQueuedData = await this.transaction(async () => {
+                const state = await this.read();
+                if (!matches(state, ticket))
+                    return false;
+                if (prune(state, this.now()))
+                    await this.commit(state);
+                return state.queue.length > 0;
+            });
+            if (!hasQueuedData)
+                return;
+            // DNS/TLS must not hold the generation lock or consume the durable queue.
+            prepared = await prepare();
+            if (!prepared)
+                return;
+        }
+        try {
+            await this.transaction(async () => {
+                const state = await this.read();
+                if (!matches(state, ticket))
+                    return;
+                const pruned = prune(state, this.now());
+                const batch = { schema_version: 1, batch_id: randomUUID(), summaries: [] };
+                for (const summary of state.queue.slice(0, 100)) {
+                    batch.summaries.push(summary);
+                    if (Buffer.byteLength(JSON.stringify(batch), 'utf8') > MAX_BODY) {
+                        batch.summaries.pop();
+                        break;
+                    }
+                }
+                if (!batch.summaries.length) {
+                    if (pruned)
+                        await this.commit(state);
+                    return;
+                }
+                if (prepared && !prepared.isReady())
+                    return;
+                const body = JSON.stringify(envelopeSchema.parse(batch));
+                state.queue.splice(0, batch.summaries.length);
+                await this.commit(state);
+                handedOff = true;
+                try {
+                    void Promise.resolve((prepared?.dispatch ?? dispatch)(body)).catch(() => { });
+                }
+                catch {
+                    /* Every attempt is final. */
+                }
+            });
+        }
+        finally {
+            if (!handedOff)
+                prepared?.cancel();
+        }
+    }
+    now() {
+        return this.options.now?.() ?? Date.now();
+    }
+    async checkRoot(create) {
+        const created = create ? await mkdir(this.root, { recursive: true, mode: 0o700 }) : undefined;
+        try {
+            await verifyInstallationPrivacy(this.root, {
+                background: this.options.background,
+                created: created !== undefined,
+            });
+        }
+        catch (error) {
+            if (!create && isMissing(error))
+                return;
+            throw error;
+        }
+    }
+    async read() {
+        const file = path.join(this.root, 'state.json');
+        try {
+            await checkPrivate(file, false);
+            const handle = await open(file, process.platform === 'win32' ? constants.O_RDONLY : constants.O_RDONLY | constants.O_NOFOLLOW, 0o600);
+            try {
+                if ((await handle.stat()).size > MAX_QUEUE + 4096)
+                    throw new Error('Oversized product state');
+                return stateSchema.parse(JSON.parse(await handle.readFile('utf8')));
+            }
+            finally {
+                await handle.close();
+            }
+        }
+        catch (error) {
+            if (isMissing(error))
+                return undefined;
+            throw new Error('Product telemetry state unavailable; retain state and use offline recovery');
+        }
+    }
+    async commit(state) {
+        stateSchema.parse(state);
+        const temporary = path.join(this.root, `state-${randomUUID()}.tmp`);
+        try {
+            const handle = await open(temporary, 'wx', 0o600);
+            try {
+                await secureNewInstallationEntry(temporary, false, this.options.background);
+                await handle.writeFile(JSON.stringify(state));
+                await handle.sync();
+            }
+            finally {
+                await handle.close();
+            }
+            await rename(temporary, path.join(this.root, 'state.json'));
+            if (process.platform !== 'win32') {
+                const directory = await open(this.root, 'r');
+                try {
+                    await directory.sync();
+                }
+                finally {
+                    await directory.close();
+                }
+            }
+        }
+        finally {
+            await rm(temporary, { force: true });
+        }
+    }
+    async cleanOrphanedWrites() {
+        const entries = await readdir(this.root);
+        if (entries.length > 256)
+            throw new Error('Product telemetry temporary state requires offline recovery');
+        for (const entry of entries) {
+            if (!/^state-[0-9a-f-]{36}\.tmp$/.test(entry))
+                continue;
+            const file = path.join(this.root, entry);
+            await checkPrivate(file, false);
+            await rm(file);
+        }
+    }
+    /** All acquisitions and dead-owner reclamation honor the same guard. An abandoned guard fails closed. */
+    async transaction(work) {
+        await this.checkRoot(true);
+        const nonce = randomUUID();
+        const guard = path.join(this.root, 'guard');
+        const lock = path.join(this.root, 'lock');
+        const acquisitionDeadline = performance.now() + (process.platform === 'win32' ? 5000 : 1000);
+        while (performance.now() < acquisitionDeadline) {
+            let guarded = false;
+            let locked = false;
+            try {
+                try {
+                    await mkdir(guard, { mode: 0o700 });
+                }
+                catch (error) {
+                    if (isExists(error)) {
+                        await delay(10, undefined, { ref: !this.options.background });
+                        continue;
+                    }
+                    throw error;
+                }
+                await secureNewInstallationEntry(guard, true, this.options.background);
+                await writeOwner(guard, nonce, this.options.background);
+                guarded = true;
+                if (await exists(lock)) {
+                    const owner = ownerSchema.safeParse(await readOwner(lock));
+                    if (!owner.success || !demonstrablyDead(owner.data.pid)) {
+                        await delay(10, undefined, { ref: !this.options.background });
+                        continue;
+                    }
+                    await rm(lock, { recursive: true });
+                }
+                await mkdir(lock, { mode: 0o700 });
+                await secureNewInstallationEntry(lock, true, this.options.background);
+                await writeOwner(lock, nonce, this.options.background);
+                locked = true;
+                await release(guard, nonce);
+                guarded = false;
+                await this.cleanOrphanedWrites();
+                return await work();
+            }
+            finally {
+                if (locked)
+                    await release(lock, nonce);
+                if (guarded)
+                    await release(guard, nonce);
+            }
+        }
+        throw new Error('Product telemetry coordination busy or ambiguous; use offline recovery');
+    }
+}
+function freshState() {
+    return { format: 1, epoch: randomUUID(), generation: 0, preference: 'default', noticed: false, queue: [] };
+}
+function isMissing(error) {
+    return hasCode(error, 'ENOENT');
+}
+function isExists(error) {
+    return hasCode(error, 'EEXIST');
+}
+function hasCode(error, code) {
+    return error instanceof Error && 'code' in error && error.code === code;
+}
+async function exists(file) {
+    try {
+        await lstat(file);
+        return true;
+    }
+    catch (error) {
+        if (isMissing(error))
+            return false;
+        throw error;
+    }
+}
+async function checkPrivate(file, directory) {
+    const info = await lstat(file);
+    if (info.isSymbolicLink() || (directory ? !info.isDirectory() : !info.isFile()))
+        throw new Error('Product telemetry path is not private');
+    if (process.platform === 'win32')
+        return;
+    if (info.uid !== process.getuid?.() || (info.mode & 0o077) !== 0)
+        throw new Error('Product telemetry path is not owner-only');
+}
+async function writeOwner(directory, nonce, background = false) {
+    const file = await open(path.join(directory, 'owner.json'), 'wx', 0o600);
+    try {
+        await secureNewInstallationEntry(path.join(directory, 'owner.json'), false, background);
+        await file.writeFile(JSON.stringify({ pid: process.pid, nonce }));
+        await file.sync();
+    }
+    finally {
+        await file.close();
+    }
+}
+async function readOwner(directory) {
+    try {
+        await checkPrivate(directory, true);
+        await checkPrivate(path.join(directory, 'owner.json'), false);
+        return JSON.parse(await readFile(path.join(directory, 'owner.json'), 'utf8'));
+    }
+    catch {
+        return undefined;
+    }
+}
+async function release(directory, nonce) {
+    const owner = ownerSchema.safeParse(await readOwner(directory));
+    if (owner.success && owner.data.nonce === nonce && owner.data.pid === process.pid)
+        await rm(directory, { recursive: true });
+}
+function demonstrablyDead(pid) {
+    try {
+        process.kill(pid, 0);
+        return false;
+    }
+    catch (error) {
+        return hasCode(error, 'ESRCH');
+    }
+}
+function matches(state, ticket) {
+    if (!state || state.preference === 'disabled')
+        return false;
+    return (state.epoch === ticket.epoch &&
+        state.generation === ticket.generation &&
+        state.installationId === ticket.installationId);
+}
+function sameCounter(a, b) {
+    return (a.kind === b.kind &&
+        a.name === b.name &&
+        a.outcome === b.outcome &&
+        a.transport === b.transport &&
+        a.client === b.client &&
+        a.bucket === b.bucket);
+}
+function sameDimensions(a, b) {
+    return (a.occurred_at.slice(0, 10) === b.occurred_at.slice(0, 10) &&
+        a.version === b.version &&
+        a.os === b.os &&
+        a.arch === b.arch &&
+        a.node_major === b.node_major &&
+        a.ci === b.ci);
+}
+function prune(state, now) {
+    const previousLength = state.queue.length;
+    state.queue = state.queue.filter((s) => now - Date.parse(s.occurred_at) <= 7 * DAY);
+    state.queue.sort((a, b) => a.occurred_at.localeCompare(b.occurred_at));
+    while (Buffer.byteLength(JSON.stringify(state.queue), 'utf8') > MAX_QUEUE)
+        state.queue.shift();
+    return state.queue.length !== previousLength;
+}
+//# sourceMappingURL=installationStore.js.map