dsh-agy 0.2.6 → 0.2.8

package/lib/{accounts-CjOuS29o.mjs → accounts-Um8N9I56.mjs}

@@ -4,6 +4,7 @@ import { createCipheriv, createDecipheriv, createHash, randomBytes, randomUUID }
 import { existsSync, mkdirSync, readFileSync, renameSync, statSync, writeFileSync } from "node:fs";
 import { dirname, join, resolve } from "node:path";
 import lockfile from "proper-lockfile";
+import { Document, isMap, isScalar, parseDocument } from "yaml";
 //#region src/types.ts
 /**
 * Host-independent authentication error. The adapter maps `kind` to the DSH
@@ -102,7 +103,7 @@ const AGY_DEFAULT_REDIRECT_URI = "http://localhost:51121/oauth-callback";
 * Antigravity API endpoints. The daily runtime host (no .sandbox suffix) is the
 * live endpoint for consumer OAuth accounts — cloudcode-pa.googleapis.com
 * answers RESOURCE_EXHAUSTED for them (verified by live probe), while the
-* daily host answers 200. Order matters: first reachable non-429/403 wins.
+* daily host answers 200. Order matters: first reachable non-429/403/503 wins.
 */
 const AGY_ENDPOINT_DAILY = "https://daily-cloudcode-pa.googleapis.com";
 const AGY_ENDPOINT_PROD = "https://cloudcode-pa.googleapis.com";
@@ -115,13 +116,24 @@ const AGY_ENDPOINT_FALLBACKS = [
 	AGY_ENDPOINT_DAILY_SANDBOX,
 	AGY_ENDPOINT_AUTOPUSH
 ];
-/** Statuses that mean "this endpoint is not usable for this account"; skip to the next. */
-const AGY_ENDPOINT_SKIP_STATUSES = /* @__PURE__ */ new Set([429, 403]);
 /**
-* Try each runtime endpoint in order, skipping unusable ones (429/403/network).
+* Statuses that mean "this endpoint is not usable for this attempt"; skip to the
+* next one in the chain. 429/403 = rate/quota/entitlement wall, 503 = capacity
+* rejection (e.g. "No capacity available for model ..."). A 503 skipped here
+* still reaches the caller when every endpoint fails, where the classifier marks
+* it transient and the adapter surfaces it as a retryable SERVER error.
+*/
+const AGY_ENDPOINT_SKIP_STATUSES = /* @__PURE__ */ new Set([
+	429,
+	403,
+	503
+]);
+/**
+* Try each runtime endpoint in order, skipping unusable ones (429/403/503/network).
 * Returns the first other response (2xx or a real error like 400/401); when
 * every endpoint is unusable, returns the last skipped response so the caller's
-* classifier can still produce a meaningful error.
+* classifier can still produce a meaningful error (a returned 503 becomes a
+* retryable SERVER failure rather than being swallowed here).
 */
 async function fetchAgyFirstOk(urlPath, init, fetchImpl = proxiedFetch) {
 	let lastSkipped = null;
@@ -1081,7 +1093,7 @@ var AgySessionManager = class AgySessionManager {
 				try {
 					const auth = await this.accessTokenFor(account);
 					if (!auth) return null;
-					const { fetchAvailableModels } = await import("./models-BTMqI4Md.mjs").then((n) => n.r);
+					const { fetchAvailableModels } = await import("./models-F-1cWO0f.mjs").then((n) => n.r);
 					const quotas = ingestFamilyQuotas(await fetchAvailableModels(auth.access, account.projectId, (input, init) => {
 						const timeout = AbortSignal.timeout(AgySessionManager.QUOTA_FETCH_TIMEOUT_MS);
 						const signal = init?.signal ? AbortSignal.any([init.signal, timeout]) : timeout;
@@ -1232,7 +1244,7 @@ var AgySessionManager = class AgySessionManager {
 			}
 			const key = this.accountKey(picked.account);
 			if (!picked.account.projectId && !this.projectRetryFailed.has(key)) try {
-				const { loadCodeAssist } = await import("./exchange-DNrUFqeJ.mjs").then((n) => n.n);
+				const { loadCodeAssist } = await import("./exchange-Bdql4kf3.mjs").then((n) => n.n);
 				const { projectId } = await loadCodeAssist(auth.access);
 				if (projectId) {
 					await this.store.mutate((s) => {
@@ -1327,7 +1339,7 @@ var AgySessionManager = class AgySessionManager {
 				ok: false,
 				error: "No agy account configured — run `dsh-agy login` first."
 			};
-			const { toAgyRequestBody } = await import("./translate-CfeRpHDe.mjs").then((n) => n.n);
+			const { toAgyRequestBody } = await import("./translate-CE9tNXiV.mjs").then((n) => n.n);
 			const { fetchAgyFirstOk } = await Promise.resolve().then(() => constants_exports);
 			const { parseAgySse } = await import("./parse-Bs4rPkHA.mjs").then((n) => n.n);
 			const body = toAgyRequestBody({
@@ -1517,34 +1529,86 @@ function resolveDshHome() {
 function homedir() {
 	return process.env.HOME ?? process.env.USERPROFILE ?? ".";
 }
+/** A credentials reference name must be a POSIX-style identifier. */
+const REF_NAME = /^[A-Za-z_][A-Za-z0-9_]*$/;
+/** The document's non-reference sections. */
+const SECTION_KEYS = ["version", "records"];
+/** Every top-level key DSH's credentials provider admits; anything else is rejected. */
+const DOCUMENT_TOP_LEVEL = /* @__PURE__ */ new Set([...SECTION_KEYS, "refs"]);
+/**
+* Describe one YAML parse failure without quoting the source, which holds
+* secrets. The parser's own message embeds the offending line.
+*/
+function describeYamlError(error) {
+	const at = error.linePos?.[0];
+	return `${error.code ?? "parse-error"}${at ? ` at line ${at.line}, column ${at.col}` : ""}`;
+}
+/**
+* Parse the credentials document and locate its `refs` section.
+*
+* The document is owned by DSH's credentials provider, which serializes it with
+* the `yaml` package. Values are folded across physical lines (a long
+* single-quoted scalar folds at whitespace) and `records` payloads nest
+* arbitrary keys, so this MUST be a real parse rather than a line scan: a
+* line-based reader cannot represent folding, and it lets a `records` payload
+* shadow a real top-level reference.
+*
+* Deliberately permissive: it validates only the shape it consumes, so the read
+* path keeps working on a document written by an older build. What may be
+* rewritten is enforced separately, in the writer.
+*/
+function parseCredentialsDocument(text, file, context) {
+	const document = parseDocument(text, {
+		prettyErrors: true,
+		uniqueKeys: true
+	});
+	if (document.errors.length > 0) throw new Error(`${context}: cannot parse ${file}: ` + document.errors.map(describeYamlError).join("; "));
+	const root = document.contents;
+	if (!isMap(root)) throw new Error(`${context}: ${file} must be a mapping`);
+	const refs = root.get("refs");
+	if (refs !== void 0 && refs !== null && !isMap(refs)) throw new Error(`${context}: "refs" in ${file} must be a mapping`);
+	return {
+		document,
+		root,
+		refs: isMap(refs) ? refs : void 0,
+		flat: !root.has("version")
+	};
+}
 /**
-* Minimal reader for the DSH credentials document: a flat YAML mapping of
-* `KEY: "value"` / `KEY: value` lines. Values are unquoted with JSON-style
-* escaping for double-quoted scalars; anything more complex fails loudly.
+* Read the references from the DSH credentials document.
+*
+* Only `refs` holds references, and a `records` payload must never be able to
+* shadow one. Two compatibility cases matter:
+*
+* - A pre-release "flat" document keeps its references at the top level; the
+*   provider still reads that layout, so we do too.
+* - Version 0.2.7 of this plugin appended the master key as a *top-level* key.
+*   The provider rejects such a document, but the key still decrypts an
+*   existing account store, so it is read as a fallback. Dropping it would
+*   silently mint a new master key and strand those accounts.
+*
+* Non-string and empty values are skipped, mirroring the provider.
 */
 function readCredentialsDocument(file) {
-	if (!existsSync(file)) return /* @__PURE__ */ new Map();
 	const entries = /* @__PURE__ */ new Map();
+	if (!existsSync(file)) return entries;
 	const text = readFileSync(file, "utf8");
-	for (const line of text.split(/\r?\n/)) {
-		const trimmed = line.trim();
-		if (!trimmed || trimmed.startsWith("#") || trimmed.startsWith("---")) continue;
-		const match = /^([A-Za-z_][A-Za-z0-9_]*):\s*(.*)$/.exec(trimmed);
-		if (!match) continue;
-		const [, key = "", rawValue = ""] = match;
-		let value;
-		if (rawValue.startsWith("\"")) try {
-			value = JSON.parse(rawValue);
-		} catch {
-			throw new Error(`readCredentialsDocument: invalid quoted value for "${key}" in ${file}`);
-		}
-		else if (rawValue.startsWith("'")) {
-			if (!rawValue.endsWith("'") || rawValue.length < 2) throw new Error(`readCredentialsDocument: unterminated single-quoted value for "${key}" in ${file}`);
-			value = rawValue.slice(1, -1).replace(/''/g, "'");
-		} else value = rawValue;
-		if (value.length === 0) continue;
+	if (text.trim().length === 0) return entries;
+	const { root, refs, flat } = parseCredentialsDocument(text, file, "readCredentialsDocument");
+	const section = flat ? root : refs;
+	if (section) for (const item of section.items) {
+		if (!isScalar(item.key) || !isScalar(item.value)) continue;
+		const key = item.key.value;
+		const value = item.value.value;
+		if (typeof key !== "string" || !REF_NAME.test(key)) continue;
+		if (flat && SECTION_KEYS.includes(key)) continue;
+		if (typeof value !== "string" || value.length === 0) continue;
 		entries.set(key, value);
 	}
+	if (!flat && !entries.has("AGY_MASTER_KEY")) {
+		const legacy = root.get(MASTER_KEY_REF);
+		if (typeof legacy === "string" && legacy.length > 0) entries.set(MASTER_KEY_REF, legacy);
+	}
 	return entries;
 }
 /**
@@ -1568,21 +1632,83 @@ function loadMasterKey(dshHome) {
 	assertOwnerOnly(file);
 	return readCredentialsDocument(file).get(MASTER_KEY_REF);
 }
+/** Top-level keys DSH's credentials provider admits; anything else is rejected. */
+/**
+* Render the version-1 layout for a pre-release "flat" document — a non-empty
+* top-level mapping of reference names to non-empty string scalars, with no
+* `version` key and no document directives. The original lines are nested
+* verbatim under `refs:`, so comments, blank lines, and each value's spelling
+* survive byte for byte. Returns undefined for anything the recognizer
+* declines, which the caller must then refuse to rewrite.
+*
+* Nesting whole lines is safe for block scalars: an explicit indent indicator
+* (`|2`) is absolute and the implied one is detected relative to the key, so
+* shifting every line by the same two spaces preserves the parsed value.
+*/
+function renderFlatLayoutMigration(text) {
+	for (const line of text.split("\n")) if (/^(%|---|\.\.\.)/.test(line)) return void 0;
+	const document = parseDocument(text, {
+		prettyErrors: true,
+		uniqueKeys: true
+	});
+	if (document.errors.length > 0) return void 0;
+	const flat = document.contents;
+	if (!isMap(flat) || flat.items.length === 0) return void 0;
+	for (const pair of flat.items) {
+		if (!isScalar(pair.key) || typeof pair.key.value !== "string") return void 0;
+		if (DOCUMENT_TOP_LEVEL.has(pair.key.value) || !REF_NAME.test(pair.key.value)) return void 0;
+		if (!isScalar(pair.value) || typeof pair.value.value !== "string") return void 0;
+		if (pair.value.value.length === 0) return void 0;
+	}
+	return `version: 1\nrefs:\n${text.split("\n").map((line) => line.length === 0 ? line : `  ${line}`).join("\n")}${text.endsWith("\n") ? "" : "\n"}`;
+}
+/**
+* Render the credentials document with {@link MASTER_KEY_REF} added under `refs`.
+*
+* The key MUST be nested under `refs`: DSH's credentials provider rejects any
+* other top-level key, and a document it rejects makes *every* credential in
+* the file unreadable, not just ours. Editing the parsed document keeps the
+* comments and formatting of every untouched entry; a document this build
+* cannot prove it understands is never rewritten.
+*/
+function renderWithMasterKey(existingText, masterKey, file) {
+	const fresh = () => new Document({
+		version: 1,
+		refs: { [MASTER_KEY_REF]: masterKey }
+	}).toString();
+	if (existingText.trim().length === 0) return fresh();
+	const { document, root, refs, flat } = parseCredentialsDocument(existingText, file, "persistMasterKey");
+	if (flat) {
+		const migrated = renderFlatLayoutMigration(existingText);
+		if (migrated === void 0) throw new Error(`persistMasterKey: ${file} is not a credentials document this build can prove it understands; refusing to rewrite it`);
+		const next = parseDocument(migrated);
+		next.setIn(["refs", MASTER_KEY_REF], masterKey);
+		return next.toString();
+	}
+	for (const key of root.items) {
+		if (!isScalar(key.key) || typeof key.key.value !== "string") continue;
+		if (!DOCUMENT_TOP_LEVEL.has(key.key.value)) throw new Error(`persistMasterKey: ${file} has unknown top-level key "${key.key.value}"; refusing to rewrite it`);
+	}
+	const version = root.get("version");
+	if (version !== 1) throw new Error(`persistMasterKey: ${file} declares version ${JSON.stringify(version)}; refusing to rewrite it`);
+	if (refs) document.setIn(["refs", MASTER_KEY_REF], masterKey);
+	else document.set("refs", { [MASTER_KEY_REF]: masterKey });
+	return document.toString();
+}
 /**
 * Generate and persist a fresh master key (0600) in the DSH credentials document.
 *
-* Append-only + atomic rename: the DSH credentials service owns this file and
-* preserves comments and the formatting of untouched entries (and may hold
-* YAML constructs this minimal reader cannot parse). Rewriting the whole file
-* from our parsed view would silently drop those; appending keeps them.
+* The key is added under `refs` by editing the parsed document, then written
+* with an atomic tmp+rename, so every other credential — and the comments and
+* formatting DSH services rely on — survives. Never rewrite the whole file from
+* a rebuilt view: that would silently drop entries this build does not model.
 */
 function persistMasterKey(dshHome, masterKey) {
 	const file = join(dshHome, ".credentials.yaml");
 	mkdirSync(dirname(file), { recursive: true });
 	const existingText = existsSync(file) ? readFileSync(file, "utf8") : "";
 	if (existingText.length > 0 && readCredentialsDocument(file).has("AGY_MASTER_KEY")) throw new Error(`persistMasterKey: ${MASTER_KEY_REF} already exists in ${file}`);
-	const entry = `${MASTER_KEY_REF}: ${JSON.stringify(masterKey)}`;
-	const next = existingText.length > 0 && !existingText.endsWith("\n") ? `${existingText}\n${entry}\n` : `${existingText}${entry}\n`;
+	const next = renderWithMasterKey(existingText, masterKey, file);
 	const tmp = `${file}.tmp-masterkey`;
 	writeFileSync(tmp, next, { mode: 384 });
 	renameSync(tmp, file);
@@ -1821,4 +1947,4 @@ var JsonAccountStore = class {
 //#endregion
 export { AgyPoolBlockedError as A, OAUTH_TOKEN_URL as C, getAgyBootstrapUserAgent as D, getAgyBootstrapClientMetadata as E, resolveAgyClientCredentials as O, OAUTH_AUTHORIZE_URL as S, fetchAgyFirstOk as T, deriveAntigravitySessionId as _, deriveKey as a, AGY_ENDPOINT_FALLBACKS as b, resolveDshHome as c, isAgyDisabled as d, generateFingerprint as f, resolveAntigravityVersionBounded as g, resolveAntigravityVersion as h, createAesGcmCodec as i, AgyAuthError as k, resolveMasterKeyCodec as l, calculateTokenExpiry as m, maskProxyUrl as n, loadMasterKey as o, recordFingerprintVersion as p, MASTER_KEY_REF as r, persistMasterKey as s, JsonAccountStore as t, AgySessionManager as u, generateAntigravityRequestId as v, OAUTH_USERINFO_URL as w, AGY_SCOPES as x, AGY_DEFAULT_REDIRECT_URI as y };
 
-//# sourceMappingURL=accounts-CjOuS29o.mjs.map
+//# sourceMappingURL=accounts-Um8N9I56.mjs.map