@cmmd-center/forge 0.9.14 → 0.9.16

package/dist/bin.cjs

@@ -65123,7 +65123,7 @@ function normalizeNumberish(value) {
 }
 //#endregion
 //#region package.json
-var version$1 = "0.9.14";
+var version$1 = "0.9.16";
 //#endregion
 //#region src/sentry.ts
 const SERVER_APP_NAME = "forge-server";
@@ -66945,13 +66945,13 @@ function validateCommandBootstrapPayload(payload) {
 		});
 		const payloadIdentity = normalizeCmmdUserIdentity(payload.user);
 		if (payloadIdentity) {
-			const cmmdIdentity = payloadIdentity.avatarUrl ? payloadIdentity : mergeCmmdUserIdentity(payloadIdentity, yield* fetchOptionalCmmdIdentityForAccessToken(payload.accessToken));
+			const cmmdIdentity = payloadIdentity.avatarUrl ? payloadIdentity : mergeCmmdUserIdentity(payloadIdentity, yield* fetchOptionalCmmdIdentityForAccessToken(cmmdUserCredential(payload)));
 			return {
 				subjectUserId: cmmdIdentity.id,
 				cmmdIdentity
 			};
 		}
-		const tokenIdentity = yield* fetchCmmdIdentityForAccessToken(payload.accessToken);
+		const tokenIdentity = yield* fetchCmmdIdentityForAccessToken(cmmdUserCredential(payload));
 		if (tokenIdentity) return {
 			subjectUserId: tokenIdentity.id,
 			cmmdIdentity: tokenIdentity
@@ -67044,6 +67044,23 @@ function isCmmdJwtToken(token) {
 	return token?.startsWith("eyJ") ?? false;
 }
 /**
+* The credential CMMD's userinfo accepts.
+*
+* Since CMMD's OAuth update, `access_token` is a JWT and the personal access
+* token arrives separately as `mcp_token`. userinfo authenticates the PAT and
+* rejects the JWT with `INVALID_OR_NON_USER_TOKEN`, so presenting the JWT
+* resolves no identity: the bootstrap then finds no subject and answers 401,
+* even though the sign-in itself succeeded and the caller did nothing wrong.
+*
+* `resolveCmmdTokenBundleCredentials` already draws this distinction for the
+* owner lanes. This is the same rule for the bootstrap lane, which had only ever
+* seen the pre-update shape where `access_token` was itself the PAT.
+*/
+function cmmdUserCredential(payload) {
+	const pat = payload.mcpToken?.trim();
+	return isCmmdJwtToken(payload.accessToken) && pat ? pat : payload.accessToken;
+}
+/**
 * Read one CMMD token-exchange response into the credential set Forge stores.
 *
 * Both owner lanes redeem the same `cmmd-forge-web` authorization code — the
@@ -92262,8 +92279,8 @@ const ProjectionThread = require_Schema$1.Struct({
 	createdAt: IsoDateTime,
 	updatedAt: IsoDateTime,
 	archivedAt: require_Schema$1.NullOr(IsoDateTime),
-	settledAt: require_Schema$1.optional(require_Schema$1.NullOr(IsoDateTime)),
-	settledOverride: require_Schema$1.optional(require_Schema$1.NullOr(require_Schema$1.Literals(["settled", "active"]))),
+	settledAt: require_Schema$1.NullOr(IsoDateTime),
+	settledOverride: require_Schema$1.NullOr(require_Schema$1.Literals(["settled", "active"])),
 	latestUserMessageAt: require_Schema$1.NullOr(IsoDateTime),
 	pendingApprovalCount: NonNegativeInt,
 	pendingUserInputCount: NonNegativeInt,
@@ -92449,16 +92466,23 @@ const FORGE_GIT_COMMIT_PATTERN = /^[0-9a-f]{7,40}$/i;
 /**
 * Resolve the commit this forge checkout actually booted from, so the
 * heartbeat can report it and CMMD can tell a stale Sprite from a current
-* one. Sprites clone forge ONLY at bootstrap (see the CMMD-side bootstrap
-* script) and nothing else refreshes them, so this value never changes for
-* the life of the process — resolve it once and cache it.
-*
-* `git rev-parse HEAD` run with the process's own cwd (`apps/server`, a
-* subdirectory of the cloned repo) walks up to find `.git` on its own; no
-* `-C` path is needed. Returns `undefined` (never throws) when there is no
-* git checkout to read — local dev run from a tarball, or any environment
-* this simply does not apply to — so the heartbeat body omits the field
-* exactly like an older Forge build that doesn't know about it yet.
+* one. The commit cannot change for the life of the process, so resolve it
+* once and cache it.
+*
+* This comment used to say Sprites clone forge at bootstrap and read their
+* commit from that checkout. They do not. A cloud runtime installs the
+* published `@cmmd-center/forge` tarball and has no `.git` anywhere near it,
+* which is why its descriptor reported no commit at all until the server
+* started baking one into its bundle. See `../environment/buildIdentity.ts`,
+* which calls this only as its last rung.
+*
+* `git rev-parse HEAD` run with the process's own cwd walks up to find `.git`
+* on its own, so no `-C` path is needed. That also means a cwd inside some
+* unrelated repository answers with that repository's HEAD, which is one more
+* reason this is the last rung rather than the first. Returns `undefined`
+* (never throws) when there is no checkout to read, so the heartbeat body
+* omits the field exactly like an older Forge build that does not know about
+* it yet.
 */
 let cached$1 = null;
 async function resolveForgeGitCommit(execImpl = (command, args) => execFileAsync$6(command, [...args], { timeout: 5e3 })) {
@@ -92830,7 +92854,7 @@ function hasValidRuntimeIdentity(value) {
 }
 function decodeRuntime$1(value) {
 	if (!isRecord$16(value) || !hasValidRuntimeIdentity(value)) return null;
-	if (!nullableString(value.endpointUrl) || value.endpointUrl !== null && !URL.canParse(value.endpointUrl) || !nullableInteger(value.deviceId) || !nullableInteger(value.projectId) || !nullableString(value.projectName) || !nullableString(value.workspaceRoot) || !nullableString(value.githubRepoFullName) || !(value.lastSeenAt === null || isIsoDateTime(value.lastSeenAt)) || !(value.metadata === null || isRecord$16(value.metadata))) return null;
+	if (!nullableString(value.endpointUrl) || value.endpointUrl !== null && !URL.canParse(value.endpointUrl) || !nullableInteger(value.deviceId) || !nullableString(value.workspaceRoot) || !nullableString(value.githubRepoFullName) || !(value.lastSeenAt === null || isIsoDateTime(value.lastSeenAt)) || !(value.metadata === null || isRecord$16(value.metadata))) return null;
 	return value;
 }
 function decodeProject(value) {
@@ -93141,8 +93165,6 @@ function replicaRuntimeMatches(left, right) {
 		[left.status, right.status],
 		[left.endpointUrl, right.endpointUrl],
 		[left.deviceId, right.deviceId],
-		[left.projectId, right.projectId],
-		[left.projectName, right.projectName],
 		[left.workspaceRoot, right.workspaceRoot],
 		[left.githubRepoFullName, right.githubRepoFullName],
 		[left.lastSeenAt, right.lastSeenAt]
@@ -206595,7 +206617,7 @@ function createDevServerMcpServer(deps, threadId) {
 * per provider — this module only adapts descriptor + result shapes.
 *
 * Without it a Claude agent has no brokered push path at all and falls back to
-* raw `git`, which the runtime deliberately blocks via `GIT_ASKPASS=/bin/false`.
+* raw `git`, which has no authenticated remote credentials in the agent runtime.
 *
 * The catalog is filtered through `applyPluginSkillPermissionsToDynamicTools`,
 * exactly as the Codex surface filters its dynamic tools. `settings` is required
@@ -287808,13 +287830,32 @@ const ObservabilityLive = require_Schema$1.unwrap(require_Schema$1.gen(function*
 //#region ../../packages/shared/src/buildCommit.ts
 const COMMIT_SHA_PATTERN$1 = /^[0-9a-f]{40}$/i;
 /**
+* Whether a value is a full commit sha.
+*
+* Exported so each surface can keep its own list of env names while sharing one
+* definition of "valid". Surfaces genuinely differ: Railway injects
+* RAILWAY_GIT_COMMIT_SHA into the cloud shell build, while the desktop release
+* workflows pass VITE_SENTRY_COMMIT_SHA. What must not differ is the check.
+*/
+function isFullCommitSha(value) {
+	const candidate = value?.trim();
+	return candidate !== void 0 && candidate !== "" && COMMIT_SHA_PATTERN$1.test(candidate);
+}
+/**
 * Build identity from the environment.
 *
 * `.dockerignore` excludes `.git`, so `git rev-parse HEAD` cannot resolve inside
 * the Railway container — the surface where "which commit is live?" is asked
 * most. The commit therefore has to arrive as env there, with git left as the
-* fallback for surfaces that genuinely are checkouts (a sprite clones forge at
-* bootstrap; desktop and dev run from a repo).
+* fallback for surfaces that genuinely are checkouts (desktop and dev run from
+* a repo).
+*
+* A cloud runtime is neither: it installs the published `@cmmd-center/forge`
+* tarball, so it has no build variables and no `.git`, and both rungs below
+* return nothing there. That is why the server bakes the commit into its bundle
+* at build time and reads that first — see `apps/server/src/environment/
+* buildIdentity.ts`. This comment previously claimed a sprite clones forge at
+* bootstrap; it does not, and believing it cost a diagnosis.
 *
 * `RAILWAY_GIT_COMMIT_SHA` is injected by the platform, which is what lets this
 * work on the cloud shell with no Dockerfile plumbing. `FORGE_BUILD_COMMIT`
@@ -287832,6 +287873,30 @@ function resolveBuildCommitFromEnv(env) {
 	}
 }
 //#endregion
+//#region src/environment/buildIdentity.ts
+/**
+* Which commit this server was built from.
+*
+* @module
+*/
+/**
+* The commit baked into this bundle, if it is a bundle at all.
+*
+* `typeof` rather than a bare reference: running from source there is no such
+* binding, and a bare reference is a ReferenceError that would take the whole
+* environment descriptor down instead of reporting an honest "unknown".
+*/
+function readBakedBuildCommit() {
+	return "e65edd4d1b8a361863a52b171b5e73295d691e11";
+}
+async function resolveServerBuildCommit(input) {
+	if (isFullCommitSha(input.baked)) return input.baked;
+	const fromEnv = resolveBuildCommitFromEnv(input.env);
+	if (fromEnv !== void 0) return fromEnv;
+	const fromGit = await input.readGitCommit();
+	return isFullCommitSha(fromGit) ? fromGit : void 0;
+}
+//#endregion
 //#region src/environment/Layers/ServerEnvironmentLabel.ts
 function normalizeLabel(value) {
 	const trimmed = value?.trim();
@@ -287980,7 +288045,11 @@ const makeServerEnvironment = require_Schema$1.fn("makeServerEnvironment")(funct
 	const initialMetadata = yield* readMetadata;
 	const displayNameOverrideRef = yield* require_HttpServer.make$3(normalizeDisplayName(initialMetadata.displayName ?? null));
 	const posthog = yield* PosthogPublicConfig.asEffect();
-	const buildCommit = resolveBuildCommitFromEnv(process.env) ?? (yield* require_Schema$1.promise(() => resolveForgeGitCommit()));
+	const buildCommit = yield* require_Schema$1.promise(() => resolveServerBuildCommit({
+		baked: readBakedBuildCommit(),
+		env: process.env,
+		readGitCommit: resolveForgeGitCommit
+	}));
 	const buildDescriptor = require_Schema$1.gen(function* () {
 		const displayNameOverride = yield* require_HttpServer.get$1(displayNameOverrideRef);
 		const os = platformOs();
@@ -296795,6 +296864,71 @@ function selectProviderUsageEnvironment(rawCatalog, ownerUserId) {
 	};
 }
 //#endregion
+//#region src/command/claudeUsageRefreshFailure.ts
+/**
+* Why a Claude usage refresh failed, in words the Usage page can show.
+*
+* CMMD answers a failed refresh with a machine reason (`runtime_not_active`,
+* `credential_changed`, …). The Shell used to collapse every one of them into
+* "Claude usage refresh is unavailable.", so the card could only say the
+* refresh failed, never what to do about it.
+*
+* The mapping is a closed allowlist in both directions: a reason CMMD may add
+* later falls back to the generic code, and the text a client sees is written
+* here, never forwarded from upstream. That keeps a credential or runtime
+* detail in a CMMD error body from reaching the browser.
+*/
+const FAILURE_TEXT = {
+	CLAUDE_USAGE_ENVIRONMENT_UNAVAILABLE: "Refresh needs your Environment running.",
+	CLAUDE_USAGE_CREDENTIAL_NOT_READY: "The Claude credential is not applied to your Environment yet.",
+	CLAUDE_USAGE_REFRESH_IN_PROGRESS: "A refresh for this account is already running.",
+	CLAUDE_USAGE_PROBE_FAILED: "Your Environment could not read Claude usage.",
+	CLAUDE_USAGE_RECONNECT_REQUIRED: "Reconnect this Claude account to refresh usage.",
+	CLAUDE_USAGE_ACCOUNT_NOT_FOUND: "This Claude account is no longer connected.",
+	CLAUDE_USAGE_REFRESH_UNAVAILABLE: "Claude usage refresh is unavailable."
+};
+/** Verbatim from CMMD `personal-claude-usage.ts` and `provider-usage-service.ts`. */
+const CODE_BY_UPSTREAM_REASON = {
+	runtime_not_active: "CLAUDE_USAGE_ENVIRONMENT_UNAVAILABLE",
+	claude_native_delivery_disabled: "CLAUDE_USAGE_ENVIRONMENT_UNAVAILABLE",
+	runtime_identity_mismatch: "CLAUDE_USAGE_ENVIRONMENT_UNAVAILABLE",
+	credential_generation_not_applied: "CLAUDE_USAGE_CREDENTIAL_NOT_READY",
+	credential_generation_unavailable: "CLAUDE_USAGE_CREDENTIAL_NOT_READY",
+	credential_changed: "CLAUDE_USAGE_CREDENTIAL_NOT_READY",
+	refresh_in_progress: "CLAUDE_USAGE_REFRESH_IN_PROGRESS",
+	usage_probe_failed: "CLAUDE_USAGE_PROBE_FAILED",
+	usage_receipt_invalid: "CLAUDE_USAGE_PROBE_FAILED",
+	usage_output_invalid: "CLAUDE_USAGE_PROBE_FAILED"
+};
+function failure(code, status) {
+	return {
+		status,
+		body: {
+			error: FAILURE_TEXT[code],
+			code
+		}
+	};
+}
+/**
+* CMMD sends the reason as `{ "error": "<reason>" }`. Anything else, including
+* a longer sentence that happens to start with an allowlisted word, is treated
+* as unknown.
+*/
+function readAllowlistedReasonCode(body) {
+	if (body === null || typeof body !== "object") return null;
+	const reason = body.error;
+	if (typeof reason !== "string") return null;
+	return Object.hasOwn(CODE_BY_UPSTREAM_REASON, reason) ? CODE_BY_UPSTREAM_REASON[reason] ?? null : null;
+}
+function describeClaudeUsageRefreshFailure(error) {
+	if (!(error instanceof CmmdProxyRequestError)) return failure("CLAUDE_USAGE_REFRESH_UNAVAILABLE", 502);
+	if (error.status === 409) return failure("CLAUDE_USAGE_RECONNECT_REQUIRED", 409);
+	if (error.status === 404) return failure("CLAUDE_USAGE_ACCOUNT_NOT_FOUND", 404);
+	const reasonCode = readAllowlistedReasonCode(error.body);
+	if (reasonCode !== null) return failure(reasonCode, 503);
+	return failure("CLAUDE_USAGE_REFRESH_UNAVAILABLE", error.status === 503 ? 503 : 502);
+}
+//#endregion
 //#region src/command/wsToken.ts
 /**
 * Build the WS token response given an optional PAT and the configured CMMD
@@ -298534,11 +298668,8 @@ function resolveProviderUsageOwnerUserId(session) {
 	return Number.isSafeInteger(userId) && userId > 0 ? userId : null;
 }
 function buildClaudeUsageRefreshErrorResponse(error) {
-	const status = error instanceof CmmdProxyRequestError && error.status === 503 ? 503 : 502;
-	return require_HttpServer.jsonUnsafe({
-		error: "Claude usage refresh is unavailable.",
-		code: "CLAUDE_USAGE_REFRESH_UNAVAILABLE"
-	}, { status });
+	const failure = describeClaudeUsageRefreshFailure(error);
+	return require_HttpServer.jsonUnsafe(failure.body, { status: failure.status });
 }
 function makeRefreshProviderUsageHandler(dependencies = {}) {
 	return require_Schema$1.gen(function* () {