@autono/open-pages 0.1.0

package/dist/sync-Be_hxSOF.js

@@ -0,0 +1,139 @@
+import chalk from "chalk";
+import { cp, lstat, mkdir, readFile, readdir, readlink, rm, symlink } from "node:fs/promises";
+import path from "node:path";
+import { createHash } from "node:crypto";
+import { existsSync } from "node:fs";
+
+//#region src/cli/sync.ts
+async function detectSkillsDrift(skillsDir) {
+	if (!existsSync(skillsDir)) return [];
+	const cwd = process.cwd();
+	const agentsSkillsDir = path.join(cwd, ".agents", "skills");
+	const skillNames = (await readdir(skillsDir, { withFileTypes: true })).filter((e) => e.isDirectory()).map((e) => e.name).sort();
+	const results = [];
+	for (const name of skillNames) {
+		const src = path.join(skillsDir, name);
+		const dst = path.join(agentsSkillsDir, name);
+		const srcHash = await hashDir(src);
+		const dstHash = existsSync(dst) ? await hashDir(dst) : null;
+		let status;
+		if (dstHash === null) status = "added";
+		else if (dstHash !== srcHash) status = "updated";
+		else status = "unchanged";
+		results.push({
+			name,
+			status
+		});
+	}
+	return results;
+}
+async function syncSkills(skillsDir, opts = {}) {
+	const { dryRun = false } = opts;
+	if (!existsSync(skillsDir)) throw new Error(`Built-in skills directory missing at ${skillsDir}. The @autono/open-pages package may be corrupt — try reinstalling.`);
+	const cwd = process.cwd();
+	const agentsSkillsDir = path.join(cwd, ".agents", "skills");
+	const claudeSkillsDir = path.join(cwd, ".claude", "skills");
+	const results = await detectSkillsDrift(skillsDir);
+	if (results.length === 0) {
+		process.stdout.write(chalk.yellow("No skills found to sync.\n"));
+		return;
+	}
+	for (const { name, status } of results) {
+		const src = path.join(skillsDir, name);
+		const dst = path.join(agentsSkillsDir, name);
+		if (dryRun) continue;
+		if (status === "unchanged") {
+			await ensureClaudeSymlink(claudeSkillsDir, name);
+			continue;
+		}
+		await mkdir(path.dirname(dst), { recursive: true });
+		if (existsSync(dst)) await rm(dst, {
+			recursive: true,
+			force: true
+		});
+		await cp(src, dst, { recursive: true });
+		await ensureClaudeSymlink(claudeSkillsDir, name);
+	}
+	printSummary(results, dryRun);
+}
+async function ensureClaudeSymlink(claudeSkillsDir, name) {
+	await mkdir(claudeSkillsDir, { recursive: true });
+	const linkPath = path.join(claudeSkillsDir, name);
+	const target = path.join("..", "..", ".agents", "skills", name);
+	if (existsSync(linkPath)) try {
+		const stat = await lstat(linkPath);
+		if (stat.isSymbolicLink()) {
+			const current = await readlink(linkPath);
+			if (current === target) return;
+		}
+		await rm(linkPath, {
+			recursive: true,
+			force: true
+		});
+	} catch {
+		await rm(linkPath, {
+			recursive: true,
+			force: true
+		});
+	}
+	try {
+		await symlink(target, linkPath, "dir");
+	} catch (err) {
+		const code = err.code;
+		if (code === "EPERM" || code === "EEXIST") {
+			const absoluteTarget = path.resolve(claudeSkillsDir, target);
+			await cp(absoluteTarget, linkPath, { recursive: true });
+		} else throw err;
+	}
+}
+async function hashDir(dir) {
+	const hash = createHash("sha256");
+	const files = await collectFiles(dir);
+	files.sort();
+	for (const rel of files) {
+		const abs = path.join(dir, rel);
+		const data = await readFile(abs);
+		hash.update(rel);
+		hash.update("\0");
+		hash.update(data);
+		hash.update("\0");
+	}
+	return hash.digest("hex");
+}
+async function collectFiles(dir, prefix = "") {
+	const out = [];
+	const entries = await readdir(dir, { withFileTypes: true });
+	for (const entry of entries) {
+		const rel = prefix ? path.join(prefix, entry.name) : entry.name;
+		if (entry.isDirectory()) out.push(...await collectFiles(path.join(dir, entry.name), rel));
+		else if (entry.isFile()) out.push(rel);
+	}
+	return out;
+}
+function printSummary(results, dryRun) {
+	const symbols = {
+		added: chalk.green("+"),
+		updated: chalk.yellow("~"),
+		unchanged: chalk.dim("=")
+	};
+	const labels = {
+		added: chalk.green("added"),
+		updated: chalk.yellow("updated"),
+		unchanged: chalk.dim("unchanged")
+	};
+	const header = dryRun ? chalk.bold("Dry run — no files written:") : chalk.bold("Synced built-in skills:");
+	process.stdout.write(`${header}\n`);
+	for (const { name, status } of results) process.stdout.write(`  ${symbols[status]} ${name} ${chalk.dim(`(${labels[status]})`)}\n`);
+	const counts = results.reduce((acc, { status }) => {
+		acc[status] += 1;
+		return acc;
+	}, {
+		added: 0,
+		updated: 0,
+		unchanged: 0
+	});
+	process.stdout.write(chalk.dim(`\n${counts.added} added, ${counts.updated} updated, ${counts.unchanged} unchanged.\n`));
+}
+
+//#endregion
+export { detectSkillsDrift, syncSkills };

