create-eventus-app 0.1.0

package/dist/chunk-5JPHU7SZ.js

@@ -0,0 +1,108 @@
+// src/scaffold.ts
+import {
+  cp,
+  mkdir,
+  readdir,
+  readFile,
+  rm,
+  stat,
+  writeFile
+} from "fs/promises";
+import path from "path";
+import { fileURLToPath } from "url";
+var DEFAULT_TEMPLATE_CANDIDATES = [
+  path.resolve(
+    path.dirname(fileURLToPath(import.meta.url)),
+    "..",
+    "template"
+  ),
+  path.resolve(
+    path.dirname(fileURLToPath(import.meta.url)),
+    "..",
+    "..",
+    "template-react",
+    "template"
+  )
+];
+var PRESERVED_DIRECTORY_ENTRIES = /* @__PURE__ */ new Set([".git"]);
+async function scaffoldProject(options) {
+  const templateDir = await resolveTemplateDir(options.templateDir);
+  const isTargetDirectoryNonEmpty = await directoryHasFiles(options.targetDir);
+  if (isTargetDirectoryNonEmpty && !options.force) {
+    const shouldContinue = options.onConfirmOverwrite ? await options.onConfirmOverwrite() : false;
+    if (!shouldContinue) {
+      throw new Error(
+        `Target directory ${options.targetDir} is not empty. Use --force to overwrite it.`
+      );
+    }
+  }
+  await mkdir(options.targetDir, { recursive: true });
+  if (isTargetDirectoryNonEmpty) {
+    await clearTargetDirectory(options.targetDir);
+  }
+  await cp(templateDir, options.targetDir, { recursive: true });
+  const replacements = /* @__PURE__ */ new Map([
+    ["__EVENTUS_PACKAGE_NAME__", options.packageName],
+    ["__EVENTUS_DISPLAY_NAME__", options.displayName],
+    ["__EVENTUS_APP_ID__", options.appId],
+    ["__EVENTUS_SDK_VERSION__", options.sdkVersion],
+    ["__EVENTUS_VITE_PLUGIN_VERSION__", options.vitePluginVersion]
+  ]);
+  await replacePlaceholders(options.targetDir, replacements);
+}
+async function resolveTemplateDir(explicitTemplateDir) {
+  if (explicitTemplateDir) {
+    return explicitTemplateDir;
+  }
+  for (const candidate of DEFAULT_TEMPLATE_CANDIDATES) {
+    try {
+      const candidateStats = await stat(candidate);
+      if (candidateStats.isDirectory()) {
+        return candidate;
+      }
+    } catch {
+    }
+  }
+  throw new Error("Unable to locate the Eventus React template.");
+}
+async function directoryHasFiles(targetDir) {
+  try {
+    const entries = await readdir(targetDir);
+    return entries.length > 0;
+  } catch {
+    return false;
+  }
+}
+async function clearTargetDirectory(targetDir) {
+  const entries = await readdir(targetDir, { withFileTypes: true });
+  await Promise.all(
+    entries.filter((entry) => !PRESERVED_DIRECTORY_ENTRIES.has(entry.name)).map(
+      (entry) => rm(path.join(targetDir, entry.name), {
+        recursive: true,
+        force: true
+      })
+    )
+  );
+}
+async function replacePlaceholders(directory, replacements) {
+  const entries = await readdir(directory, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = path.join(directory, entry.name);
+    if (entry.isDirectory()) {
+      await replacePlaceholders(fullPath, replacements);
+      continue;
+    }
+    const fileContents = await readFile(fullPath, "utf8");
+    let nextContents = fileContents;
+    for (const [placeholder, value] of replacements) {
+      nextContents = nextContents.replaceAll(placeholder, value);
+    }
+    if (nextContents !== fileContents) {
+      await writeFile(fullPath, nextContents, "utf8");
+    }
+  }
+}
+
+export {
+  scaffoldProject
+};

package/dist/chunk-BFKUHPSY.js

