@agent-device/proxy 0.0.0-stage → 0.21.23

package/dist/version.mjs

@@ -0,0 +1,179 @@
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+//#region ../host-kit/src/internal/project-root.ts
+function resolveAgentDeviceProjectRoot(startDirectory) {
+	let current = startDirectory;
+	let nearest = null;
+	for (let i = 0; i < 8; i += 1) {
+		const pkgPath = path.join(current, "package.json");
+		if (fs.existsSync(pkgPath)) {
+			nearest ??= current;
+			try {
+				if (JSON.parse(fs.readFileSync(pkgPath, "utf8")).name === "agent-device") return current;
+			} catch {}
+		}
+		current = path.dirname(current);
+	}
+	return nearest ?? startDirectory;
+}
+/**
+* The daemon's own source, relative to a project root. One path answers two questions
+* with it: whether a tree is a source checkout at all, and which entry a checkout
+* launches its daemon from (`src/daemon-client/daemon-launch-spec.ts`).
+*/
+const DAEMON_SOURCE_ENTRY = "src/daemon.ts";
+/**
+* Whether `root` is a source checkout rather than an installed copy of a published
+* version. The published package ships its `bin` and `dist` and no `src`, so the
+* daemon's own source is what tells the two apart — and that is the difference between
+* a tree whose code can be rebuilt under its own version and one whose version already
+* fixes its bytes.
+*/
+function isSourceCheckoutProjectRoot(root) {
+	return fs.existsSync(path.join(root, "package.json")) && fs.existsSync(path.join(root, "src/daemon.ts"));
+}
+//#endregion
+//#region ../kernel/src/ttl-memo.ts
+const processMemoResets = /* @__PURE__ */ new Set();
+function createTtlMemo(options = {}) {
+	const entries = /* @__PURE__ */ new Map();
+	const now = options.now ?? (() => Date.now());
+	const clearEntryTimer = (entry) => {
+		if (entry?.timer) clearTimeout(entry.timer);
+	};
+	const memo = {
+		get(key) {
+			const entry = entries.get(key);
+			if (!entry) return void 0;
+			if (entry.expiresAt !== void 0 && entry.expiresAt <= now()) {
+				memo.delete(key);
+				return;
+			}
+			return entry.value;
+		},
+		set(key, value) {
+			clearEntryTimer(entries.get(key));
+			const expiresAt = resolveExpiresAt(options.ttlMs, now);
+			const entry = {
+				value,
+				expiresAt
+			};
+			if (options.scheduleExpiry && expiresAt !== void 0) {
+				entry.timer = setTimeout(() => {
+					entries.delete(key);
+				}, Math.max(0, expiresAt - now()));
+				entry.timer.unref?.();
+			}
+			entries.set(key, entry);
+		},
+		delete(key) {
+			const entry = entries.get(key);
+			if (!entry) return false;
+			clearEntryTimer(entry);
+			return entries.delete(key);
+		},
+		clear() {
+			for (const entry of entries.values()) clearEntryTimer(entry);
+			entries.clear();
+		}
+	};
+	processMemoResets.add(memo.clear);
+	return memo;
+}
+function resolveExpiresAt(ttlMs, now) {
+	if (ttlMs === void 0 || !Number.isFinite(ttlMs)) return void 0;
+	return now() + Math.max(0, ttlMs);
+}
+//#endregion
+//#region ../host-kit/src/internal/version.ts
+const versionMemo = createTtlMemo();
+const projectRootMemo = createTtlMemo();
+function readVersion(root = findProjectRoot()) {
+	const memoized = versionMemo.get(root);
+	if (memoized !== void 0) return memoized;
+	let pkg;
+	try {
+		pkg = JSON.parse(fs.readFileSync(path.join(root, "package.json"), "utf8"));
+	} catch {
+		return "0.0.0";
+	}
+	const version = typeof pkg.version === "string" ? pkg.version : "0.0.0";
+	versionMemo.set(root, version);
+	return version;
+}
+function findProjectRoot() {
+	const memoized = projectRootMemo.get("self");
+	if (memoized !== void 0) return memoized;
+	const resolved = resolveAgentDeviceProjectRoot(path.dirname(fileURLToPath(import.meta.url)));
+	projectRootMemo.set("self", resolved);
+	return resolved;
+}
+/**
+* Whether `candidate` is a later release than `baseline` (see {@link compareVersions}).
+*/
+function isNewerVersion(candidate, baseline) {
+	return compareVersions(candidate, baseline) > 0;
+}
+/**
+* SemVer order for the versions this package publishes: numeric `major.minor.patch` first, then a
+* release sorts after any prerelease of the same base (`0.21.13` > `0.21.13-dev`, the shape main
+* carries between releases), and prerelease fields compare per dot-separated field, numerically
+* when both are numbers and lexically otherwise. Build metadata is ignored. A string that is not a
+* version at all reads as `0.0.0`, so a malformed version always compares as the oldest.
+*/
+function compareVersions(left, right) {
+	const a = parseVersion(left);
+	const b = parseVersion(right);
+	return compareRelease(a.release, b.release) || comparePrerelease(a.prerelease, b.prerelease);
+}
+const SEMVER = /^v?(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/;
+function parseVersion(version) {
+	const match = SEMVER.exec(version.trim());
+	if (!match) return {
+		release: [
+			0,
+			0,
+			0
+		],
+		prerelease: []
+	};
+	return {
+		release: [
+			Number(match[1]),
+			Number(match[2]),
+			Number(match[3])
+		],
+		prerelease: match[4]?.split(".") ?? []
+	};
+}
+function compareRelease(a, b) {
+	for (let i = 0; i < 3; i += 1) if (a[i] !== b[i]) return a[i] > b[i] ? 1 : -1;
+	return 0;
+}
+/** A release (no prerelease) sorts after every prerelease of the same base. */
+function comparePrerelease(a, b) {
+	if (a.length === 0) return b.length === 0 ? 0 : 1;
+	if (b.length === 0) return -1;
+	const fields = Math.max(a.length, b.length);
+	for (let i = 0; i < fields; i += 1) {
+		const x = a[i];
+		const y = b[i];
+		if (x === void 0) return -1;
+		if (y === void 0) return 1;
+		const order = comparePrereleaseField(x, y);
+		if (order !== 0) return order;
+	}
+	return 0;
+}
+/** Numeric fields compare as numbers and sort below alphanumeric ones; the rest compare lexically. */
+function comparePrereleaseField(x, y) {
+	if (x === y) return 0;
+	const xNumeric = /^\d+$/.test(x);
+	const yNumeric = /^\d+$/.test(y);
+	if (xNumeric && yNumeric) return Number(x) > Number(y) ? 1 : -1;
+	if (xNumeric !== yNumeric) return xNumeric ? -1 : 1;
+	return x > y ? 1 : -1;
+}
+//#endregion
+export { DAEMON_SOURCE_ENTRY, compareVersions, findProjectRoot, isNewerVersion, isSourceCheckoutProjectRoot, readVersion };

package/package.json

@@ -1,6 +1,35 @@
 {
   "name": "@agent-device/proxy",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.21.23",
+  "type": "module",
+  "description": "Transport-neutral authenticating proxy in front of an agent-device daemon.",
+  "license": "MIT",
+  "author": "Callstack",
+  "homepage": "https://agent-device.dev/",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/callstack/agent-device.git",
+    "directory": "packages/proxy"
+  },
+  "engines": {
+    "node": ">=22.12"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist"
+  ],
+  "devDependencies": {
+    "@agent-device/contracts": "0.0.0",
+    "@agent-device/host-kit": "0.0.0",
+    "@agent-device/kernel": "0.0.0"
+  },
+  "scripts": {
+    "build": "tsdown --config tsdown.config.ts"
+  }
 }