visionos-monorepo 0.1.0

package/client/tailwind.config.ts

@@ -0,0 +1,36 @@
+import type { Config } from "tailwindcss";
+
+const config: Config = {
+  content: ["./index.html", "./src/**/*.{ts,tsx}"],
+  theme: {
+    extend: {
+      colors: {
+        ink: "#0A0A0A",
+        "ink-soft": "#3A3A3A",
+        "ink-muted": "#6B6B6B",
+        beige: "#E0DFD5",
+        "beige-light": "#E8E7DF",
+        "beige-dark": "#D4D3CB",
+        tide: "#0e7490",
+        coral: "#E05A3A",
+        sand: "#FAFAF8",
+        mist: "#E0DFD5"
+      },
+      fontFamily: {
+        sans: ["Inter", "-apple-system", "BlinkMacSystemFont", "sans-serif"],
+        mono: ["JetBrains Mono", "SF Mono", "Fira Code", "monospace"]
+      },
+      boxShadow: {
+        panel: "0 20px 60px rgba(8, 17, 31, 0.12)"
+      },
+      borderRadius: {
+        lg: "16px",
+        md: "8px",
+        sm: "4px"
+      }
+    }
+  },
+  plugins: []
+};
+
+export default config;

package/client/tsconfig.json

@@ -0,0 +1,25 @@
+{
+  "extends": "../tsconfig.base.json",
+  "compilerOptions": {
+    "target": "ES2020",
+    "lib": [
+      "ES2020",
+      "DOM",
+      "DOM.Iterable"
+    ],
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "jsx": "react-jsx",
+    "types": [
+      "vite/client",
+      "node"
+    ],
+    "noEmit": true
+  },
+  "include": [
+    "src",
+    "vite.config.ts",
+    "tailwind.config.ts",
+    "../shared/src/**/*.ts"
+  ]
+}

package/client/vercel.json

@@ -0,0 +1,8 @@
+{
+  "rewrites": [
+    {
+      "source": "/(.*)",
+      "destination": "/index.html"
+    }
+  ]
+}

package/client/vite.config.ts

@@ -0,0 +1,33 @@
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { defineConfig, loadEnv } from "vite";
+import react from "@vitejs/plugin-react";
+
+const rootDir = path.dirname(fileURLToPath(import.meta.url));
+
+export default defineConfig(({ mode }) => {
+  const env = loadEnv(mode, rootDir, "");
+  const apiProxyTarget = env.VITE_API_PROXY_TARGET ?? "https://visionos.onrender.com";
+
+  return {
+    plugins: [react()],
+    resolve: {
+      alias: {
+        "@": path.resolve(rootDir, "./src")
+      }
+    },
+    server: {
+      fs: {
+        allow: [path.resolve(rootDir, "..")]
+      },
+      proxy: {
+        "/api": {
+          target: apiProxyTarget,
+          changeOrigin: true,
+          secure: true,
+          rewrite: (requestPath) => requestPath.replace(/^\/api/, "")
+        }
+      }
+    }
+  };
+});

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "visionos-monorepo",
+  "version": "0.1.0",
+  "private": false,
+  "packageManager": "npm@10",
+  "workspaces": [
+    "cli",
+    "server",
+    "client",
+    "shared"
+  ],
+  "scripts": {
+    "build": "npm run build -w shared && npm run build -w server && npm run build -w client && npm run build -w cli",
+    "pack:cli": "npm run build && npm pack -w cli",
+    "dev": "concurrently -k -n server,client -c blue,magenta \"npm run dev:server\" \"npm run dev:client\"",
+    "dev:cli": "npm run dev -w cli",
+    "dev:server": "npm run dev -w server",
+    "dev:client": "npm run dev -w client",
+    "lint": "npm run lint --workspaces --if-present"
+  },
+  "devDependencies": {
+    "concurrently": "^9.2.1"
+  },
+  "dependencies": {
+    "visionos-cli": "^0.1.7"
+  }
+}

package/server/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "@visionos/server",
+  "version": "0.1.0",
+  "private": false,
+  "type": "module",
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --clean --out-dir dist",
+    "dev": "tsx watch src/index.ts",
+    "start": "node dist/index.js",
+    "lint": "tsc --noEmit -p tsconfig.json"
+  },
+  "dependencies": {
+    "cors": "^2.8.5",
+    "dotenv": "^16.4.5",
+    "express": "^4.21.1",
+    "mongodb": "^6.21.0"
+  },
+  "devDependencies": {
+    "@types/cors": "^2.8.17",
+    "@types/express": "^4.17.21",
+    "@types/node": "^22.10.1",
+    "tsup": "^8.3.0",
+    "tsx": "^4.19.1",
+    "typescript": "^5.6.3"
+  }
+}