@@ -0,0 +1,58 @@
+// src/utils.ts
+import { readFile } from "fs/promises";
+import path from "path";
+import validateNpmPackageName from "validate-npm-package-name";
+var PACKAGE_MANAGERS = ["pnpm", "npm", "yarn", "bun"];
+function resolveProjectInput(input, cwd = process.cwd()) {
+  const trimmedInput = input.trim();
+  const targetDir = path.resolve(cwd, trimmedInput);
+  const directoryName = path.basename(targetDir);
+  return {
+    input: trimmedInput,
+    targetDir,
+    directoryName,
+    packageName: directoryName
+  };
+}
+function validateProjectName(name) {
+  const validation = validateNpmPackageName(name);
+  if (validation.validForNewPackages) {
+    return [];
+  }
+  return [...validation.errors ?? [], ...validation.warnings ?? []];
+}
+function toDisplayName(projectName) {
+  return projectName.split(/[-_.\s]+/).filter(Boolean).map((segment) => segment.charAt(0).toUpperCase() + segment.slice(1)).join(" ");
+}
+function toAppId(projectName) {
+  return projectName.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").replace(/-{2,}/g, "-");
+}
+function isPackageManager(value) {
+  return PACKAGE_MANAGERS.includes(value);
+}
+async function readToolkitVersion(packageFileUrl) {
+  const packageJson = JSON.parse(await readFile(packageFileUrl, "utf8"));
+  return packageJson.version ?? "0.1.0";
+}
+function createNextStepsMessage(packageManager, projectDirectory) {
+  const relativeDirectory = path.relative(process.cwd(), projectDirectory) || ".";
+  const installCommand = packageManager === "npm" ? "npm install" : `${packageManager} install`;
+  const devCommand = packageManager === "npm" ? "npm run dev" : `${packageManager} dev`;
+  return [
+    "Next steps:",
+    `  cd ${relativeDirectory}`,
+    `  ${installCommand}`,
+    `  ${devCommand}`
+  ].join("\n");
+}
+
+export {
+  PACKAGE_MANAGERS,
+  resolveProjectInput,
+  validateProjectName,
+  toDisplayName,
+  toAppId,
+  isPackageManager,
+  readToolkitVersion,
+  createNextStepsMessage
+};

package/dist/index.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/index.js

