void 0.1.6 → 0.7.0

package/dist/mcp-CaQzfeUi.mjs

@@ -0,0 +1,373 @@
+import { a as join, n as dirname } from "./pathe.M-eThtNZ-D-kmWkCS.mjs";
+import { a as writeProjectConfig } from "./project-TqORyHn8.mjs";
+import { n as PlatformClient, s as getToken } from "./client-snXOjrp1.mjs";
+import { existsSync, readFileSync, readdirSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { createInterface } from "node:readline";
+//#region src/cli/mcp.ts
+function findPackageRoot(from) {
+	let dir = from;
+	while (true) {
+		if (existsSync(join(dir, "package.json"))) return dir;
+		const parent = dirname(dir);
+		if (parent === dir) break;
+		dir = parent;
+	}
+	throw new Error(`mcp: Could not find package.json from '${from}'.`);
+}
+function resolveDocsDir() {
+	const pkgRoot = findPackageRoot(dirname(fileURLToPath(import.meta.url)));
+	const bundledDocsDir = join(pkgRoot, "skills", "void", "docs");
+	if (existsSync(bundledDocsDir)) return bundledDocsDir;
+	const workspaceDocsDir = join(pkgRoot, "..", "..", "docs");
+	if (existsSync(workspaceDocsDir)) return workspaceDocsDir;
+	throw new Error(`mcp: Void docs directory not found. Expected bundled docs at '${bundledDocsDir}'.`);
+}
+function findMdFiles(dir, prefix = "") {
+	const results = [];
+	for (const entry of readdirSync(dir, { withFileTypes: true })) {
+		if (entry.name === "node_modules" || entry.name.startsWith(".")) continue;
+		const rel = prefix ? prefix + "/" + entry.name : entry.name;
+		if (entry.isDirectory()) results.push(...findMdFiles(join(dir, entry.name), rel));
+		else if (entry.name.endsWith(".md")) results.push(rel);
+	}
+	return results;
+}
+function loadDocs() {
+	const docsDir = resolveDocsDir();
+	return findMdFiles(docsDir).sort().map((file) => {
+		let content = readFileSync(join(docsDir, file), "utf-8");
+		content = content.replace(/^---\n[\s\S]*?\n---\n/, "");
+		const titleMatch = content.match(/^#\s+(.+)/m);
+		const title = titleMatch ? titleMatch[1].trim() : file.replace(/\.md$/, "");
+		return {
+			slug: file.replace(/\.md$/, ""),
+			title,
+			content
+		};
+	});
+}
+function searchDocs(pages, query) {
+	const terms = query.toLowerCase().split(/\s+/).filter((t) => t.length > 0);
+	if (terms.length === 0) return [];
+	const scored = [];
+	for (const page of pages) {
+		const titleLower = page.title.toLowerCase();
+		const contentLower = page.content.toLowerCase();
+		let score = 0;
+		let firstMatchIndex = -1;
+		for (const term of terms) {
+			let idx = 0;
+			while ((idx = titleLower.indexOf(term, idx)) !== -1) {
+				score += 3;
+				idx += term.length;
+			}
+			idx = 0;
+			while ((idx = contentLower.indexOf(term, idx)) !== -1) {
+				score += 1;
+				if (firstMatchIndex === -1) firstMatchIndex = idx;
+				idx += term.length;
+			}
+		}
+		if (score === 0) continue;
+		let snippet;
+		if (firstMatchIndex !== -1) {
+			const start = Math.max(0, firstMatchIndex - 80);
+			const end = Math.min(page.content.length, firstMatchIndex + 120);
+			snippet = (start > 0 ? "..." : "") + page.content.slice(start, end).trim() + (end < page.content.length ? "..." : "");
+		} else snippet = page.content.slice(0, 200).trim() + "...";
+		scored.push({
+			slug: page.slug,
+			title: page.title,
+			snippet,
+			score
+		});
+	}
+	scored.sort((a, b) => b.score - a.score);
+	return scored.slice(0, 5);
+}
+function createQuerySdk(token) {
+	const client = new PlatformClient(token, { root: process.cwd() });
+	const sdk = {};
+	const proto = Object.getPrototypeOf(client);
+	for (const key of Object.getOwnPropertyNames(proto)) {
+		if (key === "constructor") continue;
+		const val = proto[key];
+		if (typeof val === "function") sdk[key] = val.bind(client);
+	}
+	sdk.link = async (slug) => {
+		const existing = (await client.listProjects()).find((p) => p.slug === slug);
+		if (existing) {
+			writeProjectConfig(process.cwd(), {
+				projectId: existing.id,
+				slug: existing.slug
+			});
+			return {
+				projectId: existing.id,
+				slug: existing.slug,
+				created: false
+			};
+		}
+		const created = await client.createProject(slug);
+		writeProjectConfig(process.cwd(), {
+			projectId: created.id,
+			slug: created.slug
+		});
+		return {
+			projectId: created.id,
+			slug: created.slug,
+			created: true
+		};
+	};
+	return sdk;
+}
+const TOOLS = [
+	{
+		name: "list_pages",
+		description: "List all Void documentation pages with their slugs and titles",
+		inputSchema: {
+			type: "object",
+			properties: {}
+		}
+	},
+	{
+		name: "get_page",
+		description: "Get the full content of a Void documentation page by slug",
+		inputSchema: {
+			type: "object",
+			properties: { slug: {
+				type: "string",
+				description: "Page slug, e.g. 'routing' or 'quickstart'"
+			} },
+			required: ["slug"]
+		}
+	},
+	{
+		name: "search_docs",
+		description: "Search Void documentation by keyword query. Returns top 5 matching pages with snippets.",
+		inputSchema: {
+			type: "object",
+			properties: { query: {
+				type: "string",
+				description: "Search query, e.g. 'file routing' or 'database migrations'"
+			} },
+			required: ["query"]
+		}
+	},
+	{
+		name: "query",
+		description: `Execute JavaScript to interact with the Void platform API.
+
+Available methods on the "void_" object:
+
+  Account:
+    void_.whoami() → { login, plan }
+
+  Projects:
+    void_.listProjects() → { id, slug, type, created_at, custom_domain }[]
+    void_.createProject(slug) → { id, slug }
+    void_.deleteProject(projectId) → { ok, id, slug, warnings? }
+    void_.link(slug) → { projectId, slug, created } — find-or-create project + write .void/project.json
+
+  Deployments:
+    void_.listDeployments(projectId) → { deployments, activeDeploymentId }
+    void_.rollback(projectId, deploymentId, options?) → { ok, deploymentId?, migrationDiff?, error? }
+      options.allowDestructive: string[] of migration names the current
+      active has that target lacks. Required for destructive rollbacks;
+      server returns 400 if omitted or if its view of the set has drifted.
+
+  Logs:
+    void_.getLogs(projectId, since, limit?, deploymentId?) → { timestamp, outcome, logs, exceptions, url, method, status }[]
+      since: duration string (e.g. "1h"), limit: number (default 200)
+
+  Secrets:
+    void_.listSecrets(projectId) → { name }[]
+    void_.setSecret(projectId, name, value) → { ok, name }
+    void_.deleteSecret(projectId, name) → { ok, name }
+
+  Domains:
+    void_.listDomains(projectId) → { id, hostname, status, cname_target? }[]
+    void_.getDomainStatus(projectId, domainId) → { hostname, status, ssl_status, verification_errors? }
+    void_.addDomain(projectId, hostname) → { id, hostname, status, cname_target? }
+    void_.removeDomain(projectId, domainId) → { ok }
+
+  Database:
+    void_.getMigrationStatus(projectId) → { applied: { name, applied_at }[] }
+    void_.setDatabaseUrl(projectId, connectionString) → { ok }
+    void_.getResources(projectId) → { type, binding_name }[]
+
+Write an async arrow function in JavaScript. The SDK is available as "void_".
+Example: async () => { const ps = await void_.listProjects(); return ps.map(p => p.slug); }`,
+		inputSchema: {
+			type: "object",
+			properties: { code: {
+				type: "string",
+				description: "JavaScript async arrow function to execute"
+			} },
+			required: ["code"]
+		}
+	}
+];
+function handleRequest(ctx, req) {
+	const { method, id, params } = req;
+	if (method === "initialize") return {
+		jsonrpc: "2.0",
+		id,
+		result: {
+			protocolVersion: "2024-11-05",
+			capabilities: { tools: {} },
+			serverInfo: {
+				name: "void",
+				version: "1.0.0"
+			}
+		}
+	};
+	if (method === "notifications/initialized") return null;
+	if (method === "ping") return {
+		jsonrpc: "2.0",
+		id,
+		result: {}
+	};
+	if (method === "tools/list") return {
+		jsonrpc: "2.0",
+		id,
+		result: { tools: TOOLS }
+	};
+	if (method === "tools/call") {
+		const toolName = params?.name;
+		const toolArgs = params?.arguments ?? {};
+		if (toolName === "list_pages") {
+			const list = ctx.pages.map((p) => ({
+				slug: p.slug,
+				title: p.title
+			}));
+			return {
+				jsonrpc: "2.0",
+				id,
+				result: { content: [{
+					type: "text",
+					text: JSON.stringify(list, null, 2)
+				}] }
+			};
+		}
+		if (toolName === "get_page") {
+			const slug = toolArgs.slug;
+			const page = ctx.pages.find((p) => p.slug === slug);
+			if (!page) return {
+				jsonrpc: "2.0",
+				id,
+				result: {
+					content: [{
+						type: "text",
+						text: `Page not found: ${slug}`
+					}],
+					isError: true
+				}
+			};
+			return {
+				jsonrpc: "2.0",
+				id,
+				result: { content: [{
+					type: "text",
+					text: page.content
+				}] }
+			};
+		}
+		if (toolName === "search_docs") {
+			const query = toolArgs.query;
+			const results = searchDocs(ctx.pages, query);
+			return {
+				jsonrpc: "2.0",
+				id,
+				result: { content: [{
+					type: "text",
+					text: JSON.stringify(results, null, 2)
+				}] }
+			};
+		}
+		if (toolName === "query") {
+			const code = toolArgs.code;
+			if (!ctx.token) return {
+				jsonrpc: "2.0",
+				id,
+				result: {
+					content: [{
+						type: "text",
+						text: "Not logged in. Run `void auth login` first."
+					}],
+					isError: true
+				}
+			};
+			const sdk = createQuerySdk(ctx.token);
+			const AsyncFunction = async function() {}.constructor;
+			return (async () => {
+				try {
+					const fn = new AsyncFunction("void_", `return await (${code})()`);
+					const result = await Promise.race([fn(sdk), new Promise((_, reject) => setTimeout(() => reject(/* @__PURE__ */ new Error("mcp: Query timed out after 10 seconds.")), 1e4))]);
+					return {
+						jsonrpc: "2.0",
+						id,
+						result: { content: [{
+							type: "text",
+							text: JSON.stringify(result, null, 2)
+						}] }
+					};
+				} catch (err) {
+					return {
+						jsonrpc: "2.0",
+						id,
+						result: {
+							content: [{
+								type: "text",
+								text: `Error: ${err instanceof Error ? err.message : String(err)}`
+							}],
+							isError: true
+						}
+					};
+				}
+			})();
+		}
+		return {
+			jsonrpc: "2.0",
+			id,
+			error: {
+				code: -32601,
+				message: `Unknown tool: ${toolName}`
+			}
+		};
+	}
+	return {
+		jsonrpc: "2.0",
+		id,
+		error: {
+			code: -32601,
+			message: `Unknown method: ${method}`
+		}
+	};
+}
+function runMcp() {
+	const ctx = {
+		pages: loadDocs(),
+		token: getToken(process.cwd())
+	};
+	createInterface({ input: process.stdin }).on("line", async (line) => {
+		let req;
+		try {
+			req = JSON.parse(line);
+		} catch {
+			process.stdout.write(JSON.stringify({
+				jsonrpc: "2.0",
+				id: null,
+				error: {
+					code: -32700,
+					message: "Parse error"
+				}
+			}) + "\n");
+			return;
+		}
+		const response = await handleRequest(ctx, req);
+		if (response !== null) process.stdout.write(JSON.stringify(response) + "\n");
+	});
+}
+//#endregion
+export { runMcp };

package/dist/node-DDfXj10V.mjs

@@ -0,0 +1,54 @@
+import { a as join } from "./pathe.M-eThtNZ-D-kmWkCS.mjs";
+import { n as loadVoidAuthConfig, t as findVoidAuthConfig } from "./config-CvHtTM0q.mjs";
+import { f as readConfig } from "./config-BIa9HwVX.mjs";
+import { r as resolveVoidAuthMigrationSchema } from "./drizzle-NnudE_UN.mjs";
+import { n as applySqliteAuthMigrations, t as applyPgAuthMigrations } from "./auth-migrations-BAtAck2g.mjs";
+import { getMiniflareDatabasePath } from "./runner-6Ep3fNQu.mjs";
+import { loadEnv } from "vite";
+//#region src/auth/node.ts
+async function runLocalVoidAuthMigrations(root, dialect, persistRoot = join(root, ".void"), databaseId = "local", configPath = findVoidAuthConfig(root)) {
+	const authConfig = await loadVoidAuthConfig(configPath);
+	const runtime = {
+		dialect,
+		providers: readConfig(root).auth?.providers ?? null,
+		userConfig: authConfig
+	};
+	const env = loadEnv("development", root, "");
+	const migrationSchema = resolveVoidAuthMigrationSchema(runtime, env);
+	if (dialect === "sqlite") {
+		const { DatabaseSync } = await import("node:sqlite");
+		const db = new DatabaseSync(getMiniflareDatabasePath(persistRoot, databaseId));
+		try {
+			await applySqliteAuthMigrations({
+				async all(sql) {
+					return db.prepare(sql).all();
+				},
+				async run(sql) {
+					db.prepare(sql).run();
+				}
+			}, migrationSchema);
+		} finally {
+			db.close();
+		}
+		return;
+	}
+	const connectionString = typeof env.DATABASE_URL === "string" && env.DATABASE_URL.length > 0 ? env.DATABASE_URL : void 0;
+	if (!connectionString) return;
+	const { Client } = await import("pg");
+	const client = new Client({ connectionString });
+	await client.connect();
+	try {
+		await applyPgAuthMigrations({
+			async all(sql, params) {
+				return (await client.query(sql, params)).rows;
+			},
+			async run(sql, params) {
+				await client.query(sql, params);
+			}
+		}, migrationSchema);
+	} finally {
+		await client.end();
+	}
+}
+//#endregion
+export { runLocalVoidAuthMigrations };

package/dist/output-BwlcIYSR.mjs

@@ -0,0 +1,139 @@
+import { r as __toESM, t as __commonJSMin } from "./chunk-DJd-R1mw.mjs";
+import { c as R, f as at, h as ft } from "./dist-Dayj3gCK.mjs";
+//#region ../../node_modules/.pnpm/picocolors@1.1.1/node_modules/picocolors/picocolors.js
+var require_picocolors = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	let p = process || {}, argv = p.argv || [], env = p.env || {};
+	let isColorSupported = !(!!env.NO_COLOR || argv.includes("--no-color")) && (!!env.FORCE_COLOR || argv.includes("--color") || p.platform === "win32" || (p.stdout || {}).isTTY && env.TERM !== "dumb" || !!env.CI);
+	let formatter = (open, close, replace = open) => (input) => {
+		let string = "" + input, index = string.indexOf(close, open.length);
+		return ~index ? open + replaceClose(string, close, replace, index) + close : open + string + close;
+	};
+	let replaceClose = (string, close, replace, index) => {
+		let result = "", cursor = 0;
+		do {
+			result += string.substring(cursor, index) + replace;
+			cursor = index + close.length;
+			index = string.indexOf(close, cursor);
+		} while (~index);
+		return result + string.substring(cursor);
+	};
+	let createColors = (enabled = isColorSupported) => {
+		let f = enabled ? formatter : () => String;
+		return {
+			isColorSupported: enabled,
+			reset: f("\x1B[0m", "\x1B[0m"),
+			bold: f("\x1B[1m", "\x1B[22m", "\x1B[22m\x1B[1m"),
+			dim: f("\x1B[2m", "\x1B[22m", "\x1B[22m\x1B[2m"),
+			italic: f("\x1B[3m", "\x1B[23m"),
+			underline: f("\x1B[4m", "\x1B[24m"),
+			inverse: f("\x1B[7m", "\x1B[27m"),
+			hidden: f("\x1B[8m", "\x1B[28m"),
+			strikethrough: f("\x1B[9m", "\x1B[29m"),
+			black: f("\x1B[30m", "\x1B[39m"),
+			red: f("\x1B[31m", "\x1B[39m"),
+			green: f("\x1B[32m", "\x1B[39m"),
+			yellow: f("\x1B[33m", "\x1B[39m"),
+			blue: f("\x1B[34m", "\x1B[39m"),
+			magenta: f("\x1B[35m", "\x1B[39m"),
+			cyan: f("\x1B[36m", "\x1B[39m"),
+			white: f("\x1B[37m", "\x1B[39m"),
+			gray: f("\x1B[90m", "\x1B[39m"),
+			bgBlack: f("\x1B[40m", "\x1B[49m"),
+			bgRed: f("\x1B[41m", "\x1B[49m"),
+			bgGreen: f("\x1B[42m", "\x1B[49m"),
+			bgYellow: f("\x1B[43m", "\x1B[49m"),
+			bgBlue: f("\x1B[44m", "\x1B[49m"),
+			bgMagenta: f("\x1B[45m", "\x1B[49m"),
+			bgCyan: f("\x1B[46m", "\x1B[49m"),
+			bgWhite: f("\x1B[47m", "\x1B[49m"),
+			blackBright: f("\x1B[90m", "\x1B[39m"),
+			redBright: f("\x1B[91m", "\x1B[39m"),
+			greenBright: f("\x1B[92m", "\x1B[39m"),
+			yellowBright: f("\x1B[93m", "\x1B[39m"),
+			blueBright: f("\x1B[94m", "\x1B[39m"),
+			magentaBright: f("\x1B[95m", "\x1B[39m"),
+			cyanBright: f("\x1B[96m", "\x1B[39m"),
+			whiteBright: f("\x1B[97m", "\x1B[39m"),
+			bgBlackBright: f("\x1B[100m", "\x1B[49m"),
+			bgRedBright: f("\x1B[101m", "\x1B[49m"),
+			bgGreenBright: f("\x1B[102m", "\x1B[49m"),
+			bgYellowBright: f("\x1B[103m", "\x1B[49m"),
+			bgBlueBright: f("\x1B[104m", "\x1B[49m"),
+			bgMagentaBright: f("\x1B[105m", "\x1B[49m"),
+			bgCyanBright: f("\x1B[106m", "\x1B[49m"),
+			bgWhiteBright: f("\x1B[107m", "\x1B[49m")
+		};
+	};
+	module.exports = createColors();
+	module.exports.createColors = createColors;
+}));
+//#endregion
+//#region src/cli/output.ts
+var import_picocolors = /* @__PURE__ */ __toESM(require_picocolors(), 1);
+/**
+* CI-safe spinner wrapper. In CI environments (GitHub Actions, etc.),
+* `@clack/prompts` spinner emits DEC Private Mode cursor hide/show codes
+* (`\x1b[?25l` / `\x1b[?25h`) that render as text artifacts. This wrapper
+* replaces the spinner with plain log output in CI.
+*/
+function createSpinner() {
+	if (!at()) return ft();
+	let currentMessage = "";
+	return {
+		start(msg = "") {
+			currentMessage = msg;
+			if (msg) R.step(msg);
+		},
+		stop(msg = "") {
+			if (msg) R.info(msg);
+		},
+		message(msg = "") {
+			if (msg && msg !== currentMessage) {
+				currentMessage = msg;
+				R.step(msg);
+			}
+		},
+		cancel(msg = "") {
+			if (msg) R.warn(msg);
+		},
+		error(msg = "") {
+			if (msg) R.error(msg);
+		},
+		clear() {},
+		get isCancelled() {
+			return false;
+		}
+	};
+}
+function cliTitle(command) {
+	return import_picocolors.default.blue(`void ${command}`);
+}
+function sectionTitle(title) {
+	return import_picocolors.default.reset(import_picocolors.default.blue(title));
+}
+function categoryTitle(title) {
+	return import_picocolors.default.reset(import_picocolors.default.bold(import_picocolors.default.cyan(title)));
+}
+function dim(text) {
+	return import_picocolors.default.dim(text);
+}
+function tablePrefix() {
+	return `${import_picocolors.default.gray("│")}  `;
+}
+function helpLine(command, description) {
+	return `${import_picocolors.default.reset(command.padEnd(34))} ${import_picocolors.default.dim(description)}`;
+}
+/**
+* Ensure a timestamp string will be parsed as UTC by `new Date()`.
+* DB timestamps lack timezone info — appends 'Z' only when no
+* existing indicator (Z, z, or numeric offset) is present.
+*/
+function ensureUtc(s) {
+	const last = s.at(-1);
+	if (last === "Z" || last === "z") return s;
+	if (s.includes("+", 10)) return s;
+	if (s.lastIndexOf("-") > 9) return s;
+	return s + "Z";
+}
+//#endregion
+export { ensureUtc as a, sectionTitle as c, dim as i, tablePrefix as l, cliTitle as n, helpLine as o, createSpinner as r, import_picocolors as s, categoryTitle as t, require_picocolors as u };