spiracha 1.2.0 → 1.3.2

package/apps/ui/dist/server/assets/antigravity-db-D9gW1D8G.js

@@ -0,0 +1,576 @@
+import { decryptAntigravitySafeStoragePayload } from "./antigravity-keychain-DOiuHDwK.js";
+import { readdir, stat } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+//#region ../../src/lib/antigravity-exporter-types.ts
+var DEFAULT_ANTIGRAVITY_IDE_DIR = path.join(os.homedir(), ".gemini", "antigravity-ide");
+var DEFAULT_ANTIGRAVITY_DIR = path.join(os.homedir(), ".gemini", "antigravity");
+var resolveAntigravityRoots = () => {
+	const configured = process.env.SPIRACHA_ANTIGRAVITY_DIRS?.trim() || process.env.SPIRACHA_ANTIGRAVITY_DIR?.trim();
+	if (configured) return configured.split(path.delimiter).map((entry) => entry.trim()).filter(Boolean);
+	return [DEFAULT_ANTIGRAVITY_IDE_DIR, DEFAULT_ANTIGRAVITY_DIR];
+};
+var getAntigravityConversationDir = (root) => path.join(root, "conversations");
+var getAntigravityBrainDir = (root) => path.join(root, "brain");
+var getAntigravitySummaryIndexPath = (root) => path.join(root, "agyhub_summaries_proto.pb");
+//#endregion
+//#region ../../src/lib/antigravity-db.ts
+var UNKNOWN_WORKSPACE = {
+	workspaceFolder: null,
+	workspaceKey: "unknown",
+	workspaceLabel: "Unknown project",
+	workspaceUri: null
+};
+var decoder = new TextDecoder();
+var pathExists = async (target) => {
+	try {
+		await stat(target);
+		return true;
+	} catch {
+		return false;
+	}
+};
+var isFileMissingError = (error) => {
+	const code = error.code;
+	return code === "ENOENT" || code === "ENOTDIR";
+};
+var readVarint = (buffer, start, end) => {
+	let value = 0;
+	let multiplier = 1;
+	for (let index = start; index < end; index += 1) {
+		const byte = buffer[index];
+		value += (byte & 127) * multiplier;
+		if ((byte & 128) === 0) return {
+			next: index + 1,
+			value
+		};
+		multiplier *= 128;
+	}
+	throw new Error("Unterminated protobuf varint");
+};
+var parseProtoFields = (buffer, start = 0, end = buffer.length) => {
+	const fields = [];
+	let index = start;
+	while (index < end) {
+		const key = readVarint(buffer, index, end);
+		index = key.next;
+		const fieldNumber = key.value >> 3;
+		const wireType = key.value & 7;
+		if (fieldNumber <= 0) throw new Error(`Invalid protobuf field number: ${fieldNumber}`);
+		if (wireType === 0) {
+			const fieldValue = readVarint(buffer, index, end);
+			index = fieldValue.next;
+			fields.push({
+				fieldNumber,
+				value: fieldValue.value,
+				wireType
+			});
+			continue;
+		}
+		if (wireType === 1) {
+			index += 8;
+			fields.push({
+				fieldNumber,
+				wireType
+			});
+			continue;
+		}
+		if (wireType === 2) {
+			const length = readVarint(buffer, index, end);
+			index = length.next;
+			const next = index + length.value;
+			if (next > end) throw new Error("Invalid protobuf length-delimited field");
+			fields.push({
+				bytes: buffer.slice(index, next),
+				fieldNumber,
+				wireType
+			});
+			index = next;
+			continue;
+		}
+		if (wireType === 5) {
+			index += 4;
+			fields.push({
+				fieldNumber,
+				wireType
+			});
+			continue;
+		}
+		throw new Error(`Unsupported protobuf wire type: ${wireType}`);
+	}
+	return fields;
+};
+var firstField = (fields, fieldNumber) => fields.find((field) => field.fieldNumber === fieldNumber) ?? null;
+var fieldString = (fields, fieldNumber) => {
+	const field = firstField(fields, fieldNumber);
+	if (!field?.bytes) return null;
+	return decoder.decode(field.bytes);
+};
+var fieldNumberValue = (fields, fieldNumber) => {
+	return firstField(fields, fieldNumber)?.value ?? null;
+};
+var nestedFields = (field) => {
+	if (!field?.bytes) return [];
+	return parseProtoFields(field.bytes);
+};
+var parseTimestampMs = (field) => {
+	const fields = nestedFields(field);
+	const seconds = fieldNumberValue(fields, 1);
+	if (seconds === null) return null;
+	const nanos = fieldNumberValue(fields, 2) ?? 0;
+	return seconds * 1e3 + Math.floor(nanos / 1e6);
+};
+var cleanTitle = (value, fallback) => {
+	const title = value?.replace(/\s+/g, " ").trim();
+	if (!title) return fallback;
+	return title.length > 180 ? `${title.slice(0, 177)}...` : title;
+};
+var decodeFileUri = (value) => {
+	if (!value.startsWith("file://")) return value;
+	try {
+		return decodeURIComponent(new URL(value).pathname);
+	} catch {
+		return decodeURIComponent(value.slice(7));
+	}
+};
+var normalizeWorkspaceFolder = (value) => {
+	const decoded = decodeFileUri(value.trim());
+	return decoded.replace(/\/+$/u, "") || decoded;
+};
+var workspaceFromFolder = (folderValue) => {
+	if (!folderValue) return null;
+	const folder = normalizeWorkspaceFolder(folderValue);
+	if (!folder) return null;
+	return {
+		workspaceFolder: folder,
+		workspaceKey: `folder:${folder}`,
+		workspaceLabel: path.basename(folder) || folder,
+		workspaceUri: null
+	};
+};
+var workspaceFromUri = (uri) => {
+	if (!uri) return null;
+	const workspace = workspaceFromFolder(uri);
+	if (!workspace) return null;
+	return {
+		...workspace,
+		workspaceUri: uri
+	};
+};
+var parseWorkspaceInfo = (field) => {
+	const fields = nestedFields(field);
+	return workspaceFromUri(fieldString(fields, 1) ?? fieldString(fields, 2));
+};
+var parseContextWorkspaceInfo = (field) => {
+	const fields = nestedFields(field);
+	const directUri = fieldString(fields, 7);
+	if (directUri) return workspaceFromUri(directUri);
+	return parseWorkspaceInfo(firstField(fields, 1));
+};
+var parseSummaryEntry = (entryField, summaryPath) => {
+	try {
+		const entryFields = nestedFields(entryField);
+		const conversationId = fieldString(entryFields, 1);
+		const summaryBytes = firstField(entryFields, 2);
+		if (!conversationId || !summaryBytes) return null;
+		const summaryFields = nestedFields(summaryBytes);
+		return {
+			...parseWorkspaceInfo(firstField(summaryFields, 9)) ?? parseContextWorkspaceInfo(firstField(summaryFields, 17)) ?? UNKNOWN_WORKSPACE,
+			conversationId,
+			createdAtMs: parseTimestampMs(firstField(summaryFields, 7)),
+			indexedItemCount: fieldNumberValue(summaryFields, 2),
+			lastUpdatedAtMs: parseTimestampMs(firstField(summaryFields, 3)),
+			summaryPath,
+			title: cleanTitle(fieldString(summaryFields, 1), conversationId)
+		};
+	} catch {
+		return null;
+	}
+};
+var readAntigravitySummaryIndex = async (summaryPath) => {
+	if (!await pathExists(summaryPath)) return [];
+	try {
+		return parseProtoFields(new Uint8Array(await Bun.file(summaryPath).arrayBuffer())).filter((field) => field.fieldNumber === 1).map((field) => parseSummaryEntry(field, summaryPath)).filter((entry) => entry !== null);
+	} catch {
+		return [];
+	}
+};
+var preferConversationFile = (current, candidate) => {
+	if (!current) return candidate;
+	if (candidate.mtimeMs !== current.mtimeMs) return candidate.mtimeMs > current.mtimeMs ? candidate : current;
+	return candidate.bytes > current.bytes ? candidate : current;
+};
+var readConversationFileCandidate = async (root, conversationDir, entry) => {
+	if (!entry.isFile() || !entry.name.endsWith(".pb")) return null;
+	const conversationId = entry.name.slice(0, -3);
+	const filePath = path.join(conversationDir, entry.name);
+	try {
+		const info = await stat(filePath);
+		return {
+			conversationId,
+			file: {
+				bytes: info.size,
+				mtimeMs: info.mtimeMs,
+				path: filePath,
+				root
+			}
+		};
+	} catch (error) {
+		if (isFileMissingError(error)) return null;
+		throw error;
+	}
+};
+var readConversationFiles = async (roots) => {
+	const files = /* @__PURE__ */ new Map();
+	for (const root of roots) {
+		const conversationDir = getAntigravityConversationDir(root);
+		let entries = [];
+		try {
+			entries = await readdir(conversationDir, { withFileTypes: true });
+		} catch {
+			continue;
+		}
+		for (const entry of entries) {
+			const candidate = await readConversationFileCandidate(root, conversationDir, entry);
+			if (candidate) files.set(candidate.conversationId, preferConversationFile(files.get(candidate.conversationId), candidate.file));
+		}
+	}
+	return files;
+};
+var readArtifactMetadata = async (markdownPath) => {
+	try {
+		const data = await Bun.file(`${markdownPath}.metadata.json`).json();
+		const updatedAt = typeof data.updatedAt === "string" ? Date.parse(data.updatedAt) : NaN;
+		return {
+			artifactType: typeof data.artifactType === "string" ? data.artifactType : null,
+			summary: typeof data.summary === "string" ? data.summary : null,
+			updatedAtMs: Number.isFinite(updatedAt) ? updatedAt : null
+		};
+	} catch {
+		return {
+			artifactType: null,
+			summary: null,
+			updatedAtMs: null
+		};
+	}
+};
+var readArtifactCandidate = async (root, artifactPath, fileName) => {
+	try {
+		const [info, metadata] = await Promise.all([stat(artifactPath), readArtifactMetadata(artifactPath)]);
+		return {
+			artifactType: metadata.artifactType,
+			bytes: info.size,
+			name: fileName,
+			path: artifactPath,
+			sourceRoot: root,
+			summary: metadata.summary,
+			updatedAtMs: metadata.updatedAtMs ?? info.mtimeMs
+		};
+	} catch (error) {
+		if (isFileMissingError(error)) return null;
+		throw error;
+	}
+};
+var readArtifactsForRoot = async (root) => {
+	const brainDir = getAntigravityBrainDir(root);
+	let entries = [];
+	try {
+		entries = await readdir(brainDir, { withFileTypes: true });
+	} catch {
+		return /* @__PURE__ */ new Map();
+	}
+	const artifactsByConversation = /* @__PURE__ */ new Map();
+	for (const entry of entries) {
+		if (!entry.isDirectory()) continue;
+		const artifactDir = path.join(brainDir, entry.name);
+		const files = await readdir(artifactDir, { withFileTypes: true }).catch(() => []);
+		for (const file of files) {
+			if (!file.isFile() || !file.name.endsWith(".md")) continue;
+			const artifact = await readArtifactCandidate(root, path.join(artifactDir, file.name), file.name);
+			if (!artifact) continue;
+			const list = artifactsByConversation.get(entry.name) ?? [];
+			list.push(artifact);
+			artifactsByConversation.set(entry.name, list);
+		}
+	}
+	return artifactsByConversation;
+};
+var mergeArtifactMaps = async (roots) => {
+	const merged = /* @__PURE__ */ new Map();
+	for (const root of roots) {
+		const artifacts = await readArtifactsForRoot(root);
+		for (const [conversationId, list] of artifacts) {
+			const existing = merged.get(conversationId) ?? [];
+			const byName = new Map(existing.map((artifact) => [artifact.name, artifact]));
+			for (const artifact of list) if (!byName.has(artifact.name)) byName.set(artifact.name, artifact);
+			merged.set(conversationId, [...byName.values()].sort((a, b) => (b.updatedAtMs ?? 0) - (a.updatedAtMs ?? 0) || a.name.localeCompare(b.name)));
+		}
+	}
+	return merged;
+};
+var countJsonlEntries = async (filePath) => {
+	try {
+		return (await Bun.file(filePath).text()).split(/\r?\n/u).filter((line) => line.trim().length > 0).length;
+	} catch {
+		return 0;
+	}
+};
+var preferTranscriptFile = (current, candidate) => {
+	if (!current) return candidate;
+	if (candidate.mtimeMs !== current.mtimeMs) return candidate.mtimeMs > current.mtimeMs ? candidate : current;
+	if (candidate.source !== current.source) return candidate.source === "overview" ? candidate : current;
+	return candidate.entryCount > current.entryCount ? candidate : current;
+};
+var readTranscriptFilesForRoot = async (root) => {
+	const brainDir = getAntigravityBrainDir(root);
+	let entries = [];
+	try {
+		entries = await readdir(brainDir, { withFileTypes: true });
+	} catch {
+		return /* @__PURE__ */ new Map();
+	}
+	const transcripts = /* @__PURE__ */ new Map();
+	for (const entry of entries) {
+		if (!entry.isDirectory()) continue;
+		const logsDir = path.join(brainDir, entry.name, ".system_generated", "logs");
+		for (const candidate of [{
+			name: "overview.txt",
+			source: "overview"
+		}, {
+			name: "transcript.jsonl",
+			source: "transcript"
+		}]) {
+			const transcriptPath = path.join(logsDir, candidate.name);
+			try {
+				const info = await stat(transcriptPath);
+				if (!info.isFile()) continue;
+				transcripts.set(entry.name, preferTranscriptFile(transcripts.get(entry.name), {
+					bytes: info.size,
+					entryCount: await countJsonlEntries(transcriptPath),
+					mtimeMs: info.mtimeMs,
+					path: transcriptPath,
+					root,
+					source: candidate.source
+				}));
+			} catch {}
+		}
+	}
+	return transcripts;
+};
+var mergeTranscriptMaps = async (roots) => {
+	const merged = /* @__PURE__ */ new Map();
+	for (const root of roots) {
+		const transcripts = await readTranscriptFilesForRoot(root);
+		for (const [conversationId, transcript] of transcripts) merged.set(conversationId, preferTranscriptFile(merged.get(conversationId), transcript));
+	}
+	return merged;
+};
+var readSummaryEntries = async (roots) => {
+	const summaries = /* @__PURE__ */ new Map();
+	for (const root of roots) for (const entry of await readAntigravitySummaryIndex(getAntigravitySummaryIndexPath(root))) {
+		const existing = summaries.get(entry.conversationId);
+		if (!existing || (entry.lastUpdatedAtMs ?? 0) > (existing.lastUpdatedAtMs ?? 0)) summaries.set(entry.conversationId, entry);
+	}
+	return summaries;
+};
+var maxArtifactUpdatedAt = (artifacts) => {
+	const value = Math.max(0, ...artifacts.map((artifact) => artifact.updatedAtMs ?? 0));
+	return value > 0 ? value : null;
+};
+var resolveConversationSourceRoot = (file, transcript, artifacts) => {
+	return file?.root ?? transcript?.root ?? artifacts[0]?.sourceRoot ?? null;
+};
+var resolveConversationWorkspace = (summary, file, transcript, artifacts) => {
+	return summary ?? workspaceFromFolder(resolveConversationSourceRoot(file, transcript, artifacts)) ?? UNKNOWN_WORKSPACE;
+};
+var resolveConversationTranscriptSource = (file, transcript) => {
+	return transcript?.source ?? (file?.path ? "safe-storage" : null);
+};
+var resolveConversationLastUpdatedAt = (artifacts, file, summary, transcript) => {
+	return summary?.lastUpdatedAtMs ?? transcript?.mtimeMs ?? file?.mtimeMs ?? maxArtifactUpdatedAt(artifacts);
+};
+var toConversation = (conversationId, summary, file, artifacts, transcript) => {
+	const fallbackTitle = artifacts[0]?.summary ?? conversationId;
+	const artifactBytes = artifacts.reduce((total, artifact) => total + artifact.bytes, 0);
+	const workspace = resolveConversationWorkspace(summary, file, transcript, artifacts);
+	const lastUpdatedAtMs = resolveConversationLastUpdatedAt(artifacts, file, summary, transcript);
+	const sourceRoot = resolveConversationSourceRoot(file, transcript, artifacts);
+	return {
+		artifactBytes,
+		artifactCount: artifacts.length,
+		artifacts,
+		conversationBytes: file?.bytes ?? 0,
+		conversationId,
+		conversationMtimeMs: file?.mtimeMs ?? null,
+		conversationPath: file?.path ?? null,
+		createdAtMs: summary?.createdAtMs ?? null,
+		indexedItemCount: summary?.indexedItemCount ?? null,
+		lastUpdatedAtMs,
+		sourceRoot,
+		summaryPath: summary?.summaryPath ?? null,
+		title: summary?.title ?? cleanTitle(fallbackTitle, conversationId),
+		transcriptBytes: transcript?.bytes ?? 0,
+		transcriptEntryCount: transcript?.entryCount ?? 0,
+		transcriptPath: transcript?.path ?? null,
+		transcriptSource: resolveConversationTranscriptSource(file, transcript),
+		workspaceFolder: workspace.workspaceFolder,
+		workspaceKey: workspace.workspaceKey,
+		workspaceLabel: workspace.workspaceLabel,
+		workspaceUri: workspace.workspaceUri
+	};
+};
+var listAntigravityConversations = async (roots = resolveAntigravityRoots()) => {
+	const [summaries, conversationFiles, artifacts, transcripts] = await Promise.all([
+		readSummaryEntries(roots),
+		readConversationFiles(roots),
+		mergeArtifactMaps(roots),
+		mergeTranscriptMaps(roots)
+	]);
+	return [...new Set([
+		...summaries.keys(),
+		...conversationFiles.keys(),
+		...artifacts.keys(),
+		...transcripts.keys()
+	])].map((conversationId) => toConversation(conversationId, summaries.get(conversationId), conversationFiles.get(conversationId), artifacts.get(conversationId) ?? [], transcripts.get(conversationId))).sort((a, b) => (b.lastUpdatedAtMs ?? 0) - (a.lastUpdatedAtMs ?? 0) || a.title.localeCompare(b.title));
+};
+var groupAntigravityConversations = (conversations) => {
+	const groups = /* @__PURE__ */ new Map();
+	for (const conversation of conversations) {
+		const current = groups.get(conversation.workspaceKey) ?? {
+			artifactCount: 0,
+			conversationBytes: 0,
+			conversationCount: 0,
+			key: conversation.workspaceKey,
+			label: conversation.workspaceLabel,
+			lastActiveMs: 0,
+			transcriptCount: 0,
+			uri: conversation.workspaceUri
+		};
+		current.artifactCount += conversation.artifactCount;
+		current.conversationBytes += conversation.conversationBytes;
+		current.conversationCount += 1;
+		current.lastActiveMs = Math.max(current.lastActiveMs, conversation.lastUpdatedAtMs ?? 0);
+		current.transcriptCount += conversation.transcriptEntryCount > 0 ? 1 : 0;
+		groups.set(conversation.workspaceKey, current);
+	}
+	return [...groups.values()].sort((a, b) => b.lastActiveMs - a.lastActiveMs || a.label.localeCompare(b.label));
+};
+var listAntigravityWorkspaceGroups = async (roots = resolveAntigravityRoots()) => {
+	return groupAntigravityConversations(await listAntigravityConversations(roots));
+};
+var listAntigravityConversationsForGroup = async (workspaceKey, roots = resolveAntigravityRoots()) => {
+	return (await listAntigravityConversations(roots)).filter((conversation) => conversation.workspaceKey === workspaceKey);
+};
+var renderAntigravityArtifactsMarkdown = async (conversation) => {
+	if (conversation.artifacts.length === 0) return null;
+	const parts = [
+		`# ${conversation.title}`,
+		"",
+		"- exported_from: `antigravity_brain_artifacts`",
+		`- conversation_id: \`${conversation.conversationId}\``,
+		conversation.workspaceUri ? `- workspace: \`${conversation.workspaceUri}\`` : "",
+		""
+	].filter(Boolean);
+	for (const artifact of conversation.artifacts) {
+		const body = await Bun.file(artifact.path).text();
+		parts.push(`## ${artifact.name}`, "");
+		if (artifact.summary) parts.push(`_${artifact.summary}_`, "");
+		parts.push(body.trimEnd(), "");
+	}
+	return `${parts.join("\n").trimEnd()}\n`;
+};
+var parseLogEntries = (content) => {
+	return content.split(/\r?\n/u).map((line) => line.trim()).filter(Boolean).map((line) => {
+		try {
+			return JSON.parse(line);
+		} catch {
+			return null;
+		}
+	}).filter((entry) => entry !== null);
+};
+var getString = (value) => typeof value === "string" ? value : null;
+var stripTaggedBlock = (content, tag) => {
+	return content.replace(new RegExp(`<${tag}>[\\s\\S]*?<\\/${tag}>`, "gu"), "").trim();
+};
+var extractTaggedBlock = (content, tag) => {
+	return new RegExp(`<${tag}>\\s*([\\s\\S]*?)\\s*<\\/${tag}>`, "u").exec(content)?.[1]?.trim() || null;
+};
+var cleanLogContent = (entry) => {
+	const content = getString(entry.content);
+	if (!content) return "";
+	const userRequest = extractTaggedBlock(content, "USER_REQUEST");
+	if (userRequest) return userRequest;
+	return ["ADDITIONAL_METADATA", "USER_SETTINGS_CHANGE"].reduce((current, tag) => stripTaggedBlock(current, tag), content).replace(/<\/?USER_REQUEST>/gu, "").trim();
+};
+var logEntryHeading = (entry) => {
+	const source = getString(entry.source);
+	const type = getString(entry.type);
+	if (source?.startsWith("USER")) return "User";
+	if (source === "MODEL") return "Assistant";
+	if (source === "SYSTEM") return "System";
+	return type ? `Tool: ${type}` : "Event";
+};
+var renderToolCalls = (toolCalls) => {
+	if (!Array.isArray(toolCalls) || toolCalls.length === 0) return [];
+	const parts = ["### Tool Calls", ""];
+	for (const call of toolCalls) {
+		if (!call || typeof call !== "object") continue;
+		const { args, name } = call;
+		parts.push(`- \`${typeof name === "string" ? name : "unknown"}\``);
+		if (args !== void 0) parts.push("", "```json", JSON.stringify(args, null, 2), "```", "");
+	}
+	return parts;
+};
+var renderLogEntry = (entry) => {
+	const heading = logEntryHeading(entry);
+	const timestamp = getString(entry.created_at);
+	const content = cleanLogContent(entry);
+	const thinking = getString(entry.thinking);
+	const parts = [`## ${heading}`, ""];
+	if (timestamp) parts.push(`_Timestamp: ${timestamp}_`, "");
+	if (thinking) parts.push("### Thinking", "", thinking.trim(), "");
+	if (content) parts.push(content, "");
+	parts.push(...renderToolCalls(entry.tool_calls));
+	return parts;
+};
+var renderAntigravityTranscriptMarkdown = async (conversation) => {
+	if (!conversation.transcriptPath || !conversation.transcriptSource) return null;
+	const entries = parseLogEntries(await Bun.file(conversation.transcriptPath).text());
+	if (entries.length === 0) return null;
+	const exportedFrom = conversation.transcriptSource === "overview" ? "antigravity_overview_transcript" : "antigravity_jsonl_transcript";
+	const parts = [
+		`# ${conversation.title}`,
+		"",
+		`- exported_from: \`${exportedFrom}\``,
+		`- conversation_id: \`${conversation.conversationId}\``,
+		conversation.workspaceUri ? `- workspace: \`${conversation.workspaceUri}\`` : "",
+		""
+	].filter(Boolean);
+	for (const entry of entries) parts.push(...renderLogEntry(entry));
+	return `${parts.join("\n").trimEnd()}\n`;
+};
+var renderDecryptedSafeStorageMarkdown = (conversation, content) => {
+	const trimmed = content.trim();
+	if (!trimmed) return null;
+	return [
+		`# ${conversation.title}`,
+		"",
+		"- exported_from: `antigravity_safe_storage_payload`",
+		`- conversation_id: \`${conversation.conversationId}\``,
+		conversation.workspaceUri ? `- workspace: \`${conversation.workspaceUri}\`` : "",
+		"",
+		trimmed,
+		""
+	].filter(Boolean).join("\n");
+};
+var renderAntigravityConversationMarkdown = async (conversation, options = {}) => {
+	const transcript = await renderAntigravityTranscriptMarkdown(conversation);
+	if (transcript) return transcript;
+	if (options.keychainSecret && conversation.conversationPath) {
+		const decrypted = decryptAntigravitySafeStoragePayload(Buffer.from(await Bun.file(conversation.conversationPath).arrayBuffer()), options.keychainSecret);
+		if (decrypted) return renderDecryptedSafeStorageMarkdown(conversation, decrypted);
+	}
+	return null;
+};
+//#endregion
+export { listAntigravityConversations, listAntigravityConversationsForGroup, listAntigravityWorkspaceGroups, renderAntigravityArtifactsMarkdown, renderAntigravityConversationMarkdown };