@@ -0,0 +1,121 @@
+#!/usr/bin/env node
+import {
+  scaffoldProject
+} from "./chunk-5JPHU7SZ.js";
+import {
+  PACKAGE_MANAGERS,
+  createNextStepsMessage,
+  isPackageManager,
+  readToolkitVersion,
+  resolveProjectInput,
+  toAppId,
+  toDisplayName,
+  validateProjectName
+} from "./chunk-BFKUHPSY.js";
+
+// src/index.ts
+import {
+  cancel,
+  confirm,
+  intro,
+  isCancel,
+  outro,
+  select,
+  text
+} from "@clack/prompts";
+import { cac } from "cac";
+async function run() {
+  const packageVersion = await readToolkitVersion(new URL("../package.json", import.meta.url));
+  const cli = cac("create-eventus-app");
+  cli.command("[targetDir]", "Create a new Eventus mini app").option("--package-manager <name>", "Package manager to show in next steps").option("--force", "Allow scaffolding into a non-empty directory").option("--sdk-version <version>", "Internal override for local SDK testing").option(
+    "--vite-plugin-version <version>",
+    "Internal override for local Vite plugin testing"
+  ).action(async (targetDir, options) => {
+    intro("Create Eventus App");
+    try {
+      const resolvedInput = await promptForProject(targetDir);
+      const packageManager = await resolvePackageManager(options.packageManager);
+      const toolkitVersion = options.sdkVersion && options.vitePluginVersion ? void 0 : packageVersion;
+      const sdkVersion = options.sdkVersion?.trim() || toolkitVersion || packageVersion;
+      const vitePluginVersion = options.vitePluginVersion?.trim() || toolkitVersion || packageVersion;
+      await scaffoldProject({
+        targetDir: resolvedInput.targetDir,
+        packageName: resolvedInput.packageName,
+        displayName: toDisplayName(resolvedInput.packageName),
+        appId: toAppId(resolvedInput.packageName),
+        packageManager,
+        sdkVersion,
+        vitePluginVersion,
+        force: options.force,
+        onConfirmOverwrite: async () => {
+          const answer = await confirm({
+            message: `The directory ${resolvedInput.targetDir} is not empty. Continue anyway?`,
+            initialValue: false
+          });
+          if (isCancel(answer)) {
+            throw new Error("Scaffolding cancelled by user.");
+          }
+          return answer;
+        }
+      });
+      outro(createNextStepsMessage(packageManager, resolvedInput.targetDir));
+    } catch (error) {
+      cancel(error instanceof Error ? error.message : "Scaffolding failed.");
+      process.exitCode = 1;
+    }
+  });
+  cli.help();
+  cli.version(packageVersion);
+  cli.parse();
+}
+async function promptForProject(targetDir) {
+  const targetInput = targetDir?.trim() ? targetDir : await promptText("Project name:", "eventus-mini-app");
+  const resolvedInput = resolveProjectInput(targetInput);
+  const validationErrors = validateProjectName(resolvedInput.packageName);
+  if (validationErrors.length > 0) {
+    throw new Error(
+      `Invalid project name "${resolvedInput.packageName}": ${validationErrors.join("; ")}`
+    );
+  }
+  const appId = toAppId(resolvedInput.packageName);
+  if (!appId) {
+    throw new Error(
+      `Unable to derive a valid Eventus appId from "${resolvedInput.packageName}".`
+    );
+  }
+  return resolvedInput;
+}
+async function resolvePackageManager(packageManagerOption) {
+  if (packageManagerOption) {
+    if (!isPackageManager(packageManagerOption)) {
+      throw new Error(
+        `Unsupported package manager "${packageManagerOption}". Expected one of: ${PACKAGE_MANAGERS.join(", ")}.`
+      );
+    }
+    return packageManagerOption;
+  }
+  const answer = await select({
+    message: "Which package manager should the next steps use?",
+    options: PACKAGE_MANAGERS.map((packageManager) => ({
+      value: packageManager,
+      label: packageManager
+    })),
+    initialValue: "pnpm"
+  });
+  if (isCancel(answer)) {
+    throw new Error("Scaffolding cancelled by user.");
+  }
+  return answer;
+}
+async function promptText(message, initialValue) {
+  const answer = await text({
+    message,
+    initialValue,
+    placeholder: initialValue
+  });
+  if (isCancel(answer)) {
+    throw new Error("Scaffolding cancelled by user.");
+  }
+  return answer.trim();
+}
+void run();

package/dist/scaffold.d.ts

@@ -0,0 +1,17 @@
+import { PackageManager } from './utils.js';
+
+type ScaffoldProjectOptions = {
+    targetDir: string;
+    packageName: string;
+    displayName: string;
+    appId: string;
+    packageManager: PackageManager;
+    sdkVersion: string;
+    vitePluginVersion: string;
+    force?: boolean | undefined;
+    templateDir?: string | undefined;
+    onConfirmOverwrite?: (() => Promise<boolean>) | undefined;
+};
+declare function scaffoldProject(options: ScaffoldProjectOptions): Promise<void>;
+
+export { type ScaffoldProjectOptions, scaffoldProject };

package/dist/scaffold.js

@@ -0,0 +1,6 @@
+import {
+  scaffoldProject
+} from "./chunk-5JPHU7SZ.js";
+export {
+  scaffoldProject
+};

package/dist/utils.d.ts

@@ -0,0 +1,17 @@
+declare const PACKAGE_MANAGERS: readonly ["pnpm", "npm", "yarn", "bun"];
+type PackageManager = (typeof PACKAGE_MANAGERS)[number];
+type ResolvedProjectInput = {
+    input: string;
+    targetDir: string;
+    directoryName: string;
+    packageName: string;
+};
+declare function resolveProjectInput(input: string, cwd?: string): ResolvedProjectInput;
+declare function validateProjectName(name: string): string[];
+declare function toDisplayName(projectName: string): string;
+declare function toAppId(projectName: string): string;
+declare function isPackageManager(value: string): value is PackageManager;
+declare function readToolkitVersion(packageFileUrl: URL): Promise<string>;
+declare function createNextStepsMessage(packageManager: PackageManager, projectDirectory: string): string;
+
+export { PACKAGE_MANAGERS, type PackageManager, type ResolvedProjectInput, createNextStepsMessage, isPackageManager, readToolkitVersion, resolveProjectInput, toAppId, toDisplayName, validateProjectName };

