@automaton-labs/aib 0.0.6 → 0.0.8

package/dist/workers/control-plane/client-config.default.json

@@ -0,0 +1,3 @@
+{
+  "schemaVersion": 1
+}

package/dist/workers/lexical-worker-child.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const lexical_worker_runtime_1 = require("./lexical-worker-runtime");
+const runtime = new lexical_worker_runtime_1.LexicalWorkerRuntime();
+let active = false;
+process.on("message", (message) => {
+    if (message.type === "job") {
+        if (active) {
+            send({ type: "error", id: message.id, error: { name: "Error", message: "Lexical worker received a concurrent job." } });
+            return;
+        }
+        active = true;
+        void runtime.run(message).then((output) => send({ type: "result", id: message.id, ...output }), (error) => send({ type: "error", id: message.id, error: serializeError(error) })).finally(() => { active = false; });
+        return;
+    }
+    send({ type: "shutdown", id: message.id });
+    process.disconnect?.();
+});
+send({ type: "ready", pid: process.pid, memory: process.memoryUsage() });
+function send(message) {
+    process.send?.(message);
+}
+function serializeError(error) {
+    if (!(error instanceof Error))
+        return { name: "Error", message: String(error) };
+    return { name: error.name, message: error.message, ...(error.stack ? { stack: error.stack } : {}) };
+}

package/dist/workers/lexical-worker-manager.js

