@cmmd-center/forge 0.10.0 → 0.10.1

package/dist/bin.cjs

@@ -65224,7 +65224,7 @@ function normalizeNumberish(value) {
 }
 //#endregion
 //#region package.json
-var version$1 = "0.10.0";
+var version$1 = "0.10.1";
 //#endregion
 //#region src/sentry.ts
 const SERVER_APP_NAME = "forge-server";
@@ -68388,6 +68388,13 @@ const resolveBaseDir = require_Schema$1.fn(function* (raw) {
 	if (!raw || raw.trim().length === 0) return join(node_os.homedir(), ".forge");
 	return resolve(yield* expandHomePath$1(raw.trim()));
 });
+function bunHttpServerOptions(config) {
+	return {
+		port: config.port,
+		...config.host ? { hostname: config.host } : {},
+		idleTimeout: 120
+	};
+}
 //#endregion
 //#region ../../packages/shared/src/loopback.ts
 const LOOPBACK_HOSTNAMES$1 = new Set([
@@ -97911,6 +97918,31 @@ function mapClaudeRateLimitInfo(info) {
 		}
 	};
 }
+const SEVEN_DAY_MODEL_PREFIX = "seven_day_";
+const SEVEN_DAY_OVERAGE_SUFFIX = "overage_included";
+function capitalizeModelSuffix(suffix) {
+	return suffix.length === 0 ? suffix : suffix.charAt(0).toUpperCase() + suffix.slice(1);
+}
+/**
+* Maps a per-model weekly SDKRateLimitInfo (`seven_day_<model>`, e.g.
+* `seven_day_opus`) into a `ProviderUsageModelWindow`. `seven_day_overage_included`
+* is not a per-model window (it reports overage-inclusive quota, not a
+* specific model) and stays ignored here, same as plain `overage`.
+*/
+function mapClaudeModelRateLimitInfo(info) {
+	if (typeof info.utilization !== "number" || typeof info.resetsAt !== "number" || !info.status) return null;
+	if (!info.rateLimitType?.startsWith(SEVEN_DAY_MODEL_PREFIX)) return null;
+	const suffix = info.rateLimitType.slice(10);
+	if (suffix.length === 0 || suffix === SEVEN_DAY_OVERAGE_SUFFIX) return null;
+	return {
+		model: capitalizeModelSuffix(suffix),
+		window: {
+			usedPercent: Math.round(info.utilization * 100),
+			resetsAt: (/* @__PURE__ */ new Date(info.resetsAt * 1e3)).toISOString(),
+			status: info.status
+		}
+	};
+}
 const cachedSnapshots = /* @__PURE__ */ new Map();
 let localClaudeGenerationHash = null;
 function setLocalClaudeUsageGeneration(generationId) {
@@ -97920,22 +97952,71 @@ function currentClaudeUsageGenerationHash() {
 	const value = process.env.FORGE_PERSONAL_CLAUDE_GENERATION_HASH?.trim() ?? "";
 	return /^[a-f0-9]{64}$/.test(value) ? value : localClaudeGenerationHash;
 }
-/** Merges a single-window update into the cached snapshot without clobbering the other window. */
-function recordClaudeRateLimitTelemetry(info, generationHash = currentClaudeUsageGenerationHash(), providerAccountId) {
-	const mapped = mapClaudeRateLimitInfo(info);
-	if (!mapped || generationHash === null) return;
-	const observedAt = (/* @__PURE__ */ new Date()).toISOString();
-	const cacheKey = providerAccountId ? `${providerAccountId}:${generationHash}` : generationHash;
-	const previous = cachedSnapshots.get(cacheKey);
-	const fiveHourObservedAt = mapped.kind === "fiveHour" ? observedAt : previous?.fiveHourObservedAt ?? null;
-	const sevenDayObservedAt = mapped.kind === "sevenDay" ? observedAt : previous?.sevenDayObservedAt ?? null;
-	cachedSnapshots.set(cacheKey, {
-		fiveHour: mapped.kind === "fiveHour" ? mapped.window : previous?.fiveHour ?? null,
-		sevenDay: mapped.kind === "sevenDay" ? mapped.window : previous?.sevenDay ?? null,
+function cacheKeyFor(generationHash, providerAccountId) {
+	return providerAccountId ? `${providerAccountId}:${generationHash}` : generationHash;
+}
+/**
+* `observedAt` here is a placeholder, not an observation — it becomes
+* meaningful only once a standard (five_hour/seven_day) window actually
+* lands via `withStandardWindow`, which recomputes it from the retained
+* windows' own observation times. A per-model-only cache (no standard window
+* yet) still carries this placeholder, so callers should treat `observedAt`
+* as trustworthy only once `fiveHour` or `sevenDay` is non-null.
+*/
+function emptyCachedSnapshot(observedAt) {
+	return {
+		fiveHour: null,
+		sevenDay: null,
+		modelWindowsByModel: {},
+		observedAt,
+		fiveHourObservedAt: null,
+		sevenDayObservedAt: null
+	};
+}
+/** Oldest observation among the retained standard windows, so one fresh event cannot mask stale data. */
+function oldestObservedAt(fiveHourObservedAt, sevenDayObservedAt) {
+	return [fiveHourObservedAt, sevenDayObservedAt].filter((value) => value !== null).toSorted()[0];
+}
+function withStandardWindow(previous, mapped, observedAt) {
+	const isFiveHour = mapped.kind === "fiveHour";
+	const fiveHourObservedAt = isFiveHour ? observedAt : previous.fiveHourObservedAt;
+	const sevenDayObservedAt = isFiveHour ? previous.sevenDayObservedAt : observedAt;
+	return {
+		...previous,
+		fiveHour: isFiveHour ? mapped.window : previous.fiveHour,
+		sevenDay: isFiveHour ? previous.sevenDay : mapped.window,
 		fiveHourObservedAt,
 		sevenDayObservedAt,
-		observedAt: [fiveHourObservedAt, sevenDayObservedAt].filter((value) => value !== null).toSorted()[0]
-	});
+		observedAt: oldestObservedAt(fiveHourObservedAt, sevenDayObservedAt)
+	};
+}
+function withModelWindow(previous, mapped) {
+	return {
+		...previous,
+		modelWindowsByModel: {
+			...previous.modelWindowsByModel,
+			[mapped.model]: mapped.window
+		}
+	};
+}
+/**
+* Merges a single-window update into the cached snapshot without clobbering
+* the other windows. A per-model weekly report (`seven_day_<model>`) merges
+* into `modelWindowsByModel` keyed by model, leaving every other model and
+* the plain five_hour/seven_day windows untouched.
+*/
+function recordClaudeRateLimitTelemetry(info, generationHash = currentClaudeUsageGenerationHash(), providerAccountId) {
+	if (generationHash === null) return;
+	const cacheKey = cacheKeyFor(generationHash, providerAccountId);
+	const observedAt = (/* @__PURE__ */ new Date()).toISOString();
+	const previous = cachedSnapshots.get(cacheKey) ?? emptyCachedSnapshot(observedAt);
+	const standard = mapClaudeRateLimitInfo(info);
+	if (standard) {
+		cachedSnapshots.set(cacheKey, withStandardWindow(previous, standard, observedAt));
+		return;
+	}
+	const model = mapClaudeModelRateLimitInfo(info);
+	if (model) cachedSnapshots.set(cacheKey, withModelWindow(previous, model));
 }
 //#endregion
 //#region src/providerAuth/ClaudeDeviceAuth.ts
@@ -98139,6 +98220,44 @@ function parseUsageLine(output, label, now) {
 		status: usageStatus(usedPercent)
 	};
 }
+const MODEL_WEEK_LINE = /^Current week \(([^)]+)\): (\d+(?:\.\d+)?)% used(?: · resets (.+))?$/gm;
+const ALL_MODELS_LABEL = "all models";
+/** Matches CMMD's own bound in `personal-claude-usage.ts` — a model name past
+* this is treated as noise, not a real per-model window. */
+const MAX_MODEL_NAME_LENGTH = 64;
+/** Matches CMMD's own cap in `personal-claude-usage.ts`. */
+const MAX_MODEL_WINDOWS = 32;
+/**
+* Parses every "Current week (<Model>)" line except the "(all models)" row
+* already handled by `parseUsageLine`. The exclusion is case-insensitive to
+* match CMMD's own parser. A per-model line usually carries no reset suffix
+* of its own — Claude Code shows the same weekly reset as the all-models row
+* — so a missing suffix falls back to `sevenDayResetsAt`. A malformed line
+* (bad percent, unparsable reset, an implausibly long model name) is
+* skipped, not fatal: the two required lines are what fail closed, not these
+* optional extras. The result is capped at CMMD's own `modelWindows` bound so
+* an unexpectedly large or noisy `/usage` output can't grow the publish body
+* without limit.
+*/
+function parseModelUsageLines(output, sevenDayResetsAt, now) {
+	const windows = [];
+	for (const match of output.matchAll(MODEL_WEEK_LINE)) {
+		const model = match[1];
+		if (model.toLowerCase() === ALL_MODELS_LABEL) continue;
+		if (model.length > MAX_MODEL_NAME_LENGTH) continue;
+		const usedPercent = Number(match[2]);
+		if (!Number.isFinite(usedPercent) || usedPercent < 0 || usedPercent > 100) continue;
+		const resetsAt = match[3] ? parseResetAt(match[3], now) : sevenDayResetsAt;
+		if (resetsAt === null) continue;
+		windows.push({
+			model,
+			usedPercent,
+			resetsAt,
+			status: usageStatus(usedPercent)
+		});
+	}
+	return windows.slice(0, MAX_MODEL_WINDOWS);
+}
 async function fetchClaudeUsageViaOfficialClient(input) {
 	const raw = await (input.run ?? runClaudeUsageCommand)(input.binaryPath, USAGE_ARGS, input.claudeConfigDir);
 	const parsed = JSON.parse(raw);
@@ -98150,7 +98269,8 @@ async function fetchClaudeUsageViaOfficialClient(input) {
 	if (fiveHour === null || sevenDay === null) throw new Error("Claude client usage output shape changed.");
 	return {
 		fiveHour,
-		sevenDay
+		sevenDay,
+		modelWindows: parseModelUsageLines(parsed.result, sevenDay.resetsAt, now)
 	};
 }
 //#endregion
@@ -98348,27 +98468,61 @@ const logUsagePublishFailure = (failure, path) => failure === null ? require_Sch
 	stack: failure.cause instanceof Error ? failure.cause.stack : void 0,
 	path
 });
