void 0.1.6 → 0.7.0

package/dist/scan-C6HMEIdW.mjs

@@ -0,0 +1,318 @@
+import { a as join, t as basename } from "./pathe.M-eThtNZ-D-kmWkCS.mjs";
+import { n as globSync, t as glob } from "./dist-DUyXJLkq.mjs";
+import { d as isIdentifier, f as isLiteral, m as isObjectExpression, u as isCallExpression } from "./plugin-inference-oZ6Ybu2_.mjs";
+import { o as parseRouteFilename, s as parseWebSocketFilename, t as scanPages } from "./scan-Ba4hFwlH.mjs";
+import { readFileSync } from "node:fs";
+import { parseSync } from "vite";
+//#region src/crons/scan.ts
+const JOB_EXTENSIONS = [
+	"ts",
+	"mts",
+	"js",
+	"mjs"
+];
+function extractJobName(filePath) {
+	return filePath.replace(/\.[^.]+$/, "");
+}
+function extractCronExpressions(source, filePath) {
+	const singleMatch = source.match(/export\s+const\s+cron\s*=\s*(['"`])([^'"`]+)\1/);
+	if (singleMatch) {
+		const cron = singleMatch[2].trim();
+		if (!cron) throw new Error(`cron: Invalid job file '${filePath}'. Cron expression cannot be empty.`);
+		return [cron];
+	}
+	const arrayMatch = source.match(/export\s+const\s+cron\s*=\s*\[([^\]]+)\]/);
+	if (arrayMatch) {
+		const items = arrayMatch[1].match(/(['"`])([^'"`]+)\1/g);
+		if (!items || items.length === 0) throw new Error(`cron: Invalid job file '${filePath}'. Cron array cannot be empty.`);
+		return items.map((item) => {
+			return item.match(/['"`]([^'"`]+)['"`]/)[1].trim();
+		});
+	}
+	throw new Error(`cron: Invalid job file '${filePath}'. Add \`export const cron = "<schedule>"\`.`);
+}
+function parseJobFiles(root, jobsDir, files) {
+	return files.filter((f) => !f.split("/").some((segment) => segment.startsWith("_"))).sort((a, b) => a.localeCompare(b)).map((filePath) => {
+		const source = readFileSync(join(root, jobsDir, filePath), "utf-8");
+		return {
+			filePath,
+			name: extractJobName(filePath),
+			crons: extractCronExpressions(source, filePath)
+		};
+	});
+}
+async function scanJobs(root, jobsDir = "crons") {
+	return parseJobFiles(root, jobsDir, await glob(`**/*.{${JOB_EXTENSIONS.join(",")}}`, {
+		cwd: `${root}/${jobsDir}`,
+		absolute: false
+	}).catch(() => []));
+}
+function scanJobsSync(root, jobsDir = "crons") {
+	const pattern = `**/*.{${JOB_EXTENSIONS.join(",")}}`;
+	let files;
+	try {
+		files = globSync(pattern, {
+			cwd: `${root}/${jobsDir}`,
+			absolute: false
+		});
+	} catch {
+		files = [];
+	}
+	return parseJobFiles(root, jobsDir, files);
+}
+//#endregion
+//#region src/queues/scan.ts
+const QUEUE_EXTENSIONS = [
+	"ts",
+	"mts",
+	"js",
+	"mjs"
+];
+function extractName(filePath) {
+	return filePath.replace(/\.[^.]+$/, "");
+}
+function deriveBindingName(name) {
+	return "QUEUE_" + name.toUpperCase().replace(/[^A-Z0-9]/g, "_");
+}
+function extractConsumerOption(source, name) {
+	const re = new RegExp(`export\\s+const\\s+${name}\\s*=\\s*(\\d+)`);
+	const match = source.match(re);
+	return match ? Number(match[1]) : void 0;
+}
+function parseQueueFiles(root, queuesDir, files) {
+	return files.filter((f) => !f.split("/").some((segment) => segment.startsWith("_"))).sort((a, b) => a.localeCompare(b)).map((filePath) => {
+		const source = readFileSync(join(root, queuesDir, filePath), "utf-8");
+		const name = extractName(filePath);
+		return {
+			filePath,
+			name,
+			bindingName: deriveBindingName(name),
+			maxBatchSize: extractConsumerOption(source, "maxBatchSize"),
+			maxBatchTimeout: extractConsumerOption(source, "maxBatchTimeout"),
+			maxRetries: extractConsumerOption(source, "maxRetries"),
+			retryDelay: extractConsumerOption(source, "retryDelay")
+		};
+	});
+}
+async function scanQueues(root, queuesDir = "queues") {
+	return parseQueueFiles(root, queuesDir, await glob(`**/*.{${QUEUE_EXTENSIONS.join(",")}}`, {
+		cwd: `${root}/${queuesDir}`,
+		absolute: false
+	}).catch(() => []));
+}
+function scanQueuesSync(root, queuesDir = "queues") {
+	const pattern = `**/*.{${QUEUE_EXTENSIONS.join(",")}}`;
+	let files;
+	try {
+		files = globSync(pattern, {
+			cwd: `${root}/${queuesDir}`,
+			absolute: false
+		});
+	} catch {
+		files = [];
+	}
+	return parseQueueFiles(root, queuesDir, files);
+}
+//#endregion
+//#region src/router/detect-exports.ts
+const HTTP_METHODS = new Set([
+	"GET",
+	"POST",
+	"PUT",
+	"PATCH",
+	"DELETE",
+	"OPTIONS",
+	"HEAD"
+]);
+/**
+* Detect which HTTP method names are exported from a route file.
+* Scans top-level named exports for identifiers matching HTTP methods.
+*/
+function detectHttpExports(absPath) {
+	const code = readFileSync(absPath, "utf-8");
+	const filename = basename(absPath);
+	let parsed;
+	try {
+		parsed = parseSync(filename, code);
+	} catch {
+		return [];
+	}
+	const methods = [];
+	const program = parsed.program;
+	for (const node of program.body ?? []) if (node.type === "ExportNamedDeclaration") {
+		const declarationNode = node;
+		const decl = declarationNode.declaration;
+		if (decl) {
+			if (decl.type === "VariableDeclaration") {
+				for (const declarator of decl.declarations ?? []) if (isIdentifier(declarator.id) && HTTP_METHODS.has(declarator.id.name)) methods.push(declarator.id.name);
+			} else if (decl.type === "FunctionDeclaration") {
+				const fn = decl;
+				if (isIdentifier(fn.id) && HTTP_METHODS.has(fn.id.name)) methods.push(fn.id.name);
+			}
+		}
+		if (declarationNode.specifiers) for (const spec of declarationNode.specifiers) {
+			const exported = isIdentifier(spec.exported) ? spec.exported.name : isIdentifier(spec.local) ? spec.local.name : void 0;
+			if (exported && HTTP_METHODS.has(exported)) methods.push(exported);
+		}
+	}
+	return methods;
+}
+//#endregion
+//#region src/router/websocket.ts
+const HANDLER_EXTENSIONS$1 = [
+	"ts",
+	"mts",
+	"js",
+	"mjs"
+];
+const WEBSOCKET_ROUTE_RE = /(?:\.(?:dev|prod))?\.ws\.(?:ts|mts|js|mjs)$/;
+function isWebSocketRouteFile(filePath) {
+	return WEBSOCKET_ROUTE_RE.test(filePath.replace(/\\/g, "/"));
+}
+function toIdentifierPart(segment) {
+	return segment.replace(/^\(\s*|\s*\)$/g, "").replace(/^\[\.\.\.(.+)\]$/, "$1").replace(/^\[(.+)\]$/, "$1").replace(/\.ws$/, "").replace(/\.(dev|prod)$/, "").replace(/[^a-zA-Z0-9]+/g, " ").split(" ").filter(Boolean).map((part) => part[0].toUpperCase() + part.slice(1)).join("");
+}
+function deriveWebSocketClassName(filePath) {
+	const parts = filePath.replace(/\\/g, "/").replace(/\.(ts|mts|js|mjs)$/, "").split("/").filter((segment) => segment.length > 0 && !(segment.startsWith("(") && segment.endsWith(")"))).map(toIdentifierPart).filter(Boolean);
+	return (parts.length > 0 ? parts.join("") : "WebSocket") + "Ws";
+}
+function getPropertyName(node) {
+	if (!node) return null;
+	if (isIdentifier(node)) return node.name;
+	if (isLiteral(node) && typeof node.value === "string") return node.value;
+	return null;
+}
+function extractDefinition(call) {
+	if (!isCallExpression(call)) return null;
+	if (!isIdentifier(call.callee)) return null;
+	const calleeName = call.callee.name;
+	if (calleeName !== "defineRoom" && calleeName !== "defineWebSocket") return null;
+	let hasAuthGate = false;
+	const options = call.arguments?.[0];
+	if (isObjectExpression(options)) for (const property of options.properties ?? []) {
+		if (property.type !== "Property") continue;
+		if (getPropertyName(property.key) === "onBeforeConnect") {
+			hasAuthGate = true;
+			break;
+		}
+	}
+	return {
+		mode: calleeName === "defineRoom" ? "room" : "socket",
+		hasAuthGate
+	};
+}
+function detectWebSocketDefinition(absPath) {
+	const code = readFileSync(absPath, "utf-8");
+	const filename = absPath.split("/").pop() ?? absPath;
+	let parsed;
+	try {
+		parsed = parseSync(filename, code);
+	} catch {
+		return null;
+	}
+	const program = parsed.program;
+	const variableInitializers = /* @__PURE__ */ new Map();
+	for (const node of program.body ?? []) if (node.type === "VariableDeclaration") {
+		for (const declarator of node.declarations ?? []) if (isIdentifier(declarator.id) && declarator.init) variableInitializers.set(declarator.id.name, declarator.init);
+	}
+	for (const node of program.body ?? []) {
+		if (node.type !== "ExportDefaultDeclaration") continue;
+		const declaration = node.declaration;
+		if (isIdentifier(declaration)) return extractDefinition(variableInitializers.get(declaration.name));
+		return extractDefinition(declaration);
+	}
+	return null;
+}
+function buildWebSocketRoute(root, filePath) {
+	const parsed = parseWebSocketFilename(filePath);
+	const info = detectWebSocketDefinition(join(root, "routes", filePath));
+	const className = deriveWebSocketClassName(filePath);
+	return {
+		...parsed,
+		className,
+		bindingName: className,
+		mode: info?.mode ?? "socket",
+		hasAuthGate: info?.hasAuthGate ?? false
+	};
+}
+function parseWebSocketFiles(root, files) {
+	return files.filter((f) => isWebSocketRouteFile(f)).filter((f) => !f.split("/").some((segment) => segment.startsWith("_"))).map((filePath) => buildWebSocketRoute(root, filePath)).sort((a, b) => {
+		if (a.catchAll !== b.catchAll) return a.catchAll ? 1 : -1;
+		return a.pattern.localeCompare(b.pattern);
+	});
+}
+async function scanWebSocketRoutes(root) {
+	return parseWebSocketFiles(root, await glob(`**/*.{${HANDLER_EXTENSIONS$1.join(",")}}`, {
+		cwd: `${root}/routes`,
+		absolute: false
+	}).catch(() => []));
+}
+function scanWebSocketRoutesSync(root) {
+	const pattern = `**/*.{${HANDLER_EXTENSIONS$1.join(",")}}`;
+	let files;
+	try {
+		files = globSync(pattern, {
+			cwd: `${root}/routes`,
+			absolute: false
+		});
+	} catch {
+		files = [];
+	}
+	return parseWebSocketFiles(root, files);
+}
+function isWebSocketPatternFile(filePath) {
+	return isWebSocketRouteFile(filePath);
+}
+//#endregion
+//#region src/router/scan.ts
+const HANDLER_EXTENSIONS = [
+	"ts",
+	"mts",
+	"js",
+	"mjs"
+];
+/**
+* Scan routes/ and middleware/ directories and return a structured manifest.
+* Files starting with _ are ignored.
+*/
+async function scanRoutes(root, options) {
+	const pattern = `**/*.{${HANDLER_EXTENSIONS.join(",")}}`;
+	const [routeFiles, websockets, middlewareFiles, jobs, queues, pages] = await Promise.all([
+		glob(pattern, {
+			cwd: `${root}/routes`,
+			absolute: false
+		}),
+		scanWebSocketRoutes(root),
+		glob(pattern, {
+			cwd: `${root}/middleware`,
+			absolute: false
+		}).catch(() => []),
+		scanJobs(root),
+		scanQueues(root),
+		scanPages(root, { output: options?.output })
+	]);
+	const routesDir = `${root}/routes`;
+	return {
+		routes: routeFiles.filter((f) => !isWebSocketPatternFile(f)).filter((f) => !f.split("/").some((s) => s.startsWith("_"))).map((f) => {
+			const route = parseRouteFilename(f);
+			route.methods = detectHttpExports(join(routesDir, f));
+			return route;
+		}).sort((a, b) => {
+			if (a.catchAll !== b.catchAll) return a.catchAll ? 1 : -1;
+			return a.pattern.localeCompare(b.pattern);
+		}),
+		websockets,
+		middleware: middlewareFiles.filter((f) => !f.startsWith("_")).map((f) => {
+			const match = f.split("/").pop().match(/^(\d+)\./);
+			return {
+				order: match ? parseInt(match[1], 10) : Infinity,
+				filePath: f
+			};
+		}).sort((a, b) => a.order - b.order),
+		jobs,
+		queues,
+		pages
+	};
+}
+//#endregion
+export { scanJobsSync as i, scanWebSocketRoutesSync as n, scanQueuesSync as r, scanRoutes as t };

package/dist/secret-CeRSukgM.mjs

@@ -0,0 +1,109 @@
+import { n as cliTitle } from "./output-BwlcIYSR.mjs";
+import { _ as me, c as R, g as ge, n as Ce, u as Se, v as ue, x as q, y as ye } from "./dist-Dayj3gCK.mjs";
+import { r as readProjectConfig } from "./project-TqORyHn8.mjs";
+import { n as PlatformClient, s as getToken } from "./client-snXOjrp1.mjs";
+import { r as resolveProjectBySlug, t as getRequestedProjectSlug } from "./resolve-project-Br5BR03U.mjs";
+import { readFileSync } from "node:fs";
+//#region src/cli/secret.ts
+async function runSecretCommand(root, args) {
+	console.log();
+	ge(cliTitle("secret"));
+	const token = getToken(root);
+	if (!token) {
+		R.error("Not logged in. Run `void auth login` first.");
+		process.exit(1);
+	}
+	const client = new PlatformClient(token, { root });
+	const requestedProjectName = getRequestedProjectSlug({ projectSlug: args.projectName });
+	let projectId;
+	if (requestedProjectName) {
+		const config = resolveProjectBySlug(await client.listProjects(), requestedProjectName);
+		if (!config) throw new Error(`secret: No project found with slug '${requestedProjectName}'.`);
+		projectId = config.projectId;
+	} else {
+		const config = readProjectConfig(root);
+		if (!config) throw new Error("No linked project found. Run `void project link`, `void deploy`, or pass --project <name>.");
+		projectId = config.projectId;
+	}
+	if (args.action === "list") {
+		const secrets = await client.listSecrets(projectId);
+		if (secrets.length === 0) {
+			ye("No secrets set.");
+			return;
+		}
+		Se(secrets.map((s) => `  ${s.name}`).join("\n"), "Secrets");
+		ye(`${secrets.length} secret(s)`);
+		return;
+	}
+	if (args.action === "put") {
+		const value = args.value ?? await readSecretValue();
+		await client.setSecret(projectId, args.name, value);
+		ye(`Secret ${args.name} set.`);
+		return;
+	}
+	if (args.action === "sync") {
+		const secrets = parseDotenvFile(args.file);
+		if (secrets.length === 0) {
+			R.warn("No secrets found in file.");
+			ye("Nothing to sync.");
+			return;
+		}
+		R.info(`Found ${secrets.length} secret(s):`);
+		for (const s of secrets) R.message(`  ${s.name}`);
+		const proceed = await ue({ message: `This will overwrite ${secrets.length} secret(s) in the remote environment. Continue?` });
+		if (q(proceed) || !proceed) {
+			me("Secret sync cancelled.");
+			process.exit(0);
+		}
+		for (const s of secrets) {
+			await client.setSecret(projectId, s.name, s.value);
+			R.success(`Set ${s.name}`);
+		}
+		ye(`Synced ${secrets.length} secret(s).`);
+		return;
+	}
+	await client.deleteSecret(projectId, args.name);
+	ye(`Secret ${args.name} deleted.`);
+}
+const SECRET_KEY_RE = /^[A-Z][A-Z0-9_]*$/;
+function parseDotenvFile(filePath) {
+	const content = readFileSync(filePath, "utf-8");
+	const secrets = [];
+	for (const line of content.split("\n")) {
+		const trimmed = line.trim();
+		if (!trimmed || trimmed.startsWith("#")) continue;
+		const eqIndex = trimmed.indexOf("=");
+		if (eqIndex === -1) throw new Error(`secret: Invalid dotenv line '${trimmed}'. Add KEY=value.`);
+		const key = trimmed.slice(0, eqIndex).trim();
+		let value = trimmed.slice(eqIndex + 1).trim();
+		if (value.startsWith("\"") && value.endsWith("\"") || value.startsWith("'") && value.endsWith("'")) value = value.slice(1, -1);
+		if (!SECRET_KEY_RE.test(key)) throw new Error(`secret: Invalid secret name '${key}'. Use uppercase letters, digits, and underscores.`);
+		secrets.push({
+			name: key,
+			value
+		});
+	}
+	return secrets;
+}
+async function readSecretValue() {
+	if (!process.stdin.isTTY) {
+		const chunks = [];
+		for await (const chunk of process.stdin) chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk)));
+		const value = Buffer.concat(chunks).toString("utf-8");
+		if (value.length === 0) throw new Error("Secret value is required.");
+		return value;
+	}
+	const result = await Ce({
+		message: "Enter secret value:",
+		mask: "*"
+	});
+	if (q(result)) {
+		me("Secret command cancelled.");
+		process.exit(0);
+	}
+	const value = result ?? "";
+	if (value.length === 0) throw new Error("Secret value is required.");
+	return value;
+}
+//#endregion
+export { runSecretCommand };

package/dist/skills-ipldjlKE.mjs

@@ -0,0 +1,62 @@
+import { a as join, o as relative } from "./pathe.M-eThtNZ-D-kmWkCS.mjs";
+import { c as R } from "./dist-Dayj3gCK.mjs";
+import { r as getPackageDir } from "./cli/cli.mjs";
+import { existsSync, mkdirSync, readFileSync, readdirSync, readlinkSync, symlinkSync } from "node:fs";
+//#region src/cli/skills.ts
+function parseSkills(skillsDir) {
+	if (!existsSync(skillsDir)) return [];
+	const entries = readdirSync(skillsDir, { withFileTypes: true });
+	const skills = [];
+	for (const entry of entries) {
+		if (!entry.isDirectory()) continue;
+		const skillMd = join(skillsDir, entry.name, "SKILL.md");
+		if (!existsSync(skillMd)) continue;
+		const frontmatter = readFileSync(skillMd, "utf-8").match(/^---\n([\s\S]*?)\n---/);
+		if (!frontmatter) continue;
+		const nameMatch = frontmatter[1].match(/^name:\s*(.+)$/m);
+		const descMatch = frontmatter[1].match(/^description:\s*(.+)$/m);
+		skills.push({
+			dirName: entry.name,
+			name: nameMatch ? nameMatch[1].trim() : entry.name,
+			description: descMatch ? descMatch[1].trim() : ""
+		});
+	}
+	return skills;
+}
+function linkSkills(root, skillsDir, skills, agentSkillsDir) {
+	const targetDir = join(root, agentSkillsDir);
+	mkdirSync(targetDir, { recursive: true });
+	let linked = 0;
+	for (const skill of skills) {
+		const linkPath = join(targetDir, skill.dirName);
+		const relativeTarget = relative(targetDir, join(skillsDir, skill.dirName));
+		if (existsSync(linkPath)) {
+			try {
+				if (readlinkSync(linkPath) === relativeTarget) {
+					R.info(`  ${skill.name} — already linked`);
+					continue;
+				}
+			} catch {}
+			R.warn(`  ${skill.name} — path exists but is not the expected symlink, skipping`);
+			continue;
+		}
+		symlinkSync(relativeTarget, linkPath, process.platform === "win32" ? "junction" : "dir");
+		R.success(`  ${skill.name} — linked`);
+		linked++;
+	}
+	return linked;
+}
+function linkSkillsForSpecificAgents(root, agents) {
+	const skillsDir = join(getPackageDir(), "skills");
+	const skills = parseSkills(skillsDir);
+	if (skills.length === 0) return 0;
+	if (agents.length === 0) return 0;
+	let totalLinked = 0;
+	for (const agent of agents) {
+		R.info(`${agent.displayName} → ${agent.skillsDir}`);
+		totalLinked += linkSkills(root, skillsDir, skills, agent.skillsDir);
+	}
+	return totalLinked;
+}
+//#endregion
+export { linkSkillsForSpecificAgents };

package/dist/standard-schema-9CRjx-uR.d.mts

@@ -0,0 +1,42 @@
+//#region src/standard-schema.d.ts
+/**
+* Standard Schema V1 types, inlined from the spec.
+* https://github.com/standard-schema/standard-schema
+*
+* Per the spec's design, libraries may copy these types directly
+* to avoid requiring `@standard-schema/spec` as a dependency.
+*/
+interface StandardSchemaV1<Input = unknown, Output = Input> {
+  readonly "~standard": StandardSchemaV1.Props<Input, Output>;
+}
+declare namespace StandardSchemaV1 {
+  interface Props<Input = unknown, Output = Input> {
+    readonly version: 1;
+    readonly vendor: string;
+    readonly validate: (value: unknown) => Result<Output> | Promise<Result<Output>>;
+    readonly types?: Types<Input, Output> | undefined;
+  }
+  type Result<Output> = SuccessResult<Output> | FailureResult;
+  interface SuccessResult<Output> {
+    readonly value: Output;
+    readonly issues?: undefined;
+  }
+  interface FailureResult {
+    readonly issues: ReadonlyArray<Issue>;
+  }
+  interface Issue {
+    readonly message: string;
+    readonly path?: ReadonlyArray<PropertyKey | PathSegment> | undefined;
+  }
+  interface PathSegment {
+    readonly key: PropertyKey;
+  }
+  interface Types<Input = unknown, Output = Input> {
+    readonly input: Input;
+    readonly output: Output;
+  }
+  type InferInput<Schema extends StandardSchemaV1> = NonNullable<Schema["~standard"]["types"]>["input"];
+  type InferOutput<Schema extends StandardSchemaV1> = NonNullable<Schema["~standard"]["types"]>["output"];
+}
+//#endregion
+export { StandardSchemaV1 as t };