pockcode 0.0.1

package/dist/assets/auth.server-B_P8Jm6O.js

@@ -0,0 +1,87 @@
+import { r as resolvePockcodeAuthPath, t as ensureParentDirectory } from "./runtime-paths.server-D6rRjGVb.js";
+import { readFile, rename, writeFile } from "node:fs/promises";
+import { randomBytes, scrypt, timingSafeEqual } from "node:crypto";
+import { promisify } from "node:util";
+//#region app/server/auth.server.ts
+var scrypt$1 = promisify(scrypt);
+var passwordKeyLength = 64;
+var passwordMinLength = 8;
+var scryptOptions = {
+	N: 16384,
+	maxmem: 64 * 1024 * 1024,
+	p: 1,
+	r: 8
+};
+var authConfigCache;
+async function hasConfiguredPassword() {
+	return Boolean(await readAuthConfig());
+}
+async function setupPassword(password) {
+	const normalized = password.trim();
+	if (normalized.length < passwordMinLength) throw new Error(`Password must be at least ${passwordMinLength} characters.`);
+	if (await readAuthConfig()) throw new Error("Pockcode password is already configured.");
+	const salt = randomBytes(16);
+	const key = await scrypt$1(normalized, salt, passwordKeyLength, scryptOptions);
+	const config = {
+		version: 1,
+		password: {
+			algorithm: "scrypt",
+			createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+			key: key.toString("base64"),
+			keyLength: passwordKeyLength,
+			salt: salt.toString("base64"),
+			scrypt: scryptOptions
+		}
+	};
+	const authPath = resolvePockcodeAuthPath();
+	ensureParentDirectory(authPath);
+	const tmpPath = `${authPath}.${process.pid}.${Date.now()}.tmp`;
+	await writeFile(tmpPath, `${JSON.stringify(config, null, 2)}\n`, { mode: 384 });
+	await rename(tmpPath, authPath);
+	authConfigCache = config;
+}
+async function verifyBasicAuthorization(header) {
+	const value = Array.isArray(header) ? header[0] : header;
+	if (!value?.startsWith("Basic ")) return false;
+	let decoded = "";
+	try {
+		decoded = Buffer.from(value.slice(6), "base64").toString("utf8");
+	} catch {
+		return false;
+	}
+	const separatorIndex = decoded.indexOf(":");
+	if (separatorIndex < 0) return false;
+	return verifyPassword(decoded.slice(separatorIndex + 1));
+}
+function pockcodeAuthRealm() {
+	return "pockcode";
+}
+async function isRequestAuthorized(req) {
+	return verifyBasicAuthorization(req.headers.authorization);
+}
+async function verifyPassword(password) {
+	const config = await readAuthConfig();
+	if (!config) return false;
+	const expectedKey = Buffer.from(config.password.key, "base64");
+	const key = await scrypt$1(password, Buffer.from(config.password.salt, "base64"), config.password.keyLength, config.password.scrypt);
+	return key.length === expectedKey.length && timingSafeEqual(key, expectedKey);
+}
+async function readAuthConfig() {
+	if (authConfigCache !== void 0) return authConfigCache;
+	const authPath = resolvePockcodeAuthPath();
+	try {
+		authConfigCache = readConfig(JSON.parse(await readFile(authPath, "utf8")));
+	} catch {
+		authConfigCache = null;
+	}
+	return authConfigCache;
+}
+function readConfig(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+	const record = value;
+	const password = record.password;
+	if (record.version !== 1 || !password || password.algorithm !== "scrypt" || typeof password.key !== "string" || typeof password.salt !== "string" || typeof password.keyLength !== "number" || !password.scrypt || typeof password.scrypt.N !== "number" || typeof password.scrypt.r !== "number" || typeof password.scrypt.p !== "number") return null;
+	return record;
+}
+//#endregion
+export { hasConfiguredPassword, isRequestAuthorized, pockcodeAuthRealm, setupPassword, verifyBasicAuthorization };

package/dist/assets/chat-status-monitor.server-D2VG_D8P.js