package/server/src/app.ts

@@ -0,0 +1,132 @@
+import path from "node:path";
+import cors from "cors";
+import express from "express";
+import { env } from "./config/env.js";
+import { AccountStoreError, createAccountStore, type AccountStore } from "./features/accounts/accountStore.js";
+import { MongoContentStore, type ContentStore } from "./features/accounts/contentStore.js";
+import { createAuthRouter, type CreateAuthRouterOptions } from "./routes/auth.js";
+import { healthRouter } from "./routes/health.js";
+import { createProgressRouter } from "./routes/progress.js";
+import { createContentRouter } from "./routes/content.js";
+
+export interface CreateAppOptions extends CreateAuthRouterOptions {
+  accountStore?: AccountStore | null;
+  contentStore?: ContentStore | null;
+  apiBaseUrl?: string;
+  clientOrigin?: string;
+  corsOrigin?: any;
+  mode?: "development" | "embedded";
+  staticSiteDir?: string;
+  getProgress?: (userId: string) => Promise<any[]> | any[];
+  upsertProgress?: (userId: string, input: any) => Promise<any> | any;
+}
+
+function normalizeOrigin(origin: string) {
+  return origin.trim().replace(/\/+$/, "");
+}
+
+function toAllowedOriginSet(corsOrigin: any) {
+  if (corsOrigin === true) {
+    return true;
+  }
+
+  const origins = Array.isArray(corsOrigin)
+    ? corsOrigin
+    : typeof corsOrigin === "string"
+      ? corsOrigin.split(",")
+      : [];
+
+  return new Set(
+    origins
+      .filter((origin): origin is string => typeof origin === "string")
+      .map(normalizeOrigin)
+      .filter(Boolean)
+  );
+}
+
+export function createApp(options: CreateAppOptions = {}) {
+  const app = express();
+  const clientOrigin = options.clientOrigin ?? env.clientOrigin;
+  const corsOrigin = options.corsOrigin ?? env.corsOrigin;
+  const allowedOrigins = toAllowedOriginSet(corsOrigin);
+  const apiBaseUrl = options.apiBaseUrl ?? `http://${env.host}:${env.port}`;
+  const accountStore = options.accountStore ?? createAccountStore(env.mongoUri, env.mongoDbName);
+  const contentStore = options.contentStore ?? (env.mongoUri ? new MongoContentStore(env.mongoUri, env.mongoDbName) : null);
+  const authRouter = createAuthRouter({
+    accountStore,
+    clientOrigin,
+    googleClientId: options.googleClientId ?? env.googleClientId,
+    getCurrentUser: options.getCurrentUser,
+    onAuthenticated: options.onAuthenticated
+  });
+
+  app.use(
+    cors({
+      origin(origin, callback) {
+        if (!origin || allowedOrigins === true || allowedOrigins.has(normalizeOrigin(origin))) {
+          callback(null, true);
+          return;
+        }
+
+        callback(null, false);
+      }
+    })
+  );
+  app.use(express.json());
+  app.use(express.urlencoded({ extended: true }));
+
+  app.use("/auth", authRouter);
+  app.use(
+    "/progress",
+    createProgressRouter(
+      accountStore,
+      options.getCurrentUser,
+      options.getProgress,
+      options.upsertProgress
+    )
+  );
+  app.use("/content", createContentRouter(accountStore, contentStore));
+  app.use("/health", healthRouter);
+
+  app.get("/runtime/info", (_req, res) => {
+    res.status(200).json({
+      runtime: {
+        appUrl: clientOrigin,
+        apiBaseUrl,
+        mainAppUrl: env.mainClientOrigin,
+        mode: options.mode ?? "development"
+      }
+    });
+  });
+
+  if (options.staticSiteDir) {
+    app.use(express.static(options.staticSiteDir));
+
+    app.get("*", (_req, res) => {
+      res.sendFile(path.join(options.staticSiteDir as string, "index.html"));
+    });
+  } else {
+    app.get("/", (_req, res) => {
+      res.status(200).json({
+        message: "VisionOS API bootstrap is running."
+      });
+    });
+  }
+
+  app.use((error: unknown, _req: express.Request, res: express.Response, _next: express.NextFunction) => {
+    if (error instanceof AccountStoreError) {
+      res.status(error.status).json({
+        message: error.message
+      });
+      return;
+    }
+
+    const message = error instanceof Error ? error.message : "Unexpected VisionOS server error.";
+
+    res.status(500).json({
+      message
+    });
+  });
+
+  return app;
+}