@@ -0,0 +1,394 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LexicalWorkerTimeoutError = exports.LexicalWorkerManager = void 0;
+exports.readLexicalWorkerSessionMode = readLexicalWorkerSessionMode;
+exports.readLexicalWorkerDeadlineMs = readLexicalWorkerDeadlineMs;
+const node_crypto_1 = require("node:crypto");
+const node_child_process_1 = require("node:child_process");
+const path = __importStar(require("node:path"));
+const node_perf_hooks_1 = require("node:perf_hooks");
+const node_v8_1 = __importDefault(require("node:v8"));
+const env_vars_1 = require("../config/env-vars");
+const request_env_1 = require("../config/request-env");
+const workspace_root_1 = require("../config/workspace-root");
+const agent_text_1 = require("../shared/agent-text");
+class LexicalWorkerManager {
+    mode;
+    deadlineMs;
+    readyTimeoutMs;
+    shutdownTimeoutMs;
+    maxPendingJobs;
+    maxObservations;
+    childModulePath;
+    childEnv;
+    onObservation;
+    queue = [];
+    observations = [];
+    child = null;
+    childReady = null;
+    activeResponse = null;
+    draining = false;
+    disposed = false;
+    nextId = 1;
+    restartCount = 0;
+    constructor(options = {}) {
+        this.mode = options.mode ?? "shadow";
+        this.deadlineMs = Math.max(1, options.deadlineMs ?? 60_000);
+        this.readyTimeoutMs = Math.max(1, options.readyTimeoutMs ?? 5_000);
+        this.shutdownTimeoutMs = Math.max(1, options.shutdownTimeoutMs ?? 1_000);
+        this.maxPendingJobs = Math.max(0, Math.floor(options.maxPendingJobs ?? 1));
+        this.maxObservations = Math.max(1, Math.floor(options.maxObservations ?? 20));
+        this.childModulePath = options.childModulePath ?? path.join(__dirname, "lexical-worker-child.js");
+        this.childEnv = { ...process.env, [env_vars_1.CLI_ENV.disableWatchers]: "1", ...options.childEnv };
+        this.onObservation = options.onObservation;
+    }
+    get state() {
+        return {
+            childPid: this.child?.pid ?? null,
+            active: this.activeResponse !== null,
+            queued: this.queue.length,
+            restartCount: this.restartCount,
+            observations: this.observations.map((item) => ({ ...item }))
+        };
+    }
+    async executeInspectGraph(cwd, restArgs, stdinPayload, inProcess) {
+        const workspaceRoot = (0, workspace_root_1.resolveWorkspaceRoot)(cwd)?.root ?? path.resolve(cwd);
+        if (this.disposed)
+            return this.fallback("shutdown", workspaceRoot, inProcess);
+        if (this.mode === "shadow" && hasGraphWriteSideEffect(restArgs, stdinPayload)) {
+            const result = await inProcess();
+            this.observe({ status: "bypass", mode: "shadow", workspaceRoot });
+            return result;
+        }
+        if (this.draining && this.queue.length >= this.maxPendingJobs) {
+            return this.fallback("backpressure", workspaceRoot, inProcess);
+        }
+        const authoritative = this.mode === "shadow" ? await inProcess() : undefined;
+        return new Promise((resolve, reject) => {
+            const environment = stringEnvironment((0, request_env_1.snapshotRequestEnv)());
+            this.queue.push({
+                workspaceRoot,
+                cwd,
+                restArgs: [...restArgs],
+                stdinPayload,
+                environment,
+                inProcess,
+                ...(authoritative ? { authoritative } : {}),
+                resolve,
+                reject
+            });
+            void this.drain();
+        });
+    }
+    async shutdown() {
+        if (this.disposed)
+            return;
+        this.disposed = true;
+        for (const item of this.queue.splice(0)) {
+            const result = this.mode === "shadow" ? item.authoritative : await item.inProcess();
+            this.observe({ status: "shutdown", mode: this.mode, workspaceRoot: item.workspaceRoot, fallback: true });
+            item.resolve(result);
+        }
+        const child = this.child;
+        if (!child)
+            return;
+        const exit = onceExit(child);
+        if (child.connected)
+            this.send({ type: "shutdown", id: this.id("shutdown") });
+        await Promise.race([exit, delay(this.shutdownTimeoutMs)]);
+        if (this.child === child)
+            await this.terminateChild(new Error("Lexical worker shutdown."));
+    }
+    async drain() {
+        if (this.draining || this.disposed)
+            return;
+        this.draining = true;
+        try {
+            while (!this.disposed && this.queue.length > 0)
+                await this.runItem(this.queue.shift());
+        }
+        finally {
+            this.draining = false;
+        }
+    }
+    async runItem(item) {
+        const startedAt = node_perf_hooks_1.performance.now();
+        let startupMs = 0;
+        try {
+            const execution = await this.executeWorkerJob(item);
+            startupMs = execution.startupMs;
+            const response = execution.response;
+            if (this.mode === "shadow") {
+                const authoritative = item.authoritative;
+                const authoritativeText = JSON.stringify(authoritative);
+                const workerText = JSON.stringify(response.result);
+                this.observe({
+                    status: authoritativeText === workerText ? "parity" : "mismatch",
+                    mode: "shadow",
+                    workspaceRoot: item.workspaceRoot,
+                    structuredEqual: authoritativeText === workerText,
+                    agentTextEqual: authoritative[agent_text_1.AGENT_TEXT_FIELD] === response.result[agent_text_1.AGENT_TEXT_FIELD],
+                    authoritativeDigest: digest(authoritativeText),
+                    workerDigest: digest(workerText),
+                    elapsedMs: node_perf_hooks_1.performance.now() - startedAt,
+                    startupMs,
+                    requestBytes: execution.requestBytes,
+                    requestSerializeMs: execution.requestSerializeMs,
+                    metrics: response.metrics
+                });
+                item.resolve(authoritative);
+            }
+            else {
+                this.observe({
+                    status: "authoritative", mode: "authoritative", workspaceRoot: item.workspaceRoot,
+                    elapsedMs: node_perf_hooks_1.performance.now() - startedAt, startupMs, requestBytes: execution.requestBytes,
+                    requestSerializeMs: execution.requestSerializeMs, metrics: response.metrics
+                });
+                item.resolve(response.result);
+            }
+        }
+        catch (error) {
+            const timeout = error instanceof LexicalWorkerTimeoutError;
+            if (!timeout)
+                await this.terminateChild(error instanceof Error ? error : new Error(String(error)));
+            if (this.mode === "shadow") {
+                this.observe({
+                    status: timeout ? "timeout" : "error", mode: "shadow", workspaceRoot: item.workspaceRoot,
+                    elapsedMs: node_perf_hooks_1.performance.now() - startedAt, startupMs, error: errorMessage(error)
+                });
+                item.resolve(item.authoritative);
+                return;
+            }
+            const fallbackStartedAt = node_perf_hooks_1.performance.now();
+            try {
+                const result = await item.inProcess();
+                this.observe({
+                    status: timeout ? "timeout" : "error", mode: "authoritative", workspaceRoot: item.workspaceRoot,
+                    fallback: true, elapsedMs: node_perf_hooks_1.performance.now() - startedAt,
+                    fallbackMs: node_perf_hooks_1.performance.now() - fallbackStartedAt, startupMs, error: errorMessage(error)
+                });
+                item.resolve(result);
+            }
+            catch (fallbackError) {
+                item.reject(fallbackError);
+            }
+        }
+    }
+    async executeWorkerJob(item) {
+        const readyStartedAt = node_perf_hooks_1.performance.now();
+        await this.ensureChild();
+        const startupMs = node_perf_hooks_1.performance.now() - readyStartedAt;
+        const message = {
+            type: "job", id: this.id("job"), kind: "inspect-graph", workspaceRoot: item.workspaceRoot,
+            cwd: item.cwd, restArgs: item.restArgs, environment: item.environment,
+            ...(isJsonValue(item.stdinPayload) ? { stdinPayload: item.stdinPayload } : {})
+        };
+        const serializeStartedAt = node_perf_hooks_1.performance.now();
+        const requestBytes = node_v8_1.default.serialize(message).byteLength;
+        const requestSerializeMs = node_perf_hooks_1.performance.now() - serializeStartedAt;
+        return {
+            response: await this.request(message), startupMs,
+            requestBytes, requestSerializeMs
+        };
+    }
+    async ensureChild() {
+        if (this.child && this.childReady)
+            return void await this.childReady;
+        const startedAt = node_perf_hooks_1.performance.now();
+        const child = (0, node_child_process_1.fork)(this.childModulePath, [], {
+            env: this.childEnv, serialization: "advanced", stdio: ["ignore", "ignore", "ignore", "ipc"]
+        });
+        this.child = child;
+        this.childReady = withTimeout(new Promise((resolve, reject) => {
+            child.on("message", (message) => {
+                if (message.type === "ready")
+                    resolve(node_perf_hooks_1.performance.now() - startedAt);
+            });
+            child.once("error", reject);
+            child.once("exit", (code) => reject(new Error(`Lexical worker exited before ready (${code ?? "signal"}).`)));
+        }), this.readyTimeoutMs, () => new LexicalWorkerTimeoutError("Lexical worker ready deadline exceeded."));
+        child.on("message", (message) => this.handleMessage(message));
+        child.on("exit", (code, signal) => this.handleExit(child, code, signal));
+        try {
+            await this.childReady;
+        }
+        catch (error) {
+            await this.terminateChild(error instanceof Error ? error : new Error(String(error)));
+            throw error;
+        }
+    }
+    async request(message) {
+        if (!this.child?.connected)
+            throw new Error("Lexical worker is not connected.");
+        const response = new Promise((resolve, reject) => {
+            this.activeResponse = { id: message.id, resolve, reject };
+            if (!this.send(message)) {
+                this.activeResponse = null;
+                reject(new Error("Lexical worker IPC channel is not available."));
+            }
+        });
+        try {
+            return await withTimeout(response, this.deadlineMs, () => new LexicalWorkerTimeoutError("Lexical worker job deadline exceeded."));
+        }
+        catch (error) {
+            if (error instanceof LexicalWorkerTimeoutError)
+                await this.terminateChild(error);
+            throw error;
+        }
+    }
+    handleMessage(message) {
+        if (message.type === "ready")
+            return;
+        const active = this.activeResponse;
+        if (!active || active.id !== message.id)
+            return;
+        if (message.type === "error") {
+            this.activeResponse = null;
+            active.reject(new Error(message.error.message));
+        }
+        else if (message.type === "result") {
+            this.activeResponse = null;
+            active.resolve(message);
+        }
+    }
+    handleExit(child, code, signal) {
+        if (this.child !== child)
+            return;
+        this.child = null;
+        this.childReady = null;
+        this.restartCount += 1;
+        const active = this.activeResponse;
+        this.activeResponse = null;
+        active?.reject(new Error(`Lexical worker exited (${code ?? signal ?? "unknown"}).`));
+    }
+    async terminateChild(reason) {
+        const child = this.child;
+        if (!child)
+            return;
+        const active = this.activeResponse;
+        this.activeResponse = null;
+        active?.reject(reason);
+        const exit = onceExit(child);
+        child.kill();
+        await Promise.race([exit, delay(this.shutdownTimeoutMs)]);
+        if (this.child === child) {
+            this.child = null;
+            this.childReady = null;
+            this.restartCount += 1;
+        }
+    }
+    send(message) {
+        if (!this.child?.connected)
+            return false;
+        try {
+            return this.child.send(message);
+        }
+        catch {
+            return false;
+        }
+    }
+    id(prefix) { return `${prefix}_${this.nextId++}`; }
+    async fallback(status, workspaceRoot, inProcess) {
+        const startedAt = node_perf_hooks_1.performance.now();
+        const result = await inProcess();
+        const elapsedMs = node_perf_hooks_1.performance.now() - startedAt;
+        this.observe({ status, mode: this.mode, workspaceRoot, fallback: true, elapsedMs, fallbackMs: elapsedMs });
+        return result;
+    }
+    observe(input) {
+        const observation = { ...input, restartCount: this.restartCount };
+        this.observations.push(observation);
+        if (this.observations.length > this.maxObservations)
+            this.observations.shift();
+        this.onObservation?.(observation);
+        return observation;
+    }
+}
+exports.LexicalWorkerManager = LexicalWorkerManager;
+function readLexicalWorkerSessionMode(env = process.env) {
+    const raw = env[env_vars_1.CLI_ENV.lexicalWorkerMode]?.trim().toLowerCase();
+    return raw === "shadow" || raw === "authoritative" ? raw : "off";
+}
+function readLexicalWorkerDeadlineMs(env = process.env) {
+    const raw = env[env_vars_1.CLI_ENV.lexicalWorkerDeadlineMs];
+    const parsed = raw ? Number.parseInt(raw, 10) : Number.NaN;
+    return Number.isFinite(parsed) && parsed > 0 ? parsed : 60_000;
+}
+class LexicalWorkerTimeoutError extends Error {
+    code = "LEXICAL_WORKER_DEADLINE";
+}
+exports.LexicalWorkerTimeoutError = LexicalWorkerTimeoutError;
+function stringEnvironment(env) {
+    return Object.fromEntries(Object.entries(env).filter((item) => typeof item[1] === "string"));
+}
+function isJsonValue(value) {
+    if (value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean")
+        return true;
+    if (Array.isArray(value))
+        return value.every(isJsonValue);
+    return typeof value === "object" && value !== null && Object.values(value).every(isJsonValue);
+}
+function hasGraphWriteSideEffect(restArgs, stdinPayload) {
+    if (restArgs.some((arg) => arg === "--save" || arg.startsWith("--save=") || arg === "--to-file" || arg.startsWith("--to-file="))) {
+        return true;
+    }
+    return containsGraphWriteField(stdinPayload);
+}
+function containsGraphWriteField(value) {
+    if (Array.isArray(value))
+        return value.some(containsGraphWriteField);
+    if (!value || typeof value !== "object")
+        return false;
+    const record = value;
+    if ([record.save, record.toFile, record.outputFile].some((item) => typeof item === "string" && item.length > 0))
+        return true;
+    return Object.values(record).some(containsGraphWriteField);
+}
+function digest(value) { return (0, node_crypto_1.createHash)("sha256").update(value).digest("hex").slice(0, 16); }
+function errorMessage(error) { return error instanceof Error ? error.message : String(error); }
+function delay(ms) { return new Promise((resolve) => setTimeout(resolve, ms)); }
+function onceExit(child) {
+    return child.exitCode !== null ? Promise.resolve() : new Promise((resolve) => child.once("exit", () => resolve()));
+}
+function withTimeout(promise, timeoutMs, errorFactory) {
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => reject(errorFactory()), timeoutMs);
+        promise.then((value) => { clearTimeout(timer); resolve(value); }, (error) => { clearTimeout(timer); reject(error); });
+    });
+}

