@xopcai/xopc 0.0.372 → 0.0.374

package/dist/src/gateway/security/device-request-proof.js

@@ -0,0 +1,122 @@
+import { init_transaction, runSqliteWriteTransaction } from "../../storage/sqlite/transaction.js";
+import { getDevice, init_device_access_repository } from "../../storage/sqlite/device-access-repository.js";
+import { getOrCreateGatewayIdentity, init_gateway_identity_repository } from "../../storage/sqlite/gateway-identity-repository.js";
+import crypto from "node:crypto";
+//#region src/gateway/security/device-request-proof.ts
+init_device_access_repository();
+init_gateway_identity_repository();
+init_transaction();
+const REQUEST_PROOF_WINDOW_MS = 12e4;
+const PROOF_HEADER = "X-Xopc-Proof";
+const SIGNED_REQUEST_HEADERS = [
+	"content-type",
+	"idempotency-key",
+	"x-xopc-expected-session-key",
+	"x-endpoint-id",
+	"x-endpoint-upload-token"
+];
+const MAX_PENDING_NONCES = 1e5;
+const nonceBudgets = /* @__PURE__ */ new WeakMap();
+let activeProofBodies = 0;
+const activeDeviceBodies = /* @__PURE__ */ new Map();
+/** Bounds buffered uploads through route completion, after signature verification. */
+function acquireProofBodyBudget(deviceId) {
+	const count = activeDeviceBodies.get(deviceId) ?? 0;
+	if (activeProofBodies >= 16 || count >= 8) return void 0;
+	activeProofBodies++;
+	activeDeviceBodies.set(deviceId, count + 1);
+	let held = true;
+	return () => {
+		if (!held) return;
+		held = false;
+		activeProofBodies--;
+		const remaining = (activeDeviceBodies.get(deviceId) ?? 1) - 1;
+		if (remaining) activeDeviceBodies.set(deviceId, remaining);
+		else activeDeviceBodies.delete(deviceId);
+	};
+}
+function proofDigest(bytes) {
+	return crypto.createHash("sha256").update(bytes).digest("hex");
+}
+function parseRequestProof(header) {
+	if (!header || header.length > 256) return void 0;
+	const parts = header.split(".");
+	if (parts.length !== 4 || !/^\d{13}$/.test(parts[0]) || !/^[A-Za-z0-9_-]{22,64}$/.test(parts[1]) || !/^[a-f0-9]{64}$/.test(parts[2]) || !/^[A-Za-z0-9_-]{86}$/.test(parts[3])) return void 0;
+	return {
+		timestamp: Number(parts[0]),
+		nonce: parts[1],
+		digest: parts[2],
+		signature: parts[3]
+	};
+}
+function requestProofMessage(input) {
+	return [
+		"xopc-request-v1",
+		input.gatewayId,
+		proofDigest(input.credential),
+		input.method,
+		input.target,
+		input.proof.digest,
+		...SIGNED_REQUEST_HEADERS.map((name) => input.headers(name) ?? ""),
+		String(input.proof.timestamp),
+		input.proof.nonce
+	].join("\n");
+}
+function verifyRequestProofSignature(device, proof, message) {
+	try {
+		const key = crypto.createPublicKey({
+			key: device.publicKeyJwk,
+			format: "jwk"
+		});
+		return crypto.verify("sha256", Buffer.from(message), {
+			key,
+			dsaEncoding: "ieee-p1363"
+		}, Buffer.from(proof.signature, "base64url"));
+	} catch {
+		return false;
+	}
+}
+/** The unique insert happens before business effects; expiry includes future-dated proofs. */
+function consumeRequestNonce(deviceId, proof, now = Date.now()) {
+	return runSqliteWriteTransaction((db) => {
+		let budget = nonceBudgets.get(db);
+		if (!budget || now >= budget.cleanupAt) {
+			db.prepare("DELETE FROM device_request_nonces WHERE expires_at < ?").run(now);
+			const count = db.prepare("SELECT count(*) AS total FROM device_request_nonces").get();
+			budget = {
+				cleanupAt: now + 3e4,
+				total: count.total
+			};
+			nonceBudgets.set(db, budget);
+		}
+		if (Math.abs(now - proof.timestamp) > 12e4 || budget.total >= MAX_PENDING_NONCES) return false;
+		const inserted = db.prepare("INSERT OR IGNORE INTO device_request_nonces (device_id, nonce, expires_at) VALUES (?, ?, ?)").run(deviceId, proof.nonce, proof.timestamp + REQUEST_PROOF_WINDOW_MS).changes === 1;
+		if (inserted) budget.total++;
+		return inserted;
+	});
+}
+/** Native WebSocket upgrades bind the first ticket to the device key without another round trip. */
+function verifyDeviceConnectionProof(principalId, ticket, path, header) {
+	let device;
+	try {
+		device = getDevice(principalId);
+	} catch {
+		return false;
+	}
+	if (!device) return !header;
+	if (device.revokedAt !== void 0) return false;
+	if (!device.requestProofVersion && !header) return true;
+	const proof = parseRequestProof(header);
+	if (!proof || Math.abs(Date.now() - proof.timestamp) > 12e4 || proof.digest !== proofDigest("")) return false;
+	const message = requestProofMessage({
+		gatewayId: getOrCreateGatewayIdentity().id,
+		credential: ticket,
+		method: "CONNECT",
+		target: path,
+		headers: () => void 0,
+		proof
+	});
+	return verifyRequestProofSignature(device, proof, message) && consumeRequestNonce(device.id, proof);
+}
+//#endregion
+export { PROOF_HEADER, REQUEST_PROOF_WINDOW_MS, SIGNED_REQUEST_HEADERS, acquireProofBodyBudget, consumeRequestNonce, parseRequestProof, proofDigest, requestProofMessage, verifyDeviceConnectionProof, verifyRequestProofSignature };

package/dist/src/gateway/security/loopback.js

@@ -1,9 +1,6 @@
-import { isLoopbackHost } from "../host.js";
+import { __esmMin } from "../../../_virtual/_rolldown/runtime.js";
+import { init_host, isLoopbackHost } from "../host.js";
 //#region src/gateway/security/loopback.ts
-/**
-* Loopback / browser-origin classification helpers used by rate-limit policy
-* and other security middleware. Pure functions, no I/O.
-*/
 function isLoopbackClientIp(clientIp) {
 	if (!clientIp || clientIp === "unknown") return false;
 	const trimmed = clientIp.trim();
@@ -39,5 +36,9 @@ function getClientIpFromHeaders(headers) {
 	if (cf) return cf;
 	return "unknown";
 }
+var init_loopback = __esmMin((() => {
+	init_host();
+}));
 //#endregion
-export { getClientIpFromHeaders, isLoopbackBrowserOrigin, isLoopbackClientIp, isLoopbackEmbeddedBrowserClient };
+init_loopback();
+export { getClientIpFromHeaders, init_loopback, isLoopbackBrowserOrigin, isLoopbackClientIp, isLoopbackEmbeddedBrowserClient };

package/dist/src/gateway/service.js

@@ -8,6 +8,10 @@ import { init_logger } from "../utils/logger.js";
 import { closeXopcDatabase } from "../storage/sqlite/connection.js";
 import { getSqliteDatabase, init_transaction } from "../storage/sqlite/transaction.js";
 import { getBrowserTabBindingById, init_browser_tab_binding_repository } from "../storage/sqlite/browser-tab-binding-repository.js";
+import { buckets } from "./rate-limit/buckets.js";
+import { init_host, resolveEffectiveGatewayPort } from "./host.js";
+import { isGatewayStrictSecurityEnabled } from "./rate-limit/env-flags.js";
+import { init_rate_limit } from "./rate-limit/index.js";
 import { bumpSessionInputRevision, findSessionInput, init_session_input_repository, insertSessionInput } from "../storage/sqlite/session-input-repository.js";
 import { TaskRepository } from "../tasks/task-repository.js";
 import { TaskRunRepository, init_task_run_repository } from "../tasks/task-run-repository.js";
@@ -38,7 +42,6 @@ import { DomainOutboxDispatcher } from "../infra/domain-outbox-dispatcher.js";
 import { ProjectService } from "../projects/project-service.js";
 import { resolveProjectAgentId } from "../projects/project-agent.js";
 import "../projects/index.js";
-import { resolveEffectiveGatewayPort } from "./host.js";
 import { runMemoryMaintenance } from "../memory-maintenance/service.js";
 import "../memory-maintenance/index.js";
 import { RealtimeExtensionBrowserProvider } from "../browser/providers/realtime-extension.js";
@@ -72,10 +75,10 @@ import { bootstrapApplicationStateSync } from "../bootstrap/application-state.js
 import { setPairingBroadcastSink } from "../channels/pairing/pairing-events.js";
 import { registerClarificationChannelRuntime } from "./clarify-runtime.js";
 import { ChannelManager } from "../channels/manager.js";
-import { ChatPreviewService } from "../chat-previews/service.js";
-import "../chat-previews/index.js";
 import { getWorkspacePath } from "../config/workspace-path-helpers.js";
 import "../config/index.js";
+import { ChatPreviewService } from "../chat-previews/service.js";
+import "../chat-previews/index.js";
 import { ManagedComposioEventPoller } from "../connectors/composio-managed-events.js";
 import { startConnectedKnowledgeCoordinator } from "../knowledge/coordinator.js";
 import "../knowledge/index.js";
@@ -124,9 +127,6 @@ import { wireTunnelEventsToGateway } from "../tunnel/gateway-lifecycle.js";
 import { getExposureManager } from "../remote-access/exposure-manager.js";
 import { sanitizeTunnelConfig } from "../tunnel/tunnel-config.js";
 import { assertGatewayAuthNotKnownWeak } from "./security/known-weak-secrets.js";
-import { buckets } from "./rate-limit/buckets.js";
-import { isGatewayStrictSecurityEnabled } from "./rate-limit/env-flags.js";
-import "./rate-limit/index.js";
 import { assertGatewayRuntimeConfig } from "./runtime-config.js";
 import { auditGatewayConfig } from "./security/audit.js";
 import { getXopcCloudCatalogCoordinator } from "../providers/xopc-cloud-catalog-coordinator.js";
@@ -169,6 +169,8 @@ init_config_repository();
 init_changes();
 init_agent_scope();
 init_schema();
+init_host();
+init_rate_limit();
 init_providers();
 init_logger();
 init_log_stream();

package/dist/src/gateway/tailscale-auth.js

@@ -1,6 +1,7 @@
+import { init_host, isLoopbackHost } from "./host.js";
 import { readTailscaleWhoisIdentity } from "../infra/tailscale.js";
-import { isLoopbackHost } from "./host.js";
 //#region src/gateway/tailscale-auth.ts
+init_host();
 function parseTailscaleAuthHeaders(headers) {
 	return {
 		forwardedFor: headers["x-forwarded-for"]?.split(",")[0]?.trim(),

package/dist/src/gateway/ws-security.js

@@ -1,9 +1,10 @@
-import { isLoopbackHost } from "./host.js";
+import { init_host, isLoopbackHost } from "./host.js";
 import net from "node:net";
 //#region src/gateway/ws-security.ts
 /**
 * WebSocket / gateway URL transport security (OpenClaw-aligned).
 */
+init_host();
 function isPrivateOrLoopbackHost(hostname) {
 	const host = hostname.trim().toLowerCase();
 	if (isLoopbackHost(host)) return true;

package/dist/src/infra/rate-limit/failure-limiter.js

@@ -1,98 +1,86 @@
-import { KeyedStore } from "./keyed-store.js";
+import { __esmMin } from "../../../_virtual/_rolldown/runtime.js";
+import { KeyedStore, init_keyed_store } from "./keyed-store.js";
 //#region src/infra/rate-limit/failure-limiter.ts
-/**
-* Per-key brute-force protection limiter.
-*
-* Semantics:
-*   - `fail(key)` records a failed attempt; reaching `maxFailures` within
-*     `windowMs` triggers a `blockDurationMs` lockout.
-*   - `succeed(key)` clears all state for the key (a successful auth wipes the
-*     bucket so legitimate users aren't punished for prior typos).
-*   - `check(key)` is read-only — returns the current block status.
-*   - Failures from the same key within `burstCoalesceMs` collapse to a single
-*     attempt. This absorbs SPA fan-out / SDK auto-retry storms without
-*     weakening protection: a deliberate attacker is rate-limited to ~1
-*     attempt/s per key, still astronomically slow against any token of
-*     meaningful entropy.
-*
-* Pure counter — no policy knowledge (loopback exemption, key formatting,
-* etc. all live in the policy layer that calls into this limiter).
-*/
-const DEFAULT_BURST_COALESCE_MS = 1e3;
-var FailureLimiter = class {
-	store;
-	clock;
-	maxFailures;
-	windowMs;
-	blockDurationMs;
-	burstCoalesceMs;
-	constructor(cfg) {
-		this.maxFailures = Math.max(1, Math.floor(cfg.maxFailures));
-		this.windowMs = Math.max(1e3, Math.floor(cfg.windowMs));
-		this.blockDurationMs = Math.max(1e3, Math.floor(cfg.blockDurationMs));
-		this.burstCoalesceMs = Math.max(0, Math.floor(cfg.burstCoalesceMs ?? DEFAULT_BURST_COALESCE_MS));
-		this.clock = cfg.clock ?? Date.now;
-		this.store = new KeyedStore({
-			staleAfterMs: cfg.staleAfterMs ?? this.windowMs + this.blockDurationMs,
-			clock: this.clock
-		});
-	}
-	check(key) {
-		const now = this.clock();
-		const state = this.store.get(key);
-		if (!state?.blockedUntil) return { blocked: false };
-		if (now >= state.blockedUntil) {
-			state.blockedUntil = void 0;
-			state.count = 0;
-			state.windowStart = now;
-			state.lastTouchedMs = now;
-			return { blocked: false };
+var DEFAULT_BURST_COALESCE_MS, FailureLimiter;
+var init_failure_limiter = __esmMin((() => {
+	init_keyed_store();
+	DEFAULT_BURST_COALESCE_MS = 1e3;
+	FailureLimiter = class {
+		store;
+		clock;
+		maxFailures;
+		windowMs;
+		blockDurationMs;
+		burstCoalesceMs;
+		constructor(cfg) {
+			this.maxFailures = Math.max(1, Math.floor(cfg.maxFailures));
+			this.windowMs = Math.max(1e3, Math.floor(cfg.windowMs));
+			this.blockDurationMs = Math.max(1e3, Math.floor(cfg.blockDurationMs));
+			this.burstCoalesceMs = Math.max(0, Math.floor(cfg.burstCoalesceMs ?? DEFAULT_BURST_COALESCE_MS));
+			this.clock = cfg.clock ?? Date.now;
+			this.store = new KeyedStore({
+				staleAfterMs: cfg.staleAfterMs ?? this.windowMs + this.blockDurationMs,
+				clock: this.clock
+			});
 		}
-		return {
-			blocked: true,
-			retryAfterSec: Math.max(1, Math.ceil((state.blockedUntil - now) / 1e3))
-		};
-	}
-	fail(key) {
-		const now = this.clock();
-		let state = this.store.get(key);
-		if (!state) {
-			state = {
-				windowStart: now,
-				count: 0,
-				lastTouchedMs: now
+		check(key) {
+			const now = this.clock();
+			const state = this.store.get(key);
+			if (!state?.blockedUntil) return { blocked: false };
+			if (now >= state.blockedUntil) {
+				state.blockedUntil = void 0;
+				state.count = 0;
+				state.windowStart = now;
+				state.lastTouchedMs = now;
+				return { blocked: false };
+			}
+			return {
+				blocked: true,
+				retryAfterSec: Math.max(1, Math.ceil((state.blockedUntil - now) / 1e3))
 			};
-			this.store.set(key, state);
 		}
-		state.lastTouchedMs = now;
-		if (state.blockedUntil && now < state.blockedUntil) return;
-		if (state.blockedUntil && now >= state.blockedUntil) {
-			state.blockedUntil = void 0;
-			state.count = 0;
-			state.windowStart = now;
+		fail(key) {
+			const now = this.clock();
+			let state = this.store.get(key);
+			if (!state) {
+				state = {
+					windowStart: now,
+					count: 0,
+					lastTouchedMs: now
+				};
+				this.store.set(key, state);
+			}
+			state.lastTouchedMs = now;
+			if (state.blockedUntil && now < state.blockedUntil) return;
+			if (state.blockedUntil && now >= state.blockedUntil) {
+				state.blockedUntil = void 0;
+				state.count = 0;
+				state.windowStart = now;
+			}
+			if (now - state.windowStart > this.windowMs) {
+				state.count = 0;
+				state.windowStart = now;
+			}
+			if (state.lastFailureAtMs !== void 0 && now - state.lastFailureAtMs < this.burstCoalesceMs) {
+				state.lastFailureAtMs = now;
+				return;
+			}
+			state.lastFailureAtMs = now;
+			state.count += 1;
+			if (state.count >= this.maxFailures) state.blockedUntil = now + this.blockDurationMs;
 		}
-		if (now - state.windowStart > this.windowMs) {
-			state.count = 0;
-			state.windowStart = now;
+		succeed(key) {
+			this.store.delete(key);
 		}
-		if (state.lastFailureAtMs !== void 0 && now - state.lastFailureAtMs < this.burstCoalesceMs) {
-			state.lastFailureAtMs = now;
-			return;
+		/** @internal Test hook. */
+		resetForTests() {
+			this.store.clear();
+		}
+		destroy() {
+			this.store.destroy();
 		}
-		state.lastFailureAtMs = now;
-		state.count += 1;
-		if (state.count >= this.maxFailures) state.blockedUntil = now + this.blockDurationMs;
-	}
-	succeed(key) {
-		this.store.delete(key);
-	}
-	/** @internal Test hook. */
-	resetForTests() {
-		this.store.clear();
-	}
-	destroy() {
-		this.store.destroy();
-	}
-};
+	};
+}));
 //#endregion
-export { FailureLimiter };
+init_failure_limiter();
+export { FailureLimiter, init_failure_limiter };

package/dist/src/infra/rate-limit/index.js

@@ -1,3 +1,11 @@
-import { RateLimiter } from "./rate-limiter.js";
-import { FailureLimiter } from "./failure-limiter.js";
-export { FailureLimiter, RateLimiter };
+import { __esmMin } from "../../../_virtual/_rolldown/runtime.js";
+import { RateLimiter, init_rate_limiter } from "./rate-limiter.js";
+import { FailureLimiter, init_failure_limiter } from "./failure-limiter.js";
+//#region src/infra/rate-limit/index.ts
+var init_rate_limit = __esmMin((() => {
+	init_rate_limiter();
+	init_failure_limiter();
+}));
+//#endregion
+init_rate_limit();
+export { FailureLimiter, RateLimiter, init_rate_limit };

package/dist/src/infra/rate-limit/keyed-store.js

@@ -1,49 +1,54 @@
+import { __esmMin } from "../../../_virtual/_rolldown/runtime.js";
 //#region src/infra/rate-limit/keyed-store.ts
-var KeyedStore = class {
-	map = /* @__PURE__ */ new Map();
-	maxEntries;
-	overflow;
-	clock;
-	staleAfterMs;
-	cleanupTimer;
-	constructor(opts) {
-		this.maxEntries = Math.max(1, opts.maxEntries ?? 1e4);
-		this.clock = opts.clock ?? Date.now;
-		this.staleAfterMs = Math.max(1e3, opts.staleAfterMs);
-		const interval = Math.min(600 * 1e3, Math.max(1e3, opts.cleanupIntervalMs ?? Math.floor(this.staleAfterMs / 4)));
-		this.cleanupTimer = setInterval(() => this.sweep(), interval);
-		this.cleanupTimer.unref?.();
-	}
-	get(key) {
-		return this.map.get(key) ?? (this.map.size >= this.maxEntries ? this.overflow : void 0);
-	}
-	set(key, value) {
-		if (this.map.has(key) || this.map.size < this.maxEntries) this.map.set(key, value);
-		else this.overflow ??= value;
-	}
-	delete(key) {
-		this.map.delete(key);
-	}
-	size() {
-		return this.map.size;
-	}
-	clear() {
-		this.map.clear();
-		this.overflow = void 0;
-	}
-	destroy() {
-		if (this.cleanupTimer) {
-			clearInterval(this.cleanupTimer);
-			this.cleanupTimer = void 0;
-		}
-		this.map.clear();
-		this.overflow = void 0;
-	}
-	sweep() {
-		const now = this.clock();
-		if (this.overflow && now - this.overflow.lastTouchedMs > this.staleAfterMs) this.overflow = void 0;
-		for (const [k, v] of this.map.entries()) if (now - v.lastTouchedMs > this.staleAfterMs) this.map.delete(k);
-	}
-};
+var KeyedStore;
+var init_keyed_store = __esmMin((() => {
+	KeyedStore = class {
+		map = /* @__PURE__ */ new Map();
+		maxEntries;
+		overflow;
+		clock;
+		staleAfterMs;
+		cleanupTimer;
+		constructor(opts) {
+			this.maxEntries = Math.max(1, opts.maxEntries ?? 1e4);
+			this.clock = opts.clock ?? Date.now;
+			this.staleAfterMs = Math.max(1e3, opts.staleAfterMs);
+			const interval = Math.min(600 * 1e3, Math.max(1e3, opts.cleanupIntervalMs ?? Math.floor(this.staleAfterMs / 4)));
+			this.cleanupTimer = setInterval(() => this.sweep(), interval);
+			this.cleanupTimer.unref?.();
+		}
+		get(key) {
+			return this.map.get(key) ?? (this.map.size >= this.maxEntries ? this.overflow : void 0);
+		}
+		set(key, value) {
+			if (this.map.has(key) || this.map.size < this.maxEntries) this.map.set(key, value);
+			else this.overflow ??= value;
+		}
+		delete(key) {
+			this.map.delete(key);
+		}
+		size() {
+			return this.map.size;
+		}
+		clear() {
+			this.map.clear();
+			this.overflow = void 0;
+		}
+		destroy() {
+			if (this.cleanupTimer) {
+				clearInterval(this.cleanupTimer);
+				this.cleanupTimer = void 0;
+			}
+			this.map.clear();
+			this.overflow = void 0;
+		}
+		sweep() {
+			const now = this.clock();
+			if (this.overflow && now - this.overflow.lastTouchedMs > this.staleAfterMs) this.overflow = void 0;
+			for (const [k, v] of this.map.entries()) if (now - v.lastTouchedMs > this.staleAfterMs) this.map.delete(k);
+		}
+	};
+}));
 //#endregion
-export { KeyedStore };
+init_keyed_store();
+export { KeyedStore, init_keyed_store };

package/dist/src/infra/rate-limit/rate-limiter.js

@@ -1,63 +1,60 @@
-import { KeyedStore } from "./keyed-store.js";
+import { __esmMin } from "../../../_virtual/_rolldown/runtime.js";
+import { KeyedStore, init_keyed_store } from "./keyed-store.js";
 //#region src/infra/rate-limit/rate-limiter.ts
-/**
-* Per-key fixed-window request-rate limiter. Every `consume()` counts toward
-* the limit; once the window's count hits `maxRequests`, subsequent consumes
-* return `allowed: false` until the window rolls over.
-*
-* Use this for *throughput* limiting (e.g. "15 req/min on /admin"). For
-* *failure-rate* limiting with lockout (e.g. brute-force protection), use
-* {@link FailureLimiter} instead.
-*/
-var RateLimiter = class {
-	store;
-	clock;
-	maxRequests;
-	windowMs;
-	constructor(cfg) {
-		this.maxRequests = Math.max(1, Math.floor(cfg.maxRequests));
-		this.windowMs = Math.max(1, Math.floor(cfg.windowMs));
-		this.clock = cfg.clock ?? Date.now;
-		this.store = new KeyedStore({
-			staleAfterMs: cfg.staleAfterMs ?? this.windowMs * 4,
-			clock: this.clock
-		});
-	}
-	consume(key) {
-		const now = this.clock();
-		let state = this.store.get(key);
-		if (!state) {
-			state = {
-				windowStart: now,
-				count: 0,
-				lastTouchedMs: now
+var RateLimiter;
+var init_rate_limiter = __esmMin((() => {
+	init_keyed_store();
+	RateLimiter = class {
+		store;
+		clock;
+		maxRequests;
+		windowMs;
+		constructor(cfg) {
+			this.maxRequests = Math.max(1, Math.floor(cfg.maxRequests));
+			this.windowMs = Math.max(1, Math.floor(cfg.windowMs));
+			this.clock = cfg.clock ?? Date.now;
+			this.store = new KeyedStore({
+				staleAfterMs: cfg.staleAfterMs ?? this.windowMs * 4,
+				clock: this.clock
+			});
+		}
+		consume(key) {
+			const now = this.clock();
+			let state = this.store.get(key);
+			if (!state) {
+				state = {
+					windowStart: now,
+					count: 0,
+					lastTouchedMs: now
+				};
+				this.store.set(key, state);
+			}
+			if (now - state.windowStart >= this.windowMs) {
+				state.windowStart = now;
+				state.count = 0;
+			}
+			state.lastTouchedMs = now;
+			if (state.count >= this.maxRequests) return {
+				allowed: false,
+				remaining: 0,
+				retryAfterMs: Math.max(0, state.windowStart + this.windowMs - now)
+			};
+			state.count += 1;
+			return {
+				allowed: true,
+				remaining: this.maxRequests - state.count,
+				retryAfterMs: 0
 			};
-			this.store.set(key, state);
 		}
-		if (now - state.windowStart >= this.windowMs) {
-			state.windowStart = now;
-			state.count = 0;
+		/** @internal Test hook. */
+		resetForTests() {
+			this.store.clear();
+		}
+		destroy() {
+			this.store.destroy();
 		}
-		state.lastTouchedMs = now;
-		if (state.count >= this.maxRequests) return {
-			allowed: false,
-			remaining: 0,
-			retryAfterMs: Math.max(0, state.windowStart + this.windowMs - now)
-		};
-		state.count += 1;
-		return {
-			allowed: true,
-			remaining: this.maxRequests - state.count,
-			retryAfterMs: 0
-		};
-	}
-	/** @internal Test hook. */
-	resetForTests() {
-		this.store.clear();
-	}
-	destroy() {
-		this.store.destroy();
-	}
-};
+	};
+}));
 //#endregion
-export { RateLimiter };
+init_rate_limiter();
+export { RateLimiter, init_rate_limiter };

package/dist/src/infra/update-service-refresh.js

@@ -1,9 +1,10 @@
 import { createLogger } from "../utils/logger/index.js";
 import { init_logger } from "../utils/logger.js";
-import { SERVICE_VERSION_ENV_KEY, formatGatewayServiceDescription } from "../daemon/constants.js";
+import { SERVICE_VERSION_ENV_KEY, formatGatewayServiceDescription, init_constants } from "../daemon/constants.js";
 import path from "node:path";
 import fs from "node:fs/promises";
 //#region src/infra/update-service-refresh.ts
+init_constants();
 init_logger();
 const log = createLogger("UpdateServiceRefresh");
 function resolveBinPath(bin) {

package/dist/src/personal-agent/repository.d.ts

@@ -13,6 +13,9 @@ export interface PersonalAgentRecord {
         model: string;
         voice: string;
     } | null;
+    voiceCallPreferences: {
+        openingGreetingEnabled: boolean;
+    };
     preferences: Record<string, unknown>;
     revision: number;
     errorMessage: string | null;