package/apps/ui/dist/server/assets/antigravity-keychain-DOiuHDwK.js

@@ -0,0 +1,126 @@
+import { createDecipheriv, pbkdf2Sync } from "node:crypto";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+//#region ../../src/lib/antigravity-keychain.ts
+var ANTIGRAVITY_KEYCHAIN_SERVICE = "Antigravity Safe Storage";
+var ANTIGRAVITY_KEYCHAIN_ACCOUNT = "Antigravity Key";
+var execFileAsync = promisify(execFile);
+var SAFE_STORAGE_SALT = "saltysalt";
+var SAFE_STORAGE_ITERATIONS = 1003;
+var SAFE_STORAGE_KEY_LENGTH = 16;
+var SAFE_STORAGE_IV = Buffer.alloc(16, 32);
+var cachedKeychainSecret = null;
+var lastKeychainError = null;
+var deriveAntigravitySafeStorageKey = (keychainSecret) => {
+	return pbkdf2Sync(keychainSecret, SAFE_STORAGE_SALT, SAFE_STORAGE_ITERATIONS, SAFE_STORAGE_KEY_LENGTH, "sha1");
+};
+var parseBufferJson = (value) => {
+	if (!value || typeof value !== "object") return null;
+	const data = value.data;
+	if (!Array.isArray(data) || data.some((entry) => typeof entry !== "number")) return null;
+	return Buffer.from(data);
+};
+var normalizeEncryptedPayload = (payload) => {
+	if (payload instanceof Buffer) return payload;
+	if (payload instanceof Uint8Array) return Buffer.from(payload);
+	const trimmed = payload.trim();
+	if (trimmed.startsWith("{")) try {
+		return parseBufferJson(JSON.parse(trimmed));
+	} catch {
+		return null;
+	}
+	return Buffer.from(payload, "binary");
+};
+var hasSafeStoragePrefix = (payload) => {
+	const prefix = payload.subarray(0, 3).toString("ascii");
+	return prefix === "v10" || prefix === "v11";
+};
+var isReadableUtf8 = (value) => {
+	if (value.includes("�")) return false;
+	const printable = [...value].filter((char) => {
+		const code = char.charCodeAt(0);
+		return code === 9 || code === 10 || code === 13 || code >= 32;
+	}).length;
+	return value.length === 0 || printable / value.length > .95;
+};
+var decryptWithKey = (encrypted, key) => {
+	const ciphertext = hasSafeStoragePrefix(encrypted) ? encrypted.subarray(3) : encrypted;
+	if (ciphertext.length === 0 || ciphertext.length % 16 !== 0) return null;
+	try {
+		const decipher = createDecipheriv("aes-128-cbc", key, SAFE_STORAGE_IV);
+		const decrypted = Buffer.concat([decipher.update(ciphertext), decipher.final()]).toString("utf8");
+		return isReadableUtf8(decrypted) ? decrypted : null;
+	} catch {
+		return null;
+	}
+};
+var decryptAntigravitySafeStoragePayload = (payload, keychainSecret) => {
+	const encrypted = normalizeEncryptedPayload(payload);
+	if (!encrypted) return null;
+	const keyAttempts = [deriveAntigravitySafeStorageKey(keychainSecret)];
+	if (/^[A-Za-z0-9+/]+={0,2}$/u.test(keychainSecret)) keyAttempts.push(deriveAntigravitySafeStorageKey(Buffer.from(keychainSecret, "base64")));
+	for (const key of keyAttempts) {
+		const decrypted = decryptWithKey(encrypted, key);
+		if (decrypted !== null) return decrypted;
+	}
+	return null;
+};
+var getAntigravityDecryptionState = ({ cachedSecret = cachedKeychainSecret, lastError = lastKeychainError, platform = process.platform } = {}) => {
+	if (platform !== "darwin") return {
+		canRequestAccess: false,
+		error: null,
+		isUnlocked: false,
+		keychainAccount: ANTIGRAVITY_KEYCHAIN_ACCOUNT,
+		keychainService: ANTIGRAVITY_KEYCHAIN_SERVICE,
+		platform,
+		provider: "unsupported",
+		status: "unsupported"
+	};
+	if (cachedSecret) return {
+		canRequestAccess: true,
+		error: null,
+		isUnlocked: true,
+		keychainAccount: ANTIGRAVITY_KEYCHAIN_ACCOUNT,
+		keychainService: ANTIGRAVITY_KEYCHAIN_SERVICE,
+		platform,
+		provider: "keychain",
+		status: "unlocked"
+	};
+	return {
+		canRequestAccess: true,
+		error: lastError,
+		isUnlocked: false,
+		keychainAccount: ANTIGRAVITY_KEYCHAIN_ACCOUNT,
+		keychainService: ANTIGRAVITY_KEYCHAIN_SERVICE,
+		platform,
+		provider: "keychain",
+		status: lastError ? "error" : "locked"
+	};
+};
+var getCachedAntigravityKeychainSecret = () => cachedKeychainSecret;
+var readAntigravityKeychainSecret = async () => {
+	if (process.platform !== "darwin") throw new Error("Antigravity Keychain access is only available on macOS.");
+	const { stdout } = await execFileAsync("security", [
+		"find-generic-password",
+		"-s",
+		ANTIGRAVITY_KEYCHAIN_SERVICE,
+		"-a",
+		ANTIGRAVITY_KEYCHAIN_ACCOUNT,
+		"-w"
+	]);
+	const secret = stdout.trim();
+	if (!secret) throw new Error(`No secret was returned for ${ANTIGRAVITY_KEYCHAIN_SERVICE}.`);
+	return secret;
+};
+var unlockAntigravityDecryption = async () => {
+	try {
+		cachedKeychainSecret = await readAntigravityKeychainSecret();
+		lastKeychainError = null;
+	} catch (error) {
+		cachedKeychainSecret = null;
+		lastKeychainError = error instanceof Error ? error.message : String(error);
+	}
+	return getAntigravityDecryptionState();
+};
+//#endregion
+export { decryptAntigravitySafeStoragePayload, getAntigravityDecryptionState, getCachedAntigravityKeychainSecret, unlockAntigravityDecryption };