package/dist/sync-lKEXyPOh.js

@@ -0,0 +1,3 @@
+import { detectSkillsDrift, syncSkills } from "./sync-Be_hxSOF.js";
+
+export { syncSkills };

package/dist/types-C5NCdDT-.d.ts

@@ -0,0 +1,219 @@
+//#region src/locale/types.d.ts
+type Plural = {
+  one: string;
+  other: string;
+};
+type Locale = {
+  id: 'en' | 'zh-TW' | 'zh-CN' | 'ja';
+  common: {
+    cancel: string;
+    save: string;
+    delete: string;
+    rename: string;
+    move: string;
+    add: string;
+    done: string;
+    tryAgain: string;
+    selected: string;
+  };
+  notFound: {
+    eyebrow: string;
+    title: string;
+  };
+  home: {
+    appTitle: string;
+    draft: string;
+    duplicate: string;
+    themes: string;
+    assets: string;
+    folders: string;
+    pages: string;
+    menu: string;
+    newFolder: string;
+    folderName: string;
+    updateAvailable: string;
+    updatePackage: string;
+    updatingPackage: string;
+    updatePackageDone: string;
+    updatePackageFailed: string;
+    restartServer: string;
+    restartingServer: string;
+    restartServerFailed: string;
+    changeIcon: string;
+    iconEmojiTab: string;
+    iconColorTab: string;
+    folderActions: string;
+    searchPlaceholder: string;
+    clearSearch: string;
+    sortLabel: string;
+    sortByCreatedDesc: string;
+    sortByCreatedAsc: string;
+    sortByTitleAsc: string;
+    sortByTitleDesc: string;
+    noMatches: string;
+    nothingMatchesPrefix: string;
+    nothingMatchesSuffix: string;
+    noDocsYet: string;
+    createDocHintPrefix: string;
+    createDocHintSuffix: string;
+    folderEmptyTitle: string;
+    folderEmptyHint: string;
+    docActions: string;
+    moveToFolder: string;
+    renameDialogEyebrow: string;
+    renameDialogTitle: string;
+    renameDialogDescription: string;
+    docNamePlaceholder: string;
+    moveDialogEyebrow: string;
+    moveDialogTitle: string;
+    moveDialogDescriptionPrefix: string;
+    moveDialogDescriptionSuffix: string;
+    deleteDialogEyebrow: string;
+    deleteDialogTitle: string;
+    deleteDialogDescriptionPrefix: string;
+    deleteDialogDescriptionMid: string;
+    deleteDialogDescriptionSuffix: string;
+    toastFolderCreated: string;
+    toastFolderCreateFailed: string;
+    toastDocDuplicated: string;
+    toastDocDuplicateFailed: string;
+    toastDocMoved: string;
+    toastDocMoveFailed: string;
+    toastFolderDeleted: string;
+    toastFolderDeleteFailed: string;
+    toastFolderReorderFailed: string;
+    pickIcon: string;
+  };
+  page: {
+    loadingEyebrow: string;
+  };
+  asset: {
+    devOnlyMessage: string;
+    sectionAria: string;
+    eyebrow: string;
+    scopeDoc: string;
+    scopeGlobal: string;
+    fileCount: Plural;
+    createdAt: string;
+    modifiedAt: string;
+    nameColumn: string;
+    typeColumn: string;
+    sizeColumn: string;
+    statusColumn: string;
+    sortAria: string;
+    sortByColumn: string;
+    sortAscending: string;
+    sortDescending: string;
+    assetSearchPlaceholder: string;
+    clearAssetSearch: string;
+    usageFilterAria: string;
+    usageAll: string;
+    usageUsed: string;
+    usageUnused: string;
+    typeFilterAria: string;
+    typeAll: string;
+    typeImage: string;
+    typeFont: string;
+    typeVideo: string;
+    typeOther: string;
+    gridViewAria: string;
+    listViewAria: string;
+    gridColumnsAria: string;
+    gridColumnsValue: string;
+    noMatchingAssets: string;
+    noMatchingAssetsHint: string;
+    clearFilters: string;
+    searchLogos: string;
+    upload: string;
+    dropToUpload: string;
+    loading: string;
+    noAssetsYet: string;
+    noAssetsHintPrefix: string;
+    noAssetsHintSuffix: string;
+    nameAlreadyExists: string;
+    previewAria: string;
+    actionsAria: string;
+    previewMenuItem: string;
+    renameMenuItem: string;
+    deleteMenuItem: string;
+    conflictTitle: string;
+    conflictDescription: string;
+    conflictReplace: string;
+    conflictRenameCopy: string;
+    deleteAssetTitle: string;
+    deleteAssetDescription: string;
+    deleteAssetInUseDescription: string;
+    deleteAssetInUseHint: string;
+    deleteAndRevert: string;
+    toastRevertFailed: string;
+    toastDeletedWithRevert: string;
+    noPreview: string;
+    importHintComment: string;
+    importHintSemi: string;
+    logoSearchTitle: string;
+    logoSearchPoweredByPrefix: string;
+    logoSearchPlaceholder: string;
+    logoSearchErrorTitle: string;
+    logoSearchErrorBody: string;
+    logoSearchNoResults: string;
+    logoSearchEmpty: string;
+    logoSearchEmptyHintPrefix: string;
+    logoSearchEmptyHintSuffix: string;
+    logoVariantLight: string;
+    logoVariantDark: string;
+    toastUploadFailed: string;
+    toastReplaced: string;
+    toastUploadedAs: string;
+    toastUploaded: string;
+    toastRenameFailed: string;
+    toastRenamed: string;
+    toastDeleteFailed: string;
+    toastDeleted: string;
+    toastDownloadFailed: string;
+    toastSearchFailed: string;
+  };
+  commandMenu: {
+    trigger: string;
+    triggerAria: string;
+    triggerTooltip: string;
+    placeholder: string;
+    empty: string;
+    groupDocs: string;
+    groupFolders: string;
+    groupNavigation: string;
+    groupAppearance: string;
+    groupDeveloper: string;
+    themeItem: string;
+    languageItem: string;
+    hintNavigate: string;
+    hintSelect: string;
+    hintClose: string;
+  };
+  themeToggle: {
+    toggleAria: string;
+    title: string;
+    light: string;
+    dark: string;
+    system: string;
+  };
+  languageToggle: {
+    toggleAria: string;
+    title: string;
+  };
+  themes: {
+    title: string;
+    noThemesTitle: string;
+    noThemesHintPrefix: string;
+    noThemesHintSuffix: string;
+    noDemoYet: string;
+    noDemoHintPrefix: string;
+    noDemoHintSuffix: string;
+    backToGallery: string;
+    openThemeAria: string;
+    usedBy: string;
+    usedByEmpty: string;
+    expandPromptAria: string;
+    collapsePromptAria: string;
+  };
+}; //#endregion
+export { Locale, Plural };

