visionos-monorepo 0.1.0

package/.claude/worktrees/competent-burnell-8d1330/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "visionos-monorepo",
+  "version": "0.1.0",
+  "private": true,
+  "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"
+  }
+}

package/.claude/worktrees/competent-burnell-8d1330/server/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "@visionos/server",
+  "version": "0.1.0",
+  "private": true,
+  "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"
+  },
+  "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/.claude/worktrees/competent-burnell-8d1330/server/src/app.ts

@@ -0,0 +1,71 @@
+import path from "node:path";
+import cors from "cors";
+import express from "express";
+import { env } from "./config/env.js";
+import { createAuthRouter, type CreateAuthRouterOptions } from "./routes/auth.js";
+import { healthRouter } from "./routes/health.js";
+
+export interface CreateAppOptions extends CreateAuthRouterOptions {
+  apiBaseUrl?: string;
+  clientOrigin?: string;
+  corsOrigin?: string;
+  mode?: "development" | "embedded";
+  staticSiteDir?: string;
+}
+
+export function createApp(options: CreateAppOptions = {}) {
+  const app = express();
+  const clientOrigin = options.clientOrigin ?? env.clientOrigin;
+  const corsOrigin = options.corsOrigin ?? env.corsOrigin;
+  const apiBaseUrl = options.apiBaseUrl ?? `http://${env.host}:${env.port}`;
+  const authRouter = createAuthRouter({
+    clientOrigin,
+    getCurrentUser: options.getCurrentUser,
+    onAuthenticated: options.onAuthenticated
+  });
+
+  app.use(
+    cors({
+      origin: corsOrigin
+    })
+  );
+  app.use(express.json());
+  app.use(express.urlencoded({ extended: true }));
+
+  app.use("/auth", authRouter);
+  app.use("/health", healthRouter);
+
+  app.get("/runtime/info", (_req, res) => {
+    res.status(200).json({
+      runtime: {
+        appUrl: clientOrigin,
+        apiBaseUrl,
+        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) => {
+    const message = error instanceof Error ? error.message : "Unexpected VisionOS server error.";
+
+    res.status(500).json({
+      message
+    });
+  });
+
+  return app;
+}

package/.claude/worktrees/competent-burnell-8d1330/server/src/config/env.ts

@@ -0,0 +1,14 @@
+import dotenv from "dotenv";
+
+dotenv.config();
+
+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";
+
+export const env = {
+  host,
+  port: Number.isNaN(rawPort) ? 4000 : rawPort,
+  clientOrigin,
+  corsOrigin: process.env.CORS_ORIGIN ?? clientOrigin
+};

package/.claude/worktrees/competent-burnell-8d1330/server/src/features/auth/sessionStore.ts

@@ -0,0 +1,74 @@
+import { randomUUID } from "node:crypto";
+import {
+  CLI_AUTH_POLL_INTERVAL_MS,
+  CLI_AUTH_SESSION_TTL_MS,
+  type CliAuthSession,
+  type CreateCliAuthSessionResponse,
+  type LearnerIdentity,
+  type LearningTrackId
+} from "../../../../shared/src/index.js";
+
+export class InMemoryCliAuthSessionStore {
+  private readonly sessions = new Map<string, CliAuthSession>();
+
+  constructor(private readonly clientOrigin: string) {}
+
+  createSession(trackId: LearningTrackId): CreateCliAuthSessionResponse {
+    const createdAt = new Date();
+    const session: CliAuthSession = {
+      sessionId: randomUUID(),
+      trackId,
+      status: "pending",
+      createdAt: createdAt.toISOString(),
+      expiresAt: new Date(createdAt.getTime() + CLI_AUTH_SESSION_TTL_MS).toISOString()
+    };
+
+    this.sessions.set(session.sessionId, session);
+
+    return {
+      session,
+      browserUrl: new URL(`/?cliAuthSession=${session.sessionId}`, this.clientOrigin).toString(),
+      pollIntervalMs: CLI_AUTH_POLL_INTERVAL_MS
+    };
+  }
+
+  getSession(sessionId: string): CliAuthSession | undefined {
+    const session = this.sessions.get(sessionId);
+
+    if (!session) {
+      return undefined;
+    }
+
+    if (session.status === "pending" && Date.now() >= Date.parse(session.expiresAt)) {
+      const expiredSession: CliAuthSession = {
+        ...session,
+        status: "expired"
+      };
+
+      this.sessions.set(sessionId, expiredSession);
+
+      return expiredSession;
+    }
+
+    return session;
+  }
+
+  completeSession(sessionId: string, learner: LearnerIdentity): CliAuthSession | undefined {
+    const session = this.getSession(sessionId);
+
+    if (!session || session.status !== "pending") {
+      return session;
+    }
+
+    const authenticatedSession: CliAuthSession = {
+      ...session,
+      status: "authenticated",
+      authenticatedAt: new Date().toISOString(),
+      learner
+    };
+
+    this.sessions.set(sessionId, authenticatedSession);
+
+    return authenticatedSession;
+  }
+}

package/.claude/worktrees/competent-burnell-8d1330/server/src/index.ts

@@ -0,0 +1,8 @@
+import { createApp } from "./app.js";
+import { env } from "./config/env.js";
+
+const app = createApp();
+
+app.listen(env.port, env.host, () => {
+  console.log(`VisionOS server listening on http://${env.host}:${env.port}`);
+});

package/.claude/worktrees/competent-burnell-8d1330/server/src/routes/auth.ts

@@ -0,0 +1,112 @@
+import { Router } from "express";
+import {
+  type CliAuthSession,
+  type CompleteCliAuthSessionRequest,
+  type CreateCliAuthSessionRequest,
+  LEARNING_TRACKS,
+  type LearnerIdentity,
+  type LearningTrackId
+} from "../../../shared/src/index.js";
+import { env } from "../config/env.js";
+import { InMemoryCliAuthSessionStore } from "../features/auth/sessionStore.js";
+
+const emailPattern = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+
+function isLearningTrackId(value: unknown): value is LearningTrackId {
+  return typeof value === "string" && LEARNING_TRACKS.some((track) => track.id === value);
+}
+
+export interface CreateAuthRouterOptions {
+  clientOrigin?: string;
+  getCurrentUser?: () => Promise<LearnerIdentity | null> | LearnerIdentity | null;
+  onAuthenticated?: (session: CliAuthSession) => Promise<void> | void;
+}
+
+export function createAuthRouter(options: CreateAuthRouterOptions = {}) {
+  const router = Router();
+  const cliAuthSessionStore = new InMemoryCliAuthSessionStore(options.clientOrigin ?? env.clientOrigin);
+
+  router.get("/me", async (_req, res, next) => {
+    try {
+      const user = (await options.getCurrentUser?.()) ?? null;
+
+      return res.status(200).json({ user });
+    } catch (error) {
+      return next(error);
+    }
+  });
+
+  router.post("/cli/sessions", (req, res) => {
+    const body = req.body as Partial<CreateCliAuthSessionRequest>;
+
+    if (!isLearningTrackId(body.trackId)) {
+      return res.status(400).json({
+        message: "A valid learning track is required to start browser authentication."
+      });
+    }
+
+    return res.status(201).json(cliAuthSessionStore.createSession(body.trackId));
+  });
+
+  router.get("/cli/sessions/:sessionId", (req, res) => {
+    const session = cliAuthSessionStore.getSession(req.params.sessionId);
+
+    if (!session) {
+      return res.status(404).json({
+        message: "Auth session not found."
+      });
+    }
+
+    return res.status(200).json({ session });
+  });
+
+  router.post("/cli/sessions/:sessionId/complete", async (req, res, next) => {
+    try {
+      const session = cliAuthSessionStore.getSession(req.params.sessionId);
+
+      if (!session) {
+        return res.status(404).json({
+          message: "Auth session not found."
+        });
+      }
+
+      if (session.status === "expired") {
+        return res.status(410).json({
+          message: "Auth session expired.",
+          session
+        });
+      }
+
+      if (session.status === "authenticated") {
+        return res.status(200).json({ session });
+      }
+
+      const body = req.body as Partial<CompleteCliAuthSessionRequest>;
+      const learnerName = body.learnerName?.trim();
+      const learnerEmail = body.learnerEmail?.trim().toLowerCase();
+
+      if (!learnerName || !learnerEmail || !emailPattern.test(learnerEmail)) {
+        return res.status(400).json({
+          message: "A learner name and valid email address are required to complete sign-in."
+        });
+      }
+
+      const authenticatedSession = cliAuthSessionStore.completeSession(req.params.sessionId, {
+        name: learnerName,
+        email: learnerEmail
+      });
+
+      if (authenticatedSession) {
+        await options.onAuthenticated?.(authenticatedSession);
+      }
+
+      return res.status(200).json({ session: authenticatedSession });
+    } catch (error) {
+      return next(error);
+    }
+  });
+
+  return router;
+}
+
+export const authRouter = createAuthRouter();

package/.claude/worktrees/competent-burnell-8d1330/server/src/routes/health.ts

@@ -0,0 +1,14 @@
+import { Router } from "express";
+import { APP_NAME, APP_VERSION } from "../../../shared/src/index.js";
+
+export const healthRouter = Router();
+
+healthRouter.get("/", (_req, res) => {
+  res.status(200).json({
+    status: "ok",
+    service: APP_NAME,
+    version: APP_VERSION,
+    timestamp: new Date().toISOString()
+  });
+});
+

package/.claude/worktrees/competent-burnell-8d1330/server/tsconfig.json

@@ -0,0 +1,19 @@
+{
+  "extends": "../tsconfig.base.json",
+  "compilerOptions": {
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "lib": [
+      "ES2022"
+    ],
+    "types": [
+      "node"
+    ],
+    "noEmit": true
+  },
+  "include": [
+    "src/**/*.ts",
+    "../shared/src/**/*.ts"
+  ]
+}
+

package/.claude/worktrees/competent-burnell-8d1330/shared/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "@visionos/shared",
+  "version": "0.1.0",
+  "private": true,
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts --clean",
+    "dev": "tsup src/index.ts --format esm --dts --watch",
+    "lint": "tsc --noEmit -p tsconfig.json"
+  },
+  "devDependencies": {
+    "tsup": "^8.3.0",
+    "typescript": "^5.6.3"
+  }
+}
+

package/.claude/worktrees/competent-burnell-8d1330/shared/src/index.ts

@@ -0,0 +1,91 @@
+export const APP_NAME = "VisionOS";
+export const APP_VERSION = "0.1.0";
+
+export type LearningTrackId = "git" | "linux" | "react-cli" | "os-commands";
+
+export interface LearningTrack {
+  id: LearningTrackId;
+  label: string;
+  description: string;
+}
+
+export interface LearnerIdentity {
+  name: string;
+  email: string;
+}
+
+export interface VisionOsUserProfile extends LearnerIdentity {
+  sessionId: string;
+  trackId: LearningTrackId;
+  authenticatedAt: string;
+}
+
+export type CliAuthSessionStatus = "pending" | "authenticated" | "expired";
+
+export interface CliAuthSession {
+  sessionId: string;
+  trackId: LearningTrackId;
+  status: CliAuthSessionStatus;
+  createdAt: string;
+  expiresAt: string;
+  authenticatedAt?: string;
+  learner?: LearnerIdentity;
+}
+
+export interface CliAuthSessionEnvelope {
+  session: CliAuthSession;
+}
+
+export interface CreateCliAuthSessionRequest {
+  trackId: LearningTrackId;
+}
+
+export interface CreateCliAuthSessionResponse extends CliAuthSessionEnvelope {
+  browserUrl: string;
+  pollIntervalMs: number;
+}
+
+export interface CompleteCliAuthSessionRequest {
+  learnerName: string;
+  learnerEmail: string;
+}
+
+export interface VisionOsUserInfoResponse {
+  user: VisionOsUserProfile | null;
+}
+
+export interface VisionOsRuntimeInfo {
+  appUrl: string;
+  apiBaseUrl: string;
+  mode: "development" | "embedded";
+}
+
+export interface VisionOsRuntimeInfoResponse {
+  runtime: VisionOsRuntimeInfo;
+}
+
+export const CLI_AUTH_POLL_INTERVAL_MS = 1_500;
+export const CLI_AUTH_SESSION_TTL_MS = 10 * 60 * 1_000;
+
+export const LEARNING_TRACKS: LearningTrack[] = [
+  {
+    id: "git",
+    label: "Git",
+    description: "Learn branching, commits, rebasing, and collaboration commands."
+  },
+  {
+    id: "linux",
+    label: "Linux",
+    description: "Build confidence with filesystem navigation, permissions, and shell basics."
+  },
+  {
+    id: "react-cli",
+    label: "React CLI",
+    description: "Practice project scaffolding, package scripts, and frontend workflows."
+  },
+  {
+    id: "os-commands",
+    label: "OS Commands",
+    description: "Train with practical day-to-day terminal commands across common environments."
+  }
+];

package/.claude/worktrees/competent-burnell-8d1330/shared/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "extends": "../tsconfig.base.json",
+  "compilerOptions": {
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "lib": [
+      "ES2022"
+    ],
+    "declaration": true,
+    "noEmit": true
+  },
+  "include": [
+    "src/**/*.ts"
+  ]
+}
+

package/.claude/worktrees/competent-burnell-8d1330/tsconfig.base.json

@@ -0,0 +1,12 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "strict": true,
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "skipLibCheck": true,
+    "resolveJsonModule": true,
+    "allowSyntheticDefaultImports": true
+  }
+}
+