package/dist/utils.js

@@ -0,0 +1,20 @@
+import {
+  PACKAGE_MANAGERS,
+  createNextStepsMessage,
+  isPackageManager,
+  readToolkitVersion,
+  resolveProjectInput,
+  toAppId,
+  toDisplayName,
+  validateProjectName
+} from "./chunk-BFKUHPSY.js";
+export {
+  PACKAGE_MANAGERS,
+  createNextStepsMessage,
+  isPackageManager,
+  readToolkitVersion,
+  resolveProjectInput,
+  toAppId,
+  toDisplayName,
+  validateProjectName
+};

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "create-eventus-app",
+  "version": "0.1.0",
+  "description": "Scaffold an Eventus mini app.",
+  "type": "module",
+  "bin": {
+    "create-eventus-app": "./dist/index.js"
+  },
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./scaffold": {
+      "types": "./dist/scaffold.d.ts",
+      "import": "./dist/scaffold.js"
+    },
+    "./utils": {
+      "types": "./dist/utils.d.ts",
+      "import": "./dist/utils.js"
+    }
+  },
+  "files": [
+    "dist",
+    "template"
+  ],
+  "scripts": {
+    "build": "node ../../scripts/sync-template.mjs && tsup src/index.ts src/scaffold.ts src/utils.ts --format esm --dts --clean",
+    "check": "tsc -p tsconfig.json --noEmit",
+    "test": "vitest run"
+  },
+  "dependencies": {
+    "@clack/prompts": "^0.10.1",
+    "cac": "^6.7.14",
+    "validate-npm-package-name": "^5.0.0"
+  }
+}

package/template/README.md

@@ -0,0 +1,22 @@
+# __EVENTUS_DISPLAY_NAME__
+
+Starter mini app generated for the Eventus platform.
+
+## Quickstart
+
+```bash
+pnpm install
+pnpm dev
+```
+
+## Available Scripts
+
+- `pnpm dev`: start the Vite development server
+- `pnpm build`: type-check and build the app
+- `pnpm preview`: preview the production build locally
+
+## Eventus Files
+
+- `eventus.manifest.json`: base Eventus manifest consumed by the Vite plugin
+- `src/eventus-env.d.ts`: type declarations for the Eventus virtual module
+- `src/App.tsx`: sample usage of `@eventusgo/sdk` and the manifest module

package/template/eventus.manifest.json

@@ -0,0 +1,6 @@
+{
+  "name": "__EVENTUS_DISPLAY_NAME__",
+  "appId": "__EVENTUS_APP_ID__",
+  "version": "0.1.0",
+  "permissions": ["user.profile.read", "theme.read"]
+}

package/template/index.html

@@ -0,0 +1,12 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>__EVENTUS_DISPLAY_NAME__</title>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="/src/main.tsx"></script>
+  </body>
+</html>

package/template/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "__EVENTUS_PACKAGE_NAME__",
+  "private": true,
+  "version": "0.1.0",
+  "type": "module",
+  "scripts": {
+    "dev": "vite",
+    "build": "tsc --noEmit && vite build",
+    "preview": "vite preview"
+  },
+  "dependencies": {
+    "@eventusgo/sdk": "__EVENTUS_SDK_VERSION__",
+    "react": "18.3.1",
+    "react-dom": "18.3.1"
+  },
+  "devDependencies": {
+    "@eventusgo/vite-plugin": "__EVENTUS_VITE_PLUGIN_VERSION__",
+    "@types/react": "18.3.28",
+    "@types/react-dom": "18.3.7",
+    "@vitejs/plugin-react": "4.7.0",
+    "typescript": "5.9.3",
+    "vite": "5.4.21"
+  }
+}