package/dist/update-CV62NhBT.js

@@ -0,0 +1,37 @@
+import { PKG, detectPackageManager, fetchLatest, formatCommand, isOutdated, localOpenPagesCommand, runCommand, updateCommandFor } from "./update-package-Cxt57pz7.js";
+import chalk from "chalk";
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+
+//#region src/cli/update.ts
+async function installedVersion(cwd) {
+	try {
+		const raw = await readFile(path.join(cwd, "node_modules", ...PKG.split("/"), "package.json"), "utf8");
+		return JSON.parse(raw).version ?? null;
+	} catch {
+		return null;
+	}
+}
+async function update(opts) {
+	const cwd = process.cwd();
+	const [latest, installed] = await Promise.all([fetchLatest(), installedVersion(cwd)]);
+	const current = installed ?? opts.current;
+	if (latest && !isOutdated(current, latest) && !opts.force) {
+		process.stdout.write(`${chalk.green("✓")} ${PKG} ${chalk.bold(current)} is the latest version.\n`);
+		return;
+	}
+	const target = latest ? chalk.bold(latest) : chalk.bold("latest");
+	process.stdout.write(`Updating ${PKG} ${chalk.dim(current)} → ${target}\n`);
+	const packageManager = await detectPackageManager(cwd);
+	const install = await updateCommandFor(packageManager, cwd);
+	process.stdout.write(chalk.dim(`$ ${formatCommand(install)}\n`));
+	await runCommand(install, cwd, { stdio: "inherit" });
+	if (opts.skills !== false) {
+		process.stdout.write(chalk.dim("$ open-pages sync:skills\n"));
+		await runCommand(localOpenPagesCommand(cwd, ["sync:skills"]), cwd, { stdio: "inherit" });
+	}
+	process.stdout.write(`${chalk.green("✓")} Updated ${PKG} to ${target}. Restart \`open-pages dev\` to use it.\n`);
+}
+
+//#endregion
+export { update };

package/dist/update-package-Cxt57pz7.js

@@ -0,0 +1,152 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { spawn } from "node:child_process";
+
+//#region src/shared/update-package.ts
+const PKG = "@autono/open-pages";
+const CACHE_TTL_MS = 10 * 60 * 1e3;
+const COMMAND_TIMEOUT_MS = 3e5;
+let cache = null;
+function parseSemver(v) {
+	const m = /^v?(\d+)\.(\d+)\.(\d+)/.exec(v.trim());
+	if (!m) return null;
+	return [
+		Number(m[1]),
+		Number(m[2]),
+		Number(m[3])
+	];
+}
+function isOutdated(current, latest) {
+	const a = parseSemver(current);
+	const b = parseSemver(latest);
+	if (!a || !b) return false;
+	for (let i = 0; i < 3; i++) {
+		if (b[i] > a[i]) return true;
+		if (b[i] < a[i]) return false;
+	}
+	return false;
+}
+/** npm `latest` dist-tag, cached for 10 minutes. Network failures yield null. */
+async function fetchLatest(now = Date.now()) {
+	if (cache && now - cache.at < CACHE_TTL_MS) return cache.latest;
+	try {
+		const res = await fetch(`https://registry.npmjs.org/${PKG}/latest`, {
+			signal: AbortSignal.timeout(3e3),
+			headers: { accept: "application/json" }
+		});
+		if (!res.ok) throw new Error(`registry ${res.status}`);
+		const body = await res.json();
+		const latest = typeof body.version === "string" ? body.version : null;
+		cache = {
+			at: now,
+			latest
+		};
+		return latest;
+	} catch {
+		return cache?.latest ?? null;
+	}
+}
+function invalidateLatestCache() {
+	cache = null;
+}
+async function fileExists(file) {
+	try {
+		await fs.access(file);
+		return true;
+	} catch {
+		return false;
+	}
+}
+async function detectPackageManager(cwd) {
+	if (await fileExists(path.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
+	if (await fileExists(path.join(cwd, "yarn.lock"))) return "yarn";
+	if (await fileExists(path.join(cwd, "bun.lockb"))) return "bun";
+	if (await fileExists(path.join(cwd, "bun.lock"))) return "bun";
+	if (await fileExists(path.join(cwd, "package-lock.json"))) return "npm";
+	const ua = process.env.npm_config_user_agent ?? "";
+	if (ua.startsWith("pnpm")) return "pnpm";
+	if (ua.startsWith("yarn")) return "yarn";
+	if (ua.startsWith("bun")) return "bun";
+	return "npm";
+}
+async function updateCommandFor(packageManager, cwd) {
+	switch (packageManager) {
+		case "pnpm": {
+			const workspaceRoot = await fileExists(path.join(cwd, "pnpm-workspace.yaml"));
+			return {
+				cmd: "pnpm",
+				args: workspaceRoot ? [
+					"add",
+					"--workspace-root",
+					`${PKG}@latest`
+				] : ["add", `${PKG}@latest`]
+			};
+		}
+		case "yarn": return {
+			cmd: "yarn",
+			args: ["add", `${PKG}@latest`]
+		};
+		case "bun": return {
+			cmd: "bun",
+			args: ["add", `${PKG}@latest`]
+		};
+		case "npm": return {
+			cmd: "npm",
+			args: ["install", `${PKG}@latest`]
+		};
+	}
+}
+/**
+* The freshly installed package's own CLI, so skills come from the new
+* version rather than whatever process is driving the update.
+*/
+function localOpenPagesCommand(cwd, args) {
+	const bin = path.join(cwd, "node_modules", ...PKG.split("/"), "bin.js");
+	return {
+		cmd: process.execPath,
+		args: [bin, ...args],
+		shell: false
+	};
+}
+function formatCommand(spec) {
+	return [spec.cmd, ...spec.args].join(" ");
+}
+async function runCommand(spec, cwd, opts = {}) {
+	await new Promise((resolve, reject) => {
+		const child = spawn(spec.cmd, spec.args, {
+			cwd,
+			env: process.env,
+			shell: spec.shell ?? process.platform === "win32",
+			stdio: opts.stdio ?? [
+				"ignore",
+				"ignore",
+				"pipe"
+			]
+		});
+		let stderr = "";
+		const timer = setTimeout(() => {
+			child.kill();
+			reject(new Error(`${formatCommand(spec)} timed out`));
+		}, COMMAND_TIMEOUT_MS);
+		child.stderr?.on("data", (chunk) => {
+			stderr += chunk.toString("utf8");
+			if (stderr.length > 2e3) stderr = stderr.slice(-2e3);
+		});
+		child.on("error", (err) => {
+			clearTimeout(timer);
+			reject(err);
+		});
+		child.on("close", (code) => {
+			clearTimeout(timer);
+			if (code === 0) {
+				resolve();
+				return;
+			}
+			const detail = stderr.trim();
+			reject(new Error(detail || `${formatCommand(spec)} exited with code ${code ?? "unknown"}`));
+		});
+	});
+}
+
+//#endregion
+export { PKG, detectPackageManager, fetchLatest, formatCommand, invalidateLatestCache, isOutdated, localOpenPagesCommand, runCommand, updateCommandFor };

package/dist/version-B6AiiGvT.js

@@ -0,0 +1,26 @@
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { existsSync, readFileSync } from "node:fs";
+
+//#region src/vite/version.ts
+function findPackageRoot(fromFile) {
+	let dir = path.dirname(fromFile);
+	while (dir !== path.dirname(dir)) {
+		if (existsSync(path.join(dir, "package.json"))) return dir;
+		dir = path.dirname(dir);
+	}
+	throw new Error(`Could not find package.json walking up from ${fromFile}`);
+}
+const PKG_ROOT = findPackageRoot(fileURLToPath(import.meta.url));
+const APP_ROOT = path.join(PKG_ROOT, "src", "app");
+function readCoreVersion() {
+	try {
+		const raw = readFileSync(path.join(PKG_ROOT, "package.json"), "utf8");
+		return JSON.parse(raw).version ?? "0.0.0";
+	} catch {
+		return "0.0.0";
+	}
+}
+
+//#endregion
+export { APP_ROOT, PKG_ROOT, readCoreVersion };

package/dist/version-CeffgdfZ.js

@@ -0,0 +1,3 @@
+import { APP_ROOT, PKG_ROOT, readCoreVersion } from "./version-B6AiiGvT.js";
+
+export { readCoreVersion };

package/dist/vite/index.d.ts

@@ -0,0 +1,14 @@
+import "../types-C5NCdDT-.js";
+import { OpenPagesConfig } from "../config-C9or4m4J.js";
+import { InlineConfig } from "vite";
+
+//#region src/vite/config.d.ts
+type CreateViteConfigOptions = {
+  userCwd: string;
+  config?: OpenPagesConfig;
+  mode?: 'serve' | 'build';
+};
+declare function createViteConfig(opts: CreateViteConfigOptions): Promise<InlineConfig>;
+
+//#endregion
+export { createViteConfig };

package/dist/vite/index.js

@@ -0,0 +1,7 @@
+import "../design-C13iz9_4.js";
+import "../open-pages-plugin-D_DN_zjh.js";
+import { createViteConfig } from "../config-L0IbktJ0.js";
+import "../update-package-Cxt57pz7.js";
+import "../version-B6AiiGvT.js";
+
+export { createViteConfig };

package/env.d.ts

@@ -0,0 +1,59 @@
+// Ambient module declarations for assets imported from `pages/<id>/assets/`.
+// Mirrors Vite's default asset handling (default export = resolved URL).
+//
+// Consumers opt in via tsconfig:
+//
+//   { "compilerOptions": { "types": ["@autono/open-pages/env"] } }
+
+declare module '*.svg' {
+  const src: string;
+  export default src;
+}
+declare module '*.png' {
+  const src: string;
+  export default src;
+}
+declare module '*.jpg' {
+  const src: string;
+  export default src;
+}
+declare module '*.jpeg' {
+  const src: string;
+  export default src;
+}
+declare module '*.webp' {
+  const src: string;
+  export default src;
+}
+declare module '*.gif' {
+  const src: string;
+  export default src;
+}
+declare module '*.avif' {
+  const src: string;
+  export default src;
+}
+declare module '*.mp4' {
+  const src: string;
+  export default src;
+}
+declare module '*.webm' {
+  const src: string;
+  export default src;
+}
+declare module '*.woff' {
+  const src: string;
+  export default src;
+}
+declare module '*.woff2' {
+  const src: string;
+  export default src;
+}
+declare module '*.ttf' {
+  const src: string;
+  export default src;
+}
+declare module '*.otf' {
+  const src: string;
+  export default src;
+}