pockcode 0.0.1

package/dist/assets/socket.server-7dC-9Fnw.js

@@ -0,0 +1,436 @@
+import { createRequire } from "node:module";
+import { chmodSync, realpathSync, statSync } from "node:fs";
+import { readFile, readdir, realpath, stat } from "node:fs/promises";
+import path from "node:path";
+import { randomUUID } from "node:crypto";
+import os, { homedir } from "node:os";
+import { Server } from "socket.io";
+import * as pty from "node-pty";
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+//#region app/server/http.server.ts
+var HttpError = class extends Error {
+	constructor(status, message) {
+		super(message);
+		this.status = status;
+	}
+};
+function readStringField(value, field, options = {}) {
+	if (value === void 0 || value === null) {
+		if (options.required) throw new HttpError(400, `${field} is required.`);
+		return;
+	}
+	if (typeof value !== "string") throw new HttpError(400, `${field} must be a string.`);
+	const trimmed = value.trim();
+	if (!trimmed && options.required) throw new HttpError(400, `${field} is required.`);
+	if (options.maxLength && trimmed.length > options.maxLength) throw new HttpError(400, `${field} must be ${options.maxLength} characters or fewer.`);
+	return trimmed || void 0;
+}
+function readBooleanField(value, field) {
+	if (value === void 0) return;
+	if (typeof value !== "boolean") throw new HttpError(400, `${field} must be a boolean.`);
+	return value;
+}
+function readRecordField(value, field) {
+	if (value === void 0) return;
+	if (!value || typeof value !== "object" || Array.isArray(value)) throw new HttpError(400, `${field} must be an object.`);
+	return value;
+}
+//#endregion
+//#region app/server/workspaces.server.ts
+var workspaceRoot = realpathSync(homedir());
+var maxDirectoryEntries = 500;
+var maxTextFileBytes = 256 * 1024;
+var skippedDirectoryNames = new Set([
+	".git",
+	".next",
+	".turbo",
+	".vite",
+	"build",
+	"coverage",
+	"dist",
+	"node_modules",
+	"target"
+]);
+async function listWorkspaceDirectory(inputPath, includeHidden) {
+	const directoryPath = await resolveWorkspacePath(inputPath);
+	const entries = await readDirectoryEntries(directoryPath);
+	return {
+		root: workspaceRoot,
+		path: directoryPath,
+		parentPath: path.dirname(directoryPath) === directoryPath ? null : path.dirname(directoryPath),
+		entries: entries.filter((entry) => includeHidden || !isHiddenEntry(entry.name)).map((entry) => toWorkspaceEntry(directoryPath, entry.name, entry.isDirectory(), entry.isSymbolicLink())).sort(sortWorkspaceEntries).slice(0, maxDirectoryEntries)
+	};
+}
+async function readWorkspaceTree(inputPath, includeHidden) {
+	return readWorkspaceTreeDirectory(await resolveWorkspacePath(inputPath), includeHidden);
+}
+async function readWorkspaceResource(inputPath) {
+	const filePath = await resolveWorkspaceFilePath(inputPath);
+	const name = path.basename(filePath);
+	const stats = await readStats(filePath);
+	if (stats.size > maxTextFileBytes) return {
+		content: `File too large to preview (${formatBytes(stats.size)}).`,
+		name,
+		path: filePath,
+		type: "file"
+	};
+	if (!isTextFileName(name)) throw new HttpError(415, "Only text files can be opened.");
+	try {
+		return {
+			content: await readFile(filePath, "utf8"),
+			name,
+			path: filePath,
+			type: "file"
+		};
+	} catch (error) {
+		throw new HttpError(400, readError(error));
+	}
+}
+async function resolveWorkspaceDirectoryPath(inputPath) {
+	return resolveWorkspacePath(inputPath);
+}
+async function resolveWorkspacePath(inputPath) {
+	const requested = inputPath?.trim();
+	const resolvedPath = await resolveRealPath(requested ? resolveUserPath(requested) : workspaceRoot);
+	if (!isPathWithinWorkspaceRoot(resolvedPath)) throw new HttpError(403, "Path is outside the file browser home.");
+	if (!(await readStats(resolvedPath)).isDirectory()) throw new HttpError(400, "Path is not a directory.");
+	return resolvedPath;
+}
+async function resolveWorkspaceFilePath(inputPath) {
+	const requested = inputPath?.trim();
+	if (!requested) throw new HttpError(400, "path is required.");
+	const resolvedPath = await resolveRealPath(resolveUserPath(requested));
+	if (!isPathWithinWorkspaceRoot(resolvedPath)) throw new HttpError(403, "Path is outside the file browser home.");
+	if (!(await readStats(resolvedPath)).isFile()) throw new HttpError(400, "Path is not a file.");
+	return resolvedPath;
+}
+async function readWorkspaceTreeDirectory(directoryPath, includeHidden) {
+	const entry = {
+		name: path.basename(directoryPath) || directoryPath,
+		path: directoryPath,
+		type: "directory",
+		children: []
+	};
+	const children = await readTreeDirectoryEntries(directoryPath, entry);
+	for (const child of children.filter((entry) => includeHidden || !isHiddenEntry(entry.name)).sort((left, right) => sortWorkspaceEntries(toWorkspaceEntry(directoryPath, left.name, left.isDirectory(), left.isSymbolicLink()), toWorkspaceEntry(directoryPath, right.name, right.isDirectory(), right.isSymbolicLink()))).slice(0, maxDirectoryEntries)) {
+		if (child.isSymbolicLink()) {
+			entry.children?.push(toWorkspaceEntry(directoryPath, child.name, false, true));
+			continue;
+		}
+		if (child.isDirectory()) {
+			if (!skippedDirectoryNames.has(child.name)) entry.children?.push(toWorkspaceEntry(directoryPath, child.name, true, false));
+			continue;
+		}
+		entry.children?.push(toWorkspaceEntry(directoryPath, child.name, false, false));
+	}
+	return entry;
+}
+function toWorkspaceEntry(parentPath, name, isDirectory, isSymlink) {
+	return {
+		name,
+		path: path.join(parentPath, name),
+		type: isDirectory ? "directory" : isSymlink ? "symlink" : "file"
+	};
+}
+function sortWorkspaceEntries(left, right) {
+	if (left.type === "directory" && right.type !== "directory") return -1;
+	if (left.type !== "directory" && right.type === "directory") return 1;
+	return left.name.localeCompare(right.name);
+}
+function resolveUserPath(inputPath) {
+	if (inputPath === "~") return workspaceRoot;
+	if (inputPath.startsWith("~/")) return path.join(workspaceRoot, inputPath.slice(2));
+	if (path.isAbsolute(inputPath)) return inputPath;
+	return path.join(workspaceRoot, inputPath);
+}
+async function resolveRealPath(inputPath) {
+	try {
+		return await realpath(path.resolve(inputPath));
+	} catch (error) {
+		if (isNodeError(error) && error.code === "ENOENT") throw new HttpError(400, "Directory path does not exist.");
+		throw new HttpError(400, readError(error));
+	}
+}
+async function readStats(inputPath) {
+	try {
+		return await stat(inputPath);
+	} catch (error) {
+		throw new HttpError(400, readError(error));
+	}
+}
+async function readDirectoryEntries(directoryPath) {
+	try {
+		return await readdir(directoryPath, { withFileTypes: true });
+	} catch (error) {
+		throw new HttpError(400, readError(error));
+	}
+}
+async function readTreeDirectoryEntries(directoryPath, entry) {
+	try {
+		return await readdir(directoryPath, { withFileTypes: true });
+	} catch (error) {
+		entry.error = readError(error);
+		return [];
+	}
+}
+function isPathWithinWorkspaceRoot(inputPath) {
+	const relativePath = path.relative(workspaceRoot, inputPath);
+	return relativePath === "" || !relativePath.startsWith("..") && !path.isAbsolute(relativePath);
+}
+function isHiddenEntry(name) {
+	return name.startsWith(".");
+}
+function isTextFileName(name) {
+	return /(?:\.([cm]?[jt]sx?|json|md|txt|css|html?|ya?ml|toml|rs|sh|env|gitignore|dockerignore)|^Makefile$|^Dockerfile$|^\.env)/i.test(name);
+}
+function formatBytes(bytes) {
+	if (bytes < 1024) return `${bytes} B`;
+	if (bytes < 1024 * 1024) return `${Math.round(bytes / 1024)} KB`;
+	return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+function readError(error) {
+	return error instanceof Error ? error.message : "Request failed.";
+}
+function isNodeError(error) {
+	return error instanceof Error && "code" in error;
+}
+//#endregion
+//#region app/server/terminal.server.ts
+var terminalSessionsBySocket = /* @__PURE__ */ new Map();
+var require = createRequire(import.meta.url);
+var nodePtyHelperChecked = false;
+function installTerminalSocketHandlers(socket) {
+	const sessions = /* @__PURE__ */ new Map();
+	terminalSessionsBySocket.set(socket.id, sessions);
+	socket.on("terminal.create", (payload, reply) => {
+		createTerminal(socket, sessions, payload, reply);
+	});
+	socket.on("terminal.input", (payload) => {
+		const record = readRecord(payload);
+		const terminalId = readString(record.id);
+		const data = readString(record.data);
+		if (!terminalId || data === void 0) return;
+		sessions.get(terminalId)?.process.write(data);
+	});
+	socket.on("terminal.resize", (payload) => {
+		const record = readRecord(payload);
+		const terminalId = readString(record.id);
+		const cols = readInt(record.cols, 80, 2, 500);
+		const rows = readInt(record.rows, 24, 2, 200);
+		if (!terminalId) return;
+		sessions.get(terminalId)?.process.resize(cols, rows);
+	});
+	socket.on("terminal.close", (payload) => {
+		const terminalId = readString(readRecord(payload).id);
+		if (!terminalId) return;
+		const session = sessions.get(terminalId);
+		if (!session) return;
+		sessions.delete(terminalId);
+		closeHostedTerminal(session);
+		socket.emit("terminal.closed", { id: terminalId });
+	});
+	socket.on("disconnect", () => {
+		for (const session of sessions.values()) closeHostedTerminal(session);
+		sessions.clear();
+		terminalSessionsBySocket.delete(socket.id);
+	});
+}
+async function createTerminal(socket, sessions, payload, reply) {
+	try {
+		const record = readRecord(payload);
+		const cwd = await resolveWorkspaceDirectoryPath(readString(record.workspacePath) ?? null);
+		const cols = readInt(record.cols, 80, 2, 500);
+		const rows = readInt(record.rows, 24, 2, 200);
+		const shell = resolveShell();
+		const name = path.basename(shell);
+		ensureNodePtySpawnHelperExecutable();
+		const terminal = pty.spawn(shell, [], {
+			cols,
+			cwd,
+			env: terminalEnv(),
+			name: "xterm-256color",
+			rows
+		});
+		const id = randomUUID();
+		const session = {
+			cwd,
+			dataListener: terminal.onData((data) => socket.emit("terminal.output", {
+				data,
+				id
+			})),
+			exitListener: terminal.onExit(({ exitCode, signal }) => {
+				sessions.delete(id);
+				socket.emit("terminal.exit", {
+					exitCode,
+					id,
+					signal
+				});
+			}),
+			id,
+			name,
+			process: terminal,
+			shell
+		};
+		sessions.set(id, session);
+		const metadata = terminalMetadata(session);
+		reply?.({
+			ok: true,
+			terminal: metadata
+		});
+		socket.emit("terminal.created", metadata);
+	} catch (error) {
+		const message = error instanceof Error ? error.message : "Unable to start terminal.";
+		reply?.({
+			error: message,
+			ok: false
+		});
+		socket.emit("terminal.error", { error: message });
+	}
+}
+function closeHostedTerminal(session) {
+	session.dataListener.dispose();
+	session.exitListener.dispose();
+	session.process.kill();
+}
+function ensureNodePtySpawnHelperExecutable() {
+	if (nodePtyHelperChecked || process.platform === "win32") return;
+	nodePtyHelperChecked = true;
+	try {
+		const packageJsonPath = require.resolve("node-pty/package.json");
+		const helperPath = path.join(path.dirname(packageJsonPath), "prebuilds", `${process.platform}-${process.arch}`, "spawn-helper");
+		const stats = statSync(helperPath);
+		if ((stats.mode & 73) === 0) chmodSync(helperPath, stats.mode | 73);
+	} catch {}
+}
+function terminalMetadata(session) {
+	return {
+		cwd: session.cwd,
+		id: session.id,
+		name: session.name,
+		shell: session.shell
+	};
+}
+function resolveShell() {
+	if (process.platform === "win32") return process.env.ComSpec || "powershell.exe";
+	return process.env.SHELL || "/bin/zsh";
+}
+function terminalEnv() {
+	const env = {};
+	for (const [key, value] of Object.entries(process.env)) if (value !== void 0) env[key] = value;
+	env.COLORTERM = env.COLORTERM || "truecolor";
+	env.TERM = "xterm-256color";
+	env.USER = env.USER || os.userInfo().username;
+	return env;
+}
+function readRecord(value) {
+	return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function readString(value) {
+	return typeof value === "string" ? value : void 0;
+}
+function readInt(value, fallback, min, max) {
+	if (typeof value !== "number" || !Number.isFinite(value)) return fallback;
+	return Math.min(max, Math.max(min, Math.round(value)));
+}
+//#endregion
+//#region app/server/socket.server.ts
+var socket_server_exports = /* @__PURE__ */ __exportAll({
+	installProviderSocketServer: () => installProviderSocketServer,
+	listWatchedWorkspacePaths: () => listWatchedWorkspacePaths,
+	onProviderEvent: () => onProviderEvent,
+	onWorkspaceWatchChange: () => onWorkspaceWatchChange,
+	publishProviderEvent: () => publishProviderEvent
+});
+var installedServers = /* @__PURE__ */ new WeakSet();
+var providerEventListeners = /* @__PURE__ */ new Set();
+var workspaceWatchListeners = /* @__PURE__ */ new Set();
+var workspacePathsBySocket = /* @__PURE__ */ new Map();
+var io = null;
+function installProviderSocketServer(server, options = {}) {
+	if (installedServers.has(server)) return;
+	installedServers.add(server);
+	io = new Server(server, {
+		allowRequest: options.authenticateRequest ? (req, callback) => {
+			Promise.resolve(options.authenticateRequest?.(req) ?? true).then((allowed) => callback(null, allowed)).catch((error) => callback(error instanceof Error ? error.message : "Unauthorized.", false));
+		} : void 0,
+		cors: {
+			origin: true,
+			credentials: true
+		},
+		path: "/socket.io"
+	});
+	io.on("connection", (socket) => {
+		installTerminalSocketHandlers(socket);
+		socket.on("chat.join", (threadId) => {
+			if (threadId) socket.join(chatRoom(threadId));
+		});
+		socket.on("workspace.join", (workspacePath) => {
+			const path = normalizeWorkspacePath(workspacePath);
+			if (!path) return;
+			const paths = workspacePathsBySocket.get(socket.id) ?? /* @__PURE__ */ new Set();
+			paths.add(path);
+			workspacePathsBySocket.set(socket.id, paths);
+			notifyWorkspaceWatchListeners();
+		});
+		socket.on("workspace.leave", (workspacePath) => {
+			const path = normalizeWorkspacePath(workspacePath);
+			if (!path) return;
+			const paths = workspacePathsBySocket.get(socket.id);
+			paths?.delete(path);
+			if (!paths?.size) workspacePathsBySocket.delete(socket.id);
+			notifyWorkspaceWatchListeners();
+		});
+		socket.on("chat.leave", (threadId) => {
+			if (threadId) socket.leave(chatRoom(threadId));
+		});
+		socket.on("disconnect", () => {
+			if (workspacePathsBySocket.delete(socket.id)) notifyWorkspaceWatchListeners();
+		});
+	});
+}
+function listWatchedWorkspacePaths() {
+	const paths = /* @__PURE__ */ new Set();
+	for (const socketPaths of workspacePathsBySocket.values()) for (const path of socketPaths) paths.add(path);
+	return [...paths];
+}
+function onWorkspaceWatchChange(listener) {
+	workspaceWatchListeners.add(listener);
+}
+function onProviderEvent(listener) {
+	providerEventListeners.add(listener);
+	return () => {
+		providerEventListeners.delete(listener);
+	};
+}
+function publishProviderEvent(event) {
+	for (const listener of providerEventListeners) Promise.resolve(listener(event)).catch(() => void 0);
+	if (!io) return;
+	if (event.threadId) io.to(chatRoom(event.threadId)).emit(event.type, event.payload);
+	if (isChatDeltaEvent(event.type)) return;
+	io.emit("provider.event", event);
+}
+function chatRoom(threadId) {
+	return `chat:${threadId}`;
+}
+function isChatDeltaEvent(type) {
+	return type === "message.created" || type === "message.deleted" || type === "messages.replaced";
+}
+function normalizeWorkspacePath(value) {
+	return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+function notifyWorkspaceWatchListeners() {
+	for (const listener of workspaceWatchListeners) listener();
+}
+//#endregion
+export { socket_server_exports as a, readWorkspaceTree as c, readRecordField as d, readStringField as f, publishProviderEvent as i, HttpError as l, onProviderEvent as n, listWorkspaceDirectory as o, __exportAll as p, onWorkspaceWatchChange as r, readWorkspaceResource as s, listWatchedWorkspacePaths as t, readBooleanField as u };