package/template/src/App.tsx

@@ -0,0 +1,122 @@
+import { useEffect, useState } from "react";
+import manifest from "virtual:eventus-manifest";
+import {
+  eventus,
+  type EventusContext,
+  type EventusRuntimeSource,
+} from "@eventusgo/sdk";
+
+type LoadState =
+  | { status: "idle" | "loading" }
+  | { status: "ready"; context: EventusContext }
+  | { status: "error"; message: string };
+
+export default function App() {
+  const [state, setState] = useState<LoadState>({ status: "loading" });
+  const [runtimeSource, setRuntimeSource] = useState<EventusRuntimeSource | "loading">(
+    "loading",
+  );
+
+  useEffect(() => {
+    let cancelled = false;
+    let receivedReadyEvent = false;
+
+    const unsubscribeReady = eventus.on("ready", ({ context, source }) => {
+      receivedReadyEvent = true;
+      if (!cancelled) {
+        setRuntimeSource(source);
+        setState({ status: "ready", context });
+      }
+    });
+
+    const unsubscribe = eventus.on("themeChange", ({ context }) => {
+      if (!cancelled) {
+        setState({ status: "ready", context });
+      }
+    });
+
+    void (async () => {
+      try {
+        await eventus.ready();
+        const context = await eventus.getContext();
+
+        if (!cancelled && !receivedReadyEvent) {
+          setRuntimeSource("mock");
+          setState({ status: "ready", context });
+        }
+      } catch (error) {
+        if (!cancelled) {
+          setState({
+            status: "error",
+            message:
+              error instanceof Error
+                ? error.message
+                : "Unable to initialize the Eventus client.",
+          });
+        }
+      }
+    })();
+
+    return () => {
+      cancelled = true;
+      unsubscribeReady();
+      unsubscribe();
+    };
+  }, []);
+
+  const runtimeLabel =
+    runtimeSource === "native"
+      ? "Native bridge detected"
+      : runtimeSource === "mock"
+        ? "Browser mock mode active"
+        : "Detecting runtime…";
+
+  return (
+    <main className="app-shell">
+      <section className="card">
+        <p className="eyebrow">Eventus Mini App Toolkit</p>
+        <h1>{manifest.name}</h1>
+        <p className="subtitle">
+          App ID <code>{manifest.appId}</code> · Version <code>{manifest.version}</code>
+        </p>
+
+        <div className="status-banner">{runtimeLabel}</div>
+
+        {state.status === "loading" ? (
+          <p>Connecting to the Eventus client…</p>
+        ) : null}
+
+        {state.status === "error" ? (
+          <p className="error-text">{state.message}</p>
+        ) : null}
+
+        {state.status === "ready" ? (
+          <dl className="details-grid">
+            <div>
+              <dt>Theme</dt>
+              <dd>{state.context.theme}</dd>
+            </div>
+            <div>
+              <dt>Locale</dt>
+              <dd>{state.context.locale}</dd>
+            </div>
+            <div>
+              <dt>User</dt>
+              <dd>{state.context.user?.name ?? state.context.user?.id ?? "Anonymous"}</dd>
+            </div>
+            <div>
+              <dt>Manifest Permissions</dt>
+              <dd>{manifest.permissions?.join(", ") ?? "None"}</dd>
+            </div>
+          </dl>
+        ) : null}
+
+        {state.status === "ready" ? (
+          <pre className="context-preview">
+            {JSON.stringify(state.context, null, 2)}
+          </pre>
+        ) : null}
+      </section>
+    </main>
+  );
+}

package/template/src/eventus-env.d.ts

@@ -0,0 +1,15 @@
+/// <reference types="vite/client" />
+
+type EventusManifest = {
+  name: string;
+  appId: string;
+  version: string;
+  permissions?: string[];
+};
+
+declare module "virtual:eventus-manifest" {
+  const manifest: EventusManifest;
+  export default manifest;
+}
+
+declare const __EVENTUS_MANIFEST__: EventusManifest;

package/template/src/main.tsx

@@ -0,0 +1,11 @@
+import React from "react";
+import ReactDOM from "react-dom/client";
+
+import App from "./App";
+import "./styles.css";
+
+ReactDOM.createRoot(document.getElementById("root")!).render(
+  <React.StrictMode>
+    <App />
+  </React.StrictMode>,
+);

package/template/src/styles.css

@@ -0,0 +1,114 @@
+:root {
+  font-family: "IBM Plex Sans", "Segoe UI", sans-serif;
+  color: #102347;
+  background:
+    radial-gradient(circle at top, #d8f2ff 0%, #f3f9ff 35%, #eef3ff 100%);
+  line-height: 1.5;
+  font-weight: 400;
+}
+
+* {
+  box-sizing: border-box;
+}
+
+body {
+  margin: 0;
+  min-width: 320px;
+  min-height: 100vh;
+}
+
+code,
+pre {
+  font-family: "IBM Plex Mono", "SFMono-Regular", monospace;
+}
+
+.app-shell {
+  min-height: 100vh;
+  display: grid;
+  place-items: center;
+  padding: 24px;
+}
+
+.card {
+  width: min(720px, 100%);
+  padding: 32px;
+  border-radius: 24px;
+  background: rgba(255, 255, 255, 0.84);
+  border: 1px solid rgba(16, 35, 71, 0.08);
+  box-shadow: 0 24px 80px rgba(38, 73, 134, 0.14);
+  backdrop-filter: blur(16px);
+}
+
+.eyebrow {
+  margin: 0 0 8px;
+  font-size: 0.85rem;
+  letter-spacing: 0.12em;
+  text-transform: uppercase;
+  color: #3f6ea8;
+}
+
+h1 {
+  margin: 0;
+  font-size: clamp(2rem, 4vw, 3rem);
+}
+
+.subtitle {
+  margin: 12px 0 0;
+  color: #465d82;
+}
+
+.status-banner {
+  margin: 24px 0;
+  display: inline-flex;
+  padding: 8px 12px;
+  border-radius: 999px;
+  background: #eef6ff;
+  color: #22548d;
+  font-weight: 600;
+}
+
+.details-grid {
+  display: grid;
+  grid-template-columns: repeat(auto-fit, minmax(180px, 1fr));
+  gap: 16px;
+  margin: 24px 0;
+}
+
+.details-grid div {
+  padding: 16px;
+  border-radius: 16px;
+  background: #f8fbff;
+  border: 1px solid rgba(16, 35, 71, 0.08);
+}
+
+dt {
+  margin-bottom: 6px;
+  font-size: 0.85rem;
+  color: #6880a6;
+  text-transform: uppercase;
+  letter-spacing: 0.06em;
+}
+
+dd {
+  margin: 0;
+  font-weight: 600;
+}
+
+.context-preview {
+  margin: 0;
+  padding: 16px;
+  border-radius: 16px;
+  overflow: auto;
+  background: #0d1d3a;
+  color: #eef5ff;
+}
+
+.error-text {
+  color: #b42318;
+}
+
+@media (max-width: 640px) {
+  .card {
+    padding: 24px;
+  }
+}

package/template/tsconfig.json

@@ -0,0 +1,20 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "useDefineForClassFields": true,
+    "lib": ["ES2022", "DOM", "DOM.Iterable"],
+    "allowJs": false,
+    "skipLibCheck": true,
+    "esModuleInterop": false,
+    "allowSyntheticDefaultImports": true,
+    "strict": true,
+    "forceConsistentCasingInFileNames": true,
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "noEmit": true,
+    "jsx": "react-jsx"
+  },
+  "include": ["src", "vite.config.ts"]
+}

package/template/vite.config.ts

@@ -0,0 +1,7 @@
+import { defineConfig } from "vite";
+import react from "@vitejs/plugin-react";
+import { eventusVitePlugin } from "@eventusgo/vite-plugin";
+
+export default defineConfig({
+  plugins: [react(), eventusVitePlugin()],
+});