visionos-monorepo 0.1.0

package/.claude/worktrees/competent-burnell-8d1330/cli/src/lib/runtime.ts

@@ -0,0 +1,203 @@
+import fs from "node:fs/promises";
+import net from "node:net";
+import path from "node:path";
+import { spawn } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import { type VisionOsRuntimeInfo } from "../../../shared/src/index.js";
+import { clearRuntimeState, readRuntimeState, type VisionOsRuntimeState, writeRuntimeState } from "./localState.js";
+
+const runtimeHost = "127.0.0.1";
+const runtimeStartTimeoutMs = 10_000;
+
+async function fileExists(filePath: string) {
+  try {
+    await fs.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function resolveRuntimeScriptPath() {
+  const currentDir = path.dirname(fileURLToPath(import.meta.url));
+  const candidatePaths = [
+    path.resolve(currentDir, "runtime/index.js"),
+    path.resolve(currentDir, "../runtime/index.js")
+  ];
+
+  for (const candidatePath of candidatePaths) {
+    if (await fileExists(candidatePath)) {
+      return candidatePath;
+    }
+  }
+
+  throw new Error(
+    "The embedded VisionOS runtime is not built yet. Run `npm run build` from the repository root before packaging or local CLI testing."
+  );
+}
+
+function delay(ms: number) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function normalizeUrl(url: string) {
+  return url.replace(/\/$/, "");
+}
+
+async function findAvailablePort() {
+  return new Promise<number>((resolve, reject) => {
+    const server = net.createServer();
+
+    server.once("error", reject);
+    server.listen(0, runtimeHost, () => {
+      const address = server.address();
+
+      if (!address || typeof address === "string") {
+        reject(new Error("Unable to resolve a local port for the VisionOS runtime."));
+        return;
+      }
+
+      const { port } = address;
+
+      server.close((error) => {
+        if (error) {
+          reject(error);
+          return;
+        }
+
+        resolve(port);
+      });
+    });
+  });
+}
+
+async function isRuntimeHealthy(runtime: VisionOsRuntimeInfo) {
+  try {
+    const response = await fetch(`${normalizeUrl(runtime.apiBaseUrl)}/health`);
+
+    return response.ok;
+  } catch {
+    return false;
+  }
+}
+
+async function waitForRuntime(apiBaseUrl: string) {
+  const startedAt = Date.now();
+
+  while (Date.now() - startedAt < runtimeStartTimeoutMs) {
+    if (await isRuntimeHealthy({ apiBaseUrl, appUrl: apiBaseUrl, mode: "embedded" })) {
+      return;
+    }
+
+    await delay(250);
+  }
+
+  throw new Error("VisionOS runtime did not become healthy in time.");
+}
+
+function isProcessAlive(pid: number) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function getExternalRuntimeInfo(): VisionOsRuntimeInfo | null {
+  const apiBaseUrl = process.env.VISIONOS_API_URL?.trim();
+
+  if (!apiBaseUrl) {
+    return null;
+  }
+
+  const normalizedApiBaseUrl = normalizeUrl(apiBaseUrl);
+
+  return {
+    apiBaseUrl: normalizedApiBaseUrl,
+    appUrl: normalizeUrl(process.env.VISIONOS_WEB_URL?.trim() || normalizedApiBaseUrl),
+    mode: "development"
+  };
+}
+
+async function spawnRuntimeProcess() {
+  const runtimeScriptPath = await resolveRuntimeScriptPath();
+  const runtimeDir = path.dirname(runtimeScriptPath);
+  const webDistPath = path.resolve(runtimeDir, "../web");
+  const port = await findAvailablePort();
+  const appUrl = `http://${runtimeHost}:${port}`;
+
+  const child = spawn(process.execPath, [runtimeScriptPath], {
+    detached: true,
+    env: {
+      ...process.env,
+      HOST: runtimeHost,
+      PORT: String(port),
+      CLIENT_ORIGIN: appUrl,
+      CORS_ORIGIN: appUrl,
+      VISIONOS_WEB_DIST: webDistPath,
+      VISIONOS_RUNTIME_MODE: "embedded"
+    },
+    stdio: "ignore"
+  });
+
+  child.unref();
+
+  await waitForRuntime(appUrl);
+
+  const runtimeState: VisionOsRuntimeState = {
+    apiBaseUrl: appUrl,
+    appUrl,
+    host: runtimeHost,
+    mode: "embedded",
+    pid: child.pid ?? -1,
+    port,
+    startedAt: new Date().toISOString()
+  };
+
+  await writeRuntimeState(runtimeState);
+
+  return runtimeState;
+}
+
+export async function ensureVisionOsRuntime(): Promise<VisionOsRuntimeInfo> {
+  const externalRuntime = getExternalRuntimeInfo();
+
+  if (externalRuntime) {
+    return externalRuntime;
+  }
+
+  const savedRuntime = await readRuntimeState();
+
+  if (savedRuntime && isProcessAlive(savedRuntime.pid) && (await isRuntimeHealthy(savedRuntime))) {
+    return savedRuntime;
+  }
+
+  if (savedRuntime) {
+    await clearRuntimeState();
+  }
+
+  return spawnRuntimeProcess();
+}
+
+export async function getVisionOsRuntimeStatus() {
+  const runtime = await readRuntimeState();
+
+  if (!runtime) {
+    return {
+      isRunning: false,
+      runtime: null as VisionOsRuntimeState | null
+    };
+  }
+
+  const isRunning = isProcessAlive(runtime.pid) && (await isRuntimeHealthy(runtime));
+
+  if (!isRunning) {
+    await clearRuntimeState();
+  }
+
+  return {
+    isRunning,
+    runtime: isRunning ? runtime : null
+  };
+}

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

@@ -0,0 +1,36 @@
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { createApp } from "../../../server/src/app.js";
+import { writeUserProfile, readUserProfile } from "../lib/localState.js";
+
+const host = process.env.HOST ?? "127.0.0.1";
+const port = Number(process.env.PORT ?? 4173);
+const appUrl = process.env.CLIENT_ORIGIN ?? `http://${host}:${port}`;
+const currentDir = path.dirname(fileURLToPath(import.meta.url));
+const staticSiteDir = process.env.VISIONOS_WEB_DIST ?? path.resolve(currentDir, "../web");
+
+const app = createApp({
+  apiBaseUrl: appUrl,
+  clientOrigin: appUrl,
+  corsOrigin: appUrl,
+  getCurrentUser: readUserProfile,
+  mode: "embedded",
+  onAuthenticated: async (session) => {
+    if (!session.learner || !session.authenticatedAt) {
+      return;
+    }
+
+    await writeUserProfile({
+      authenticatedAt: session.authenticatedAt,
+      email: session.learner.email,
+      name: session.learner.name,
+      sessionId: session.sessionId,
+      trackId: session.trackId
+    });
+  },
+  staticSiteDir
+});
+
+app.listen(port, host, () => {
+  console.log(`VisionOS embedded runtime listening on ${appUrl}`);
+});

package/.claude/worktrees/competent-burnell-8d1330/cli/src/types/inquirer.d.ts

@@ -0,0 +1,9 @@
+declare module "inquirer" {
+  interface InquirerModule {
+    prompt<T>(questions: unknown[]): Promise<T>;
+  }
+
+  const inquirer: InquirerModule;
+
+  export default inquirer;
+}

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

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

package/.claude/worktrees/competent-burnell-8d1330/client/index.html

@@ -0,0 +1,15 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <meta name="description" content="VisionOS — A CLI-first terminal learning platform. Practice real commands with guided lessons." />
+    <title>VisionOS — Terminal Learning Platform</title>
+    <link rel="preconnect" href="https://fonts.googleapis.com" />
+    <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
+  </head>
+  <body style="background:#E0DFD5; margin:0;">
+    <div id="root"></div>
+    <script type="module" src="/src/main.tsx"></script>
+  </body>
+</html>

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

@@ -0,0 +1,27 @@
+{
+  "name": "@visionos/client",
+  "version": "0.1.0",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "build": "tsc --noEmit && vite build",
+    "dev": "vite",
+    "lint": "tsc --noEmit",
+    "preview": "vite preview"
+  },
+  "dependencies": {
+    "react": "^18.3.1",
+    "react-dom": "^18.3.1"
+  },
+  "devDependencies": {
+    "@types/react": "^18.3.12",
+    "@types/react-dom": "^18.3.1",
+    "@vitejs/plugin-react": "^4.3.3",
+    "autoprefixer": "^10.4.20",
+    "postcss": "^8.4.49",
+    "tailwindcss": "^3.4.14",
+    "typescript": "^5.6.3",
+    "vite": "^5.4.10"
+  }
+}
+

package/.claude/worktrees/competent-burnell-8d1330/client/postcss.config.cjs

@@ -0,0 +1,7 @@
+module.exports = {
+  plugins: {
+    tailwindcss: {},
+    autoprefixer: {}
+  }
+};
+

package/.claude/worktrees/competent-burnell-8d1330/client/src/App.tsx

@@ -0,0 +1,57 @@
+import { useEffect, useState } from "react";
+import { type VisionOsRuntimeInfo, type VisionOsUserProfile } from "../../shared/src/index.js";
+import { CliAuthPage } from "./components/CliAuthPage.js";
+import { ManifestoPage } from "./components/ManifestoPage.js";
+import { getCurrentUser, getRuntimeInfo, VisionOsApiError } from "./lib/api.js";
+
+export default function App() {
+  const cliAuthSessionId = new URLSearchParams(window.location.search).get("cliAuthSession");
+  const [user, setUser] = useState<VisionOsUserProfile | null>(null);
+  const [_runtime, setRuntime] = useState<VisionOsRuntimeInfo | null>(null);
+  const [_errorMessage, setErrorMessage] = useState<string | null>(null);
+
+  useEffect(() => {
+    let cancelled = false;
+
+    async function loadHomeState() {
+      try {
+        const [userResponse, runtimeResponse] = await Promise.all([getCurrentUser(), getRuntimeInfo()]);
+
+        if (cancelled) {
+          return;
+        }
+
+        setUser(userResponse.user);
+        setRuntime(runtimeResponse.runtime);
+      } catch (error) {
+        if (cancelled) {
+          return;
+        }
+
+        if (error instanceof VisionOsApiError) {
+          setErrorMessage(error.message);
+        } else if (error instanceof Error) {
+          setErrorMessage(error.message);
+        } else {
+          setErrorMessage("Unable to load VisionOS runtime details.");
+        }
+      }
+    }
+
+    if (!cliAuthSessionId) {
+      void loadHomeState();
+    }
+
+    return () => {
+      cancelled = true;
+    };
+  }, [cliAuthSessionId]);
+
+  // CLI Auth flow → dedicated auth page
+  if (cliAuthSessionId) {
+    return <CliAuthPage sessionId={cliAuthSessionId} />;
+  }
+
+  // Main manifesto landing page
+  return <ManifestoPage user={user} />;
+}