+/**
+* True only when CMMD's own telemetry schema is the reason the publish
+* failed, and only for a body that actually carried the field it can't
+* parse — never for a 400 caused by something else in the same body.
+*/
+function isModelWindowsRejection(cause, body) {
+	return cause instanceof CmmdProxyRequestError && cause.status === 400 && "modelWindows" in body;
+}
+/**
+* Sends the usage-publish body, tolerant of a CMMD deployment that has not
+* yet rolled out per-model windows. CMMD's telemetry schema is `.strict()`,
+* so an unrecognized `modelWindows` key fails the WHOLE body with a 400 —
+* losing fiveHour/sevenDay too, not just the field it can't parse yet. Retry
+* exactly once with that key omitted rather than losing the publish
+* outright; deploy CMMD first so this retry becomes unnecessary. A second
+* failure (still 400, or anything else) propagates like any other publish
+* failure — this is a rollout accommodation, not a general retry policy.
+*/
+async function publishUsageBody(jwt, path, body) {
+	try {
+		await cmmdGateway.request({
+			method: "POST",
+			jwt,
+			path,
+			body
+		});
+	} catch (cause) {
+		if (!isModelWindowsRejection(cause, body)) throw cause;
+		const { modelWindows: _modelWindows, ...bodyWithoutModelWindows } = body;
+		console.info("[cmmd-claude-cred-sync] usage publish retried without modelWindows — CMMD predates per-model rate-limit windows", { path });
+		await cmmdGateway.request({
+			method: "POST",
+			jwt,
+			path,
+			body: bodyWithoutModelWindows
+		});
+	}
+}
 async function publishClaudeUsageAfterSync(input) {
 	try {
 		const usage = await input.loadUsage({
 			binaryPath: resolveClaudeBinaryPath("claude"),
 			...input.homePath ? { claudeConfigDir: input.homePath } : {}
 		});
-		await cmmdGateway.request({
-			method: "POST",
-			jwt: input.auth.jwt,
-			path: input.auth.path === AUTH_RUNTIME_CLAUDE_CREDENTIAL_PATH ? AUTH_RUNTIME_CLAUDE_USAGE_PATH : USER_CLAUDE_USAGE_PATH,
-			body: {
-				providerAccountId: input.providerAccountId,
-				credentialGenerationId: input.credentialGenerationId,
-				accountEmail: input.accountEmail,
-				accountDisplayName: input.accountDisplayName,
-				planType: input.planType,
-				source: "active_poll",
-				fiveHour: usage.fiveHour,
-				sevenDay: usage.sevenDay,
-				observedAt: (/* @__PURE__ */ new Date()).toISOString()
-			}
+		await publishUsageBody(input.auth.jwt, input.auth.path === AUTH_RUNTIME_CLAUDE_CREDENTIAL_PATH ? AUTH_RUNTIME_CLAUDE_USAGE_PATH : USER_CLAUDE_USAGE_PATH, {
+			providerAccountId: input.providerAccountId,
+			credentialGenerationId: input.credentialGenerationId,
+			accountEmail: input.accountEmail,
+			accountDisplayName: input.accountDisplayName,
+			planType: input.planType,
+			source: "active_poll",
+			fiveHour: usage.fiveHour,
+			sevenDay: usage.sevenDay,
+			modelWindows: usage.modelWindows,
+			observedAt: (/* @__PURE__ */ new Date()).toISOString()
 		});
 		return null;
 	} catch (cause) {
@@ -288888,7 +289042,7 @@ function resolveBuildCommitFromEnv(env) {
 * environment descriptor down instead of reporting an honest "unknown".
 */
 function readBakedBuildCommit() {
-	return "4f80a79430e58ba6f2e487d692fdefeb66e8486f";
+	return "abd184dd1d3a4d5156ad021326b71afb06430b1b";
 }
 async function resolveServerBuildCommit(input) {
 	if (isFullCommitSha(input.baked)) return input.baked;
@@ -310629,6 +310783,7 @@ const claudeUsageHandler = (dependencies) => require_Schema$1.gen(function* () {
 				response = require_HttpServer.jsonUnsafe({
 					fiveHour: usage.fiveHour,
 					sevenDay: usage.sevenDay,
+					modelWindows: usage.modelWindows,
 					observedAt: observedAt.toISOString(),
 					receipt: {
 						orgId: claims.orgId,
@@ -310920,10 +311075,7 @@ const PtyAdapterLive = require_Schema$1.unwrap(require_Schema$1.gen(function* ()
 }));
 const HttpServerLive = require_Schema$1.unwrap(require_Schema$1.gen(function* () {
 	const config = yield* ServerConfig;
-	if (typeof Bun !== "undefined") return (yield* require_Schema$1.promise(() => Promise.resolve().then(() => require("./BunHttpServer-Cp9k4ybO.cjs")))).layer({
-		port: config.port,
-		...config.host ? { hostname: config.host } : {}
-	});
+	if (typeof Bun !== "undefined") return (yield* require_Schema$1.promise(() => Promise.resolve().then(() => require("./BunHttpServer-Cp9k4ybO.cjs")))).layer(bunHttpServerOptions(config));
 	const [NodeHttpServer, NodeHttp] = yield* require_Schema$1.all([require_Schema$1.promise(() => Promise.resolve().then(() => require("./NodeHttpServer-ClnvzpdU.cjs"))), require_Schema$1.promise(() => import("node:http"))]);
 	return NodeHttpServer.layer(NodeHttp.createServer, {
 		host: config.host,