package/server/src/config/env.ts

@@ -0,0 +1,135 @@
+import dotenv from "dotenv";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+let mainClientOrigin = "http://localhost:5173";
+
+function loadEnvFile(filePath: string) {
+  if (fs.existsSync(filePath)) {
+    const result = dotenv.config({ path: filePath });
+    if (result.parsed?.CLIENT_ORIGIN) {
+      mainClientOrigin = result.parsed.CLIENT_ORIGIN;
+    }
+    return true;
+  }
+  return false;
+}
+
+// 1. Try standard current working directory
+const defaultResult = dotenv.config();
+if (defaultResult.parsed?.CLIENT_ORIGIN) {
+  mainClientOrigin = defaultResult.parsed.CLIENT_ORIGIN;
+}
+
+// 2. Walk up parent directories of process.cwd() to find `.env` or `server/.env`
+try {
+  let currentDir = process.cwd();
+  for (let i = 0; i < 10; i++) {
+    const rootEnv = path.join(currentDir, ".env");
+    const serverEnv = path.join(currentDir, "server", ".env");
+
+    if (loadEnvFile(serverEnv)) {
+      break;
+    } else if (loadEnvFile(rootEnv)) {
+      break;
+    }
+
+    const parent = path.dirname(currentDir);
+    if (parent === currentDir) break;
+    currentDir = parent;
+  }
+} catch {
+  // Ignore fallback errors
+}
+
+// 3. Walk up directories starting from import.meta.url to find `.env` or `server/.env`
+try {
+  const startDir = path.dirname(fileURLToPath(import.meta.url));
+  let currentDir = startDir;
+
+  for (let i = 0; i < 10; i++) {
+    const rootEnv = path.join(currentDir, ".env");
+    const serverEnv = path.join(currentDir, "server", ".env");
+
+    if (loadEnvFile(serverEnv)) {
+      break;
+    } else if (loadEnvFile(rootEnv)) {
+      break;
+    }
+
+    const parent = path.dirname(currentDir);
+    if (parent === currentDir) break;
+    currentDir = parent;
+  }
+} catch {
+  // Ignore fallback errors
+}
+
+// 4. Try global user configuration directory (~/.visionos/.env)
+try {
+  const globalEnvPath = path.join(os.homedir(), ".visionos", ".env");
+  if (fs.existsSync(globalEnvPath)) {
+    const result = dotenv.config({ path: globalEnvPath });
+    if (result.parsed?.CLIENT_ORIGIN) {
+      mainClientOrigin = result.parsed.CLIENT_ORIGIN;
+    }
+  }
+} catch {
+  // Ignore fallback errors
+}
+
+const rawPort = Number(process.env.PORT ?? 4000);
+const host = process.env.HOST ?? "127.0.0.1";
+const clientOrigin = process.env.CLIENT_ORIGIN ?? "http://localhost:5173";
+const localDevOrigins = ["http://localhost:5173", "http://127.0.0.1:5173"];
+const deployedOrigins = ["https://vision-os-client.vercel.app", "https://visionos.onrender.com"];
+
+function normalizeOrigin(origin?: string) {
+  return origin?.trim().replace(/\/+$/, "");
+}
+
+function parseOrigins(value?: string) {
+  return (value ?? "")
+    .split(",")
+    .map(normalizeOrigin)
+    .filter(Boolean);
+}
+
+function uniqueOrigins(origins: Array<string | undefined>) {
+  return [
+    ...new Set(
+      origins
+        .map(normalizeOrigin)
+        .filter((origin): origin is string => Boolean(origin))
+    )
+  ];
+}
+
+function resolveCorsOrigin() {
+  const configuredOrigins = parseOrigins(process.env.CORS_ORIGIN);
+
+  if (configuredOrigins.includes("*")) {
+    return true;
+  }
+
+  return uniqueOrigins([
+    ...configuredOrigins,
+    clientOrigin,
+    mainClientOrigin,
+    ...localDevOrigins,
+    ...deployedOrigins
+  ]);
+}
+
+export const env = {
+  host,
+  port: Number.isNaN(rawPort) ? 4000 : rawPort,
+  clientOrigin,
+  mainClientOrigin,
+  corsOrigin: resolveCorsOrigin(),
+  googleClientId: process.env.GOOGLE_CLIENT_ID,
+  mongoDbName: process.env.MONGODB_DB ?? "visionos",
+  mongoUri: process.env.MONGODB_URI
+};