@@ -0,0 +1,136 @@
+import { i as publishProviderEvent, r as onWorkspaceWatchChange, t as listWatchedWorkspacePaths } from "./socket.server-7dC-9Fnw.js";
+import { H as ensureDatabase, M as readCodexHistoryWatchPaths, U as prisma, d as publishMessageDeltas, l as listChats, p as refreshChatStatusesForWorkspaces, y as syncProviderChatsOnce } from "./chats.service-H6m23Fna.js";
+import { watch } from "node:fs";
+import { stat } from "node:fs/promises";
+//#region app/server/chat-status-monitor.server.ts
+var debounceMs = 250;
+var initialized = false;
+var started = false;
+var syncing = false;
+var syncAgain = false;
+var syncTimer = null;
+var snapshots = /* @__PURE__ */ new Map();
+var pendingAllMessages = false;
+var pendingExternalThreadIds = /* @__PURE__ */ new Set();
+var watchers = /* @__PURE__ */ new Map();
+function startChatStatusMonitor() {
+	if (started) {
+		scheduleProviderSync();
+		return;
+	}
+	started = true;
+	onWorkspaceWatchChange(() => scheduleProviderSync());
+	refreshCodexWatchers().then(() => syncProviderState({ publishExisting: false }));
+}
+function scheduleProviderSync(change) {
+	if (change) {
+		const threadId = readCodexThreadId(change.filename);
+		if (threadId) pendingExternalThreadIds.add(threadId);
+		else pendingAllMessages = true;
+	}
+	if (syncTimer) clearTimeout(syncTimer);
+	syncTimer = setTimeout(() => {
+		syncTimer = null;
+		syncProviderState({ publishExisting: true });
+	}, debounceMs);
+}
+async function syncProviderState({ publishExisting }) {
+	if (syncing) {
+		syncAgain = true;
+		return;
+	}
+	syncing = true;
+	let targetAllMessages = false;
+	let targetExternalThreadIds = /* @__PURE__ */ new Set();
+	try {
+		await refreshCodexWatchers();
+		targetAllMessages = pendingAllMessages;
+		targetExternalThreadIds = pendingExternalThreadIds;
+		pendingAllMessages = false;
+		pendingExternalThreadIds = /* @__PURE__ */ new Set();
+		await syncProviderChatsOnce();
+		let chats = await listChats();
+		const statusUpdates = await refreshChatStatusesForWorkspaces(listWatchedWorkspacePaths());
+		if (statusUpdates.length) {
+			const statusUpdateById = new Map(statusUpdates.map((chat) => [chat.id, chat]));
+			chats = chats.map((chat) => statusUpdateById.get(chat.id) ?? chat);
+		}
+		const nextSnapshots = /* @__PURE__ */ new Map();
+		for (const chat of chats) {
+			const snapshot = {
+				lastActivityAt: chat.lastActivityAt,
+				status: chat.status
+			};
+			const previous = snapshots.get(chat.id);
+			nextSnapshots.set(chat.id, snapshot);
+			const changed = !previous || previous.status !== snapshot.status || previous.lastActivityAt !== snapshot.lastActivityAt;
+			const targeted = chat.externalThreadId ? targetExternalThreadIds.has(chat.externalThreadId) : false;
+			if (changed) publishProviderEvent({
+				threadId: chat.id,
+				type: "chat.updated",
+				payload: chat
+			});
+			if (initialized && (publishExisting || previous) && (changed || targeted || targetAllMessages || snapshot.status === "RUNNING")) await publishMessageDeltas(chat.id);
+		}
+		snapshots = nextSnapshots;
+		initialized = true;
+	} catch {
+		pendingAllMessages = pendingAllMessages || targetAllMessages;
+		for (const threadId of targetExternalThreadIds) pendingExternalThreadIds.add(threadId);
+	} finally {
+		syncing = false;
+		if (syncAgain) {
+			syncAgain = false;
+			scheduleProviderSync();
+		}
+	}
+}
+async function refreshCodexWatchers() {
+	await ensureDatabase();
+	const accounts = await prisma.providerAccount.findMany({
+		orderBy: { createdAt: "asc" },
+		where: {
+			providerId: "codex",
+			status: "CONNECTED"
+		}
+	});
+	const paths = new Set(readCodexHistoryWatchPaths());
+	for (const account of accounts) for (const path of readCodexHistoryWatchPaths(account)) paths.add(path);
+	for (const path of paths) await watchCodexPath(path);
+}
+async function watchCodexPath(path) {
+	if (watchers.has(path)) return;
+	if (!(await stat(path).catch(() => null))?.isDirectory()) return;
+	try {
+		const watcher = watch(path, {
+			persistent: false,
+			recursive: true
+		}, (_eventType, filename) => {
+			if (isCodexHistoryChange(filename)) scheduleProviderSync({ filename });
+		});
+		watcher.on("error", () => {
+			watchers.delete(path);
+			watcher.close();
+		});
+		watchers.set(path, watcher);
+	} catch {
+		const watcher = watch(path, { persistent: false }, (_eventType, filename) => {
+			if (isCodexHistoryChange(filename)) scheduleProviderSync({ filename });
+		});
+		watcher.on("error", () => {
+			watchers.delete(path);
+			watcher.close();
+		});
+		watchers.set(path, watcher);
+	}
+}
+function isCodexHistoryChange(filename) {
+	if (!filename) return true;
+	const path = filename.toString();
+	return path.endsWith(".jsonl") || path.includes("session_index.jsonl") || path.includes("logs_2.sqlite");
+}
+function readCodexThreadId(filename) {
+	return filename?.toString().match(/([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\.jsonl$/iu)?.[1] ?? null;
+}
+//#endregion
+export { startChatStatusMonitor };