@overdeck/desktop 0.45.13 → 0.45.15

package/server/writer-fe1-8iGc.js

@@ -0,0 +1,251 @@
+import { n as __esmMin } from "./rolldown-runtime-DNCzzKnI.js";
+import { a as withBdProcessLock, n as init_bd_process_lock } from "./bd-process-lock-D3S4T4o-.js";
+import { n as init_export, t as exportBeadsJsonl } from "./export-Dx_qJ3h8.js";
+import { join } from "node:path";
+import { readFile, readdir, stat } from "node:fs/promises";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+//#region ../../lib/beads/telemetry.ts
+function updateBeadsTelemetry(projectKey, patch) {
+	health.set(projectKey, {
+		...health.get(projectKey) ?? empty(),
+		...patch
+	});
+}
+function recordBeadsPull(projectKey, localHead, remoteHead, at = /* @__PURE__ */ new Date()) {
+	updateBeadsTelemetry(projectKey, {
+		localHead,
+		lastPulledRemoteHead: remoteHead,
+		lastSuccessfulPullAt: at.toISOString(),
+		lastSyncError: null
+	});
+}
+function recordBeadsPush(projectKey, localHead, at = /* @__PURE__ */ new Date()) {
+	updateBeadsTelemetry(projectKey, {
+		localHead,
+		lastSuccessfulPushAt: at.toISOString(),
+		lastConflict: null
+	});
+}
+function recordBeadsSyncError(projectKey, message) {
+	updateBeadsTelemetry(projectKey, { lastSyncError: message });
+}
+function recordBeadsConflict(projectKey, message) {
+	updateBeadsTelemetry(projectKey, { lastConflict: message });
+}
+function parseSchemaVersion(value) {
+	if (!value || typeof value !== "object") return null;
+	const record = value;
+	const raw = record.schema_version ?? record.schemaVersion ?? record.database?.schema_version;
+	const parsed = typeof raw === "number" ? raw : Number(raw);
+	return Number.isFinite(parsed) ? parsed : null;
+}
+async function getBeadsHealth(projectKey, cwd, execute = async (args, directory) => {
+	const { stdout } = await execFileAsync$1("bd", [...args], {
+		cwd: directory,
+		encoding: "utf8",
+		timeout: 1e4
+	});
+	return stdout;
+}) {
+	const state = health.get(projectKey) ?? empty();
+	let schemaVersion = null;
+	try {
+		schemaVersion = parseSchemaVersion(JSON.parse(await execute(["context", "--json"], cwd)));
+	} catch {}
+	return {
+		...state,
+		freshnessAgeMs: state.lastSuccessfulPullAt ? Math.max(0, Date.now() - Date.parse(state.lastSuccessfulPullAt)) : null,
+		schemaVersion,
+		designatedMigrator: process.env.BD_ALLOW_REMOTE_MIGRATE === "1"
+	};
+}
+var execFileAsync$1, health, empty;
+var init_telemetry = __esmMin((() => {
+	execFileAsync$1 = promisify(execFile);
+	health = /* @__PURE__ */ new Map();
+	empty = () => ({
+		localHead: null,
+		lastPulledRemoteHead: null,
+		lastSuccessfulPullAt: null,
+		lastSuccessfulPushAt: null,
+		lastConflict: null,
+		lastSyncError: null
+	});
+}));
+//#endregion
+//#region ../../lib/beads/writer.ts
+function errorText(error) {
+	if (!error || typeof error !== "object") return String(error);
+	const record = error;
+	return [
+		record.stderr,
+		record.message,
+		record.stdout
+	].filter((value) => typeof value === "string").join("\n");
+}
+function errorDiagnosticText(error) {
+	if (!error || typeof error !== "object") return String(error);
+	const record = error;
+	return [record.stderr, record.message].filter((value) => typeof value === "string").join("\n");
+}
+function formatMutationBatchFailure(result) {
+	if (!("cause" in result)) return result.message;
+	const cause = errorText(result.cause).trim();
+	return cause ? `${result.message}\nCause: ${cause}` : result.message;
+}
+function isConflict(error) {
+	return /conflict|non-fast-forward|rejected|diverge/i.test(errorDiagnosticText(error));
+}
+function parseHead(status) {
+	return /^\s*Commit:\s*([0-9a-v]{7,40})\s*$/im.exec(status)?.[1] ?? null;
+}
+async function defaultExecute(args, cwd) {
+	const { stdout } = await execFileAsync("bd", [...args], {
+		cwd,
+		encoding: "utf8",
+		timeout: 12e4,
+		maxBuffer: BD_EXEC_MAX_BUFFER
+	});
+	return stdout;
+}
+async function defaultExportSnapshot(client, cwd) {
+	await exportBeadsJsonl(cwd, { execute: (args) => client.run(args) });
+}
+async function readHead(client) {
+	try {
+		return parseHead(await client.run(["vc", "status"]));
+	} catch {
+		return null;
+	}
+}
+async function readRemoteHead(client) {
+	try {
+		const output = await client.run([
+			"dolt",
+			"remote",
+			"show",
+			"origin",
+			"--json"
+		]);
+		const parsed = JSON.parse(output);
+		const head = parsed.head ?? parsed.commit ?? parsed.remote_head;
+		return typeof head === "string" ? head : null;
+	} catch {
+		return null;
+	}
+}
+async function hasExistingEmbeddedDoltStore(cwd) {
+	try {
+		const storePath = join(await resolveBeadsDir(cwd), "embeddeddolt");
+		if (!(await stat(storePath)).isDirectory()) return false;
+		return (await readdir(storePath)).length > 0;
+	} catch {
+		return false;
+	}
+}
+async function resolveBeadsDir(cwd) {
+	const localBeadsDir = join(cwd, ".beads");
+	try {
+		return (await readFile(join(localBeadsDir, "redirect"), "utf8")).trim() || localBeadsDir;
+	} catch {
+		return localBeadsDir;
+	}
+}
+/**
+* The only canonical beads mutation transaction boundary.
+*
+* A batch owns one project lock and one bootstrap/pull/commit/export/push
+* cycle. A failed callback is deliberately left unpushed for operator
+* recovery because bd does not expose a universally safe embedded-mode
+* rollback primitive.
+*/
+async function runMutationBatch(context, mutate, dependencies = {}) {
+	const execute = dependencies.execute ?? defaultExecute;
+	const exportSnapshot = dependencies.exportSnapshot ?? defaultExportSnapshot;
+	const withLock = dependencies.withLock ?? withBdProcessLock;
+	const cwd = context.project.workspacePath;
+	const telemetryKey = context.project.projectKey ?? cwd;
+	const client = {
+		run: (args) => execute(args, cwd),
+		mutate: (args) => execute([
+			...args,
+			"--dolt-auto-commit",
+			"batch"
+		], cwd)
+	};
+	return withLock(`beads mutation: ${context.reason}`, async () => {
+		let value;
+		try {
+			if (!await hasExistingEmbeddedDoltStore(cwd)) await client.run([
+				"bootstrap",
+				"--yes",
+				"--json"
+			]);
+			await client.run(["dolt", "pull"]);
+			recordBeadsPull(telemetryKey, await readHead(client), await readRemoteHead(client));
+			value = await mutate(client);
+			await client.run([
+				"dolt",
+				"commit",
+				"-m",
+				context.reason
+			]);
+			await exportSnapshot(client, cwd);
+		} catch (error) {
+			const localHead = await readHead(client);
+			if (isConflict(error)) {
+				recordBeadsConflict(telemetryKey, errorText(error));
+				return {
+					ok: false,
+					conflict: true,
+					localHead,
+					remoteHead: await readRemoteHead(client),
+					message: "The Dolt histories conflict. Nothing was pushed; pull and reconcile the working set before retrying."
+				};
+			}
+			recordBeadsSyncError(telemetryKey, errorText(error));
+			return {
+				ok: false,
+				needsOperatorRecovery: true,
+				localHead,
+				message: "The mutation batch failed before push. The local working set was preserved for operator recovery and no partial plan was published.",
+				cause: error
+			};
+		}
+		try {
+			await client.run(["dolt", "push"]);
+			const localHead = await readHead(client);
+			recordBeadsPush(telemetryKey, localHead);
+			return {
+				ok: true,
+				value,
+				localHead
+			};
+		} catch (error) {
+			recordBeadsConflict(telemetryKey, errorText(error));
+			return {
+				ok: false,
+				conflict: true,
+				localHead: await readHead(client),
+				remoteHead: await readRemoteHead(client),
+				message: "The Dolt push was rejected. The batch is not durably complete; no force push was attempted."
+			};
+		}
+	}, {
+		...context.lockOptions,
+		workspacePath: cwd
+	});
+}
+var execFileAsync, BD_EXEC_MAX_BUFFER;
+var init_writer = __esmMin((() => {
+	init_bd_process_lock();
+	init_export();
+	init_telemetry();
+	execFileAsync = promisify(execFile);
+	BD_EXEC_MAX_BUFFER = 64 * 1024 * 1024;
+}));
+//#endregion
+export { init_telemetry as a, getBeadsHealth as i, init_writer as n, recordBeadsPull as o, runMutationBatch as r, recordBeadsSyncError as s, formatMutationBatchFailure as t };
+
+//# sourceMappingURL=writer-fe1-8iGc.js.map

package/sync-sources/hooks/record-cost-event.js

@@ -27481,8 +27481,9 @@ function getProviderForModelSync(modelId) {
 const ALLOWED = { allowed: true };
 const OHMYPI_ANTHROPIC_SUBSCRIPTION_BLOCK = {
 	allowed: false,
-	reason: "ohmypi cannot run Anthropic models when authenticated via Claude Code subscription. Switch the Anthropic provider to API-key auth, or pick a non-Anthropic model for ohmypi."
+	reason: "Claude Code subscription Terms of Service restrict Anthropic models to the Claude Code harness — ohmypi cannot run Anthropic models under subscription auth. To proceed, switch the Anthropic provider to API-key auth, or pick a non-Anthropic model for ohmypi."
 };
+OHMYPI_ANTHROPIC_SUBSCRIPTION_BLOCK.reason;
 const SUBSCRIPTION_ONLY_MODEL_BLOCK = {
 	allowed: false,
 	reason: "This OpenAI model needs a ChatGPT/Codex subscription sign-in — it is not served by the plain OpenAI API key. Run `codex login` on the host (workspace containers inherit the host sign-in), or pick a different model."