package/dist/workers/lexical-worker-protocol.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/workers/lexical-worker-runtime.js

@@ -0,0 +1,25 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LexicalWorkerRuntime = void 0;
+const node_perf_hooks_1 = require("node:perf_hooks");
+const node_v8_1 = __importDefault(require("node:v8"));
+const inspect_1 = require("../commands/inspect");
+const request_routing_context_1 = require("../config/request-routing-context");
+class LexicalWorkerRuntime {
+    async run(message) {
+        const startedAt = node_perf_hooks_1.performance.now();
+        const result = await (0, request_routing_context_1.runWithRequestRoutingContext)(message.cwd, message.environment, () => (0, inspect_1.runInspect)(message.cwd, message.restArgs, message.stdinPayload));
+        const jobMs = node_perf_hooks_1.performance.now() - startedAt;
+        const serializeStartedAt = node_perf_hooks_1.performance.now();
+        const serializedBytes = node_v8_1.default.serialize(result).byteLength;
+        const serializeMs = node_perf_hooks_1.performance.now() - serializeStartedAt;
+        return {
+            result,
+            metrics: { jobMs, serializedBytes, serializeMs, memory: process.memoryUsage() }
+        };
+    }
+}
+exports.LexicalWorkerRuntime = LexicalWorkerRuntime;

package/dist/workers/owned-one-shot-process.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runOwnedOneShotWorker = runOwnedOneShotWorker;
+const node_child_process_1 = require("node:child_process");
+const errors_1 = require("../shared/errors");
+const runtime_lifecycle_1 = require("../session/runtime-lifecycle");
+const EXIT_GRACE_MS = 1_000;
+const EXIT_FORCE_MS = 2_000;
+async function runOwnedOneShotWorker(input) {
+    const child = (0, node_child_process_1.fork)(input.workerPath, [], {
+        windowsHide: true,
+        detached: false,
+        stdio: ["ignore", "ignore", "ignore", "ipc"],
+        env: { ...process.env, ELECTRON_RUN_AS_NODE: "1" }
+    });
+    (0, runtime_lifecycle_1.trackSessionOwnedProcess)(child, input.lifecycleReason);
+    const pid = child.pid ?? null;
+    if (!pid) {
+        await terminate(child, null);
+        throw failure(input, "START_FAILED", `${input.label} did not publish a PID.`);
+    }
+    let timer = null;
+    try {
+        const result = await new Promise((resolve, reject) => {
+            let settled = false;
+            const onError = (error) => settle(failure(input, "START_FAILED", error.message));
+            const onExit = (code, signal) => settle(failure(input, "CRASHED", `${input.label} exited before a result (code=${String(code)}, signal=${String(signal)}).`));
+            const onMessage = (raw) => {
+                const value = input.validateResult(raw, pid);
+                settle(value === null ? failure(input, "PROTOCOL", `${input.label} returned malformed or mismatched evidence.`) : null, value ?? undefined);
+            };
+            const settle = (error, value) => {
+                if (settled)
+                    return;
+                settled = true;
+                if (timer)
+                    clearTimeout(timer);
+                child.removeListener("message", onMessage);
+                child.removeListener("error", onError);
+                child.removeListener("exit", onExit);
+                if (error)
+                    reject(error);
+                else
+                    resolve(value);
+            };
+            timer = setTimeout(() => settle(failure(input, "DEADLINE", `${input.label} exceeded its deadline.`)), input.deadlineMs);
+            timer.unref();
+            child.once("error", onError);
+            child.once("exit", onExit);
+            child.once("message", onMessage);
+            child.send(input.request, (error) => error && settle(failure(input, "START_FAILED", error.message)));
+        });
+        if (!await terminate(child, pid)) {
+            throw failure(input, "TERMINATION_FAILED", `Worker process-tree exit was not confirmed for PID ${pid}.`);
+        }
+        return result;
+    }
+    catch (error) {
+        if (!await terminate(child, pid)) {
+            throw failure(input, "TERMINATION_FAILED", `Worker failure was followed by unconfirmed process-tree exit for PID ${pid}.`);
+        }
+        throw error;
+    }
+    finally {
+        if (timer)
+            clearTimeout(timer);
+    }
+}
+function failure(input, suffix, message) {
+    return new errors_1.CliError(`${input.errorPrefix}_WORKER_${suffix}`, message);
+}
+async function terminate(child, pid) {
+    if (child.connected)
+        child.disconnect();
+    if (pid === null) {
+        try {
+            child.kill("SIGKILL");
+        }
+        catch { /* already gone */ }
+        return wait(child, null, EXIT_FORCE_MS);
+    }
+    if (process.platform === "win32") {
+        (0, node_child_process_1.spawnSync)("taskkill.exe", ["/PID", String(pid), "/T", "/F"], { windowsHide: true, stdio: "ignore", timeout: EXIT_FORCE_MS });
+    }
+    else {
+        try {
+            child.kill("SIGTERM");
+        }
+        catch { /* already gone */ }
+        if (await wait(child, pid, EXIT_GRACE_MS))
+            return true;
+        try {
+            child.kill("SIGKILL");
+        }
+        catch { /* already gone */ }
+    }
+    return wait(child, pid, EXIT_FORCE_MS);
+}
+async function wait(child, pid, timeout) {
+    const deadline = Date.now() + timeout;
+    while (Date.now() <= deadline) {
+        if ((pid === null || !alive(pid)) && exited(child))
+            return true;
+        await new Promise((resolve) => setTimeout(resolve, 20));
+    }
+    return (pid === null || !alive(pid)) && exited(child);
+}
+function alive(pid) { try {
+    process.kill(pid, 0);
+    return true;
+}
+catch {
+    return false;
+} }
+function exited(child) { return child.exitCode !== null || child.signalCode !== null; }

package/dist/workers/product-storage.js

@@ -0,0 +1,23 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.productStorageRoot = productStorageRoot;
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+const PRODUCT_STORAGE_NAME = "aib";
+const PRODUCT_STORAGE_ENV = "AIB_PRODUCT_STORAGE_DIR";
+function productStorageRoot() {
+    const override = process.env[PRODUCT_STORAGE_ENV];
+    if (override?.trim()) {
+        return node_path_1.default.resolve(override);
+    }
+    if (process.platform === "win32" && process.env.LOCALAPPDATA) {
+        return node_path_1.default.join(process.env.LOCALAPPDATA, PRODUCT_STORAGE_NAME);
+    }
+    if (process.env.XDG_STATE_HOME) {
+        return node_path_1.default.join(process.env.XDG_STATE_HOME, PRODUCT_STORAGE_NAME);
+    }
+    return node_path_1.default.join(node_os_1.default.homedir(), ".local", "state", PRODUCT_STORAGE_NAME);
+}