@tscircuit/cli 0.1.4 → 0.1.5

package/biome.json

@@ -32,6 +32,7 @@
         "noForEach": "off"
       },
       "style": {
+        "noUnusedTemplateLiteral": "off",
         "noUselessElse": "off",
         "noNonNullAssertion": "off",
         "useNumberNamespace": "off",

package/cli/dev/DevServer.ts

@@ -0,0 +1,155 @@
+import ky from "ky"
+import type { FileServerRoutes } from "lib/file-server/FileServerRoutes"
+import { createHttpServer } from "lib/server/createHttpServer"
+import { EventsWatcher } from "lib/server/EventsWatcher"
+import type http from "node:http"
+import type { TypedKyInstance } from "typed-ky"
+import path from "node:path"
+import fs from "node:fs"
+import type { FileUpdatedEvent } from "lib/file-server/FileServerEvent"
+import * as chokidar from "chokidar"
+
+export class DevServer {
+  port: number
+  /**
+   * The path to a component that exports a <board /> or <group /> component
+   */
+  componentFilePath: string
+
+  projectDir: string
+
+  /**
+   * The HTTP server that hosts the file server and event bus. You can use
+   * fsKy to communicate with the file server/event bus
+   */
+  httpServer?: http.Server
+  /**
+   * Watches for events on the event bus by polling `api/events/list`
+   */
+  eventsWatcher?: EventsWatcher
+  /**
+   * A ky instance that can be used to communicate with the file server and
+   * event bus
+   */
+  fsKy: TypedKyInstance<keyof FileServerRoutes, FileServerRoutes>
+  /**
+   * A chokidar instance that watches the project directory for file changes
+   */
+  filesystemWatcher?: chokidar.FSWatcher
+
+  constructor({
+    port,
+    componentFilePath,
+  }: {
+    port: number
+    componentFilePath: string
+  }) {
+    this.port = port
+    this.componentFilePath = componentFilePath
+    this.projectDir = path.dirname(componentFilePath)
+    this.fsKy = ky.create({
+      prefixUrl: `http://localhost:${port}`,
+    }) as any
+  }
+
+  async start() {
+    const { server } = await createHttpServer(this.port)
+    this.httpServer = server
+
+    this.eventsWatcher = new EventsWatcher(`http://localhost:${this.port}`)
+    this.eventsWatcher.start()
+
+    this.eventsWatcher.on(
+      "FILE_UPDATED",
+      this.handleFileUpdatedEventFromServer.bind(this),
+    )
+
+    this.filesystemWatcher = chokidar.watch(this.projectDir, {
+      persistent: true,
+      ignoreInitial: true,
+    })
+
+    this.filesystemWatcher.on("change", (filePath) =>
+      this.handleFileChangedOnFilesystem(filePath),
+    )
+    this.filesystemWatcher.on("add", (filePath) =>
+      this.handleFileChangedOnFilesystem(filePath),
+    )
+
+    this.upsertInitialFiles()
+  }
+
+  async addEntrypoint() {
+    const relativeComponentFilePath = path.relative(
+      this.projectDir,
+      this.componentFilePath,
+    )
+    await this.fsKy.post("api/files/upsert", {
+      json: {
+        file_path: "entrypoint.tsx",
+        text_content: `
+import MyCircuit from "./${relativeComponentFilePath}"
+
+circuit.add(<MyCircuit />)
+`,
+      },
+    })
+  }
+
+  async handleFileUpdatedEventFromServer(ev: FileUpdatedEvent) {
+    if (ev.initiator === "filesystem_change") return
+
+    if (ev.file_path === "manual-edits.json") {
+      console.log("Manual edits updated, updating on filesystem...")
+      const { file } = await this.fsKy
+        .get("api/files/get", {
+          searchParams: { file_path: ev.file_path },
+        })
+        .json()
+      fs.writeFileSync(
+        path.join(this.projectDir, "manual-edits.json"),
+        file.text_content,
+      )
+    }
+  }
+
+  async handleFileChangedOnFilesystem(absoluteFilePath: string) {
+    const relativeFilePath = path.relative(this.projectDir, absoluteFilePath)
+
+    // We've temporarily disabled upserting manual edits from filesystem changes
+    // because it can be edited by the browser
+    if (relativeFilePath.includes("manual-edits.json")) return
+
+    await this.fsKy
+      .post("api/files/upsert", {
+        json: {
+          file_path: relativeFilePath,
+          text_content: fs.readFileSync(absoluteFilePath, "utf-8"),
+          initiator: "filesystem_change",
+        },
+      })
+      .json()
+  }
+
+  async upsertInitialFiles() {
+    // Scan project directory for all files and upsert them
+    const fileNames = fs.readdirSync(this.projectDir)
+    for (const fileName of fileNames) {
+      await this.fsKy.post("api/files/upsert", {
+        json: {
+          file_path: fileName,
+          text_content: fs.readFileSync(
+            path.join(this.projectDir, fileName),
+            "utf-8",
+          ),
+          initiator: "filesystem_change",
+        },
+      })
+    }
+  }
+
+  async stop() {
+    this.httpServer?.close()
+    this.eventsWatcher?.stop()
+  }
+}

package/cli/dev/register.ts

@@ -2,10 +2,11 @@ import type { Command } from "commander"
 import * as path from "node:path"
 import * as chokidar from "chokidar"
 import * as fs from "node:fs"
-import { createServer } from "lib/server/createServer"
+import { createHttpServer } from "lib/server/createHttpServer"
 import { getLocalFileDependencies } from "lib/dependency-analysis/getLocalFileDependencies"
-import { installTypes } from "../../lib/dependency-analysis/installNodeModuleTypes"
+import { installNodeModuleTypesForSnippet } from "../../lib/dependency-analysis/installNodeModuleTypesForSnippet"
 import { EventsWatcher } from "../../lib/server/EventsWatcher"
+import { DevServer } from "./DevServer"
 
 export const registerDev = (program: Command) => {
   program
@@ -20,92 +21,18 @@ export const registerDev = (program: Command) => {
 
       try {
         console.log("Installing types for imported snippets...")
-        await installTypes(absolutePath)
+        await installNodeModuleTypesForSnippet(absolutePath)
         console.log("Types installed successfully")
       } catch (error) {
         console.warn("Failed to install types:", error)
       }
 
-      // Start the server
-      await createServer(port)
-
-      const eventsWatcher = new EventsWatcher(`http://localhost:${port}`)
-      eventsWatcher.start()
-
-      await fetch(`http://localhost:${port}/api/files/upsert`, {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({
-          file_path: "entrypoint.tsx",
-          text_content: `
-import MyCircuit from "./snippet.tsx"
-
-circuit.add(<MyCircuit />)
-`,
-        }),
-      })
-
-      // Function to update file content
-      const updateFile = async (filePath: string) => {
-        try {
-          const content = await fs.promises.readFile(filePath, "utf-8")
-          const response = await fetch(
-            `http://localhost:${port}/api/files/upsert`,
-            {
-              method: "POST",
-              headers: { "Content-Type": "application/json" },
-              body: JSON.stringify({
-                file_path: path.relative(fileDir, filePath),
-                text_content: content,
-              }),
-            },
-          )
-          if (!response.ok) {
-            console.error(`Failed to update ${filePath}`)
-          }
-        } catch (error) {
-          console.error(`Error updating ${filePath}:`, error)
-        }
-      }
-
-      // Get initial dependencies
-      const dependencies = new Set([absolutePath])
-      try {
-        const deps = getLocalFileDependencies(absolutePath)
-        deps.forEach((dep) => dependencies.add(dep))
-      } catch (error) {
-        console.warn("Failed to analyze dependencies:", error)
-      }
-
-      // Watch the main file and its dependencies
-      const filesystemWatcher = chokidar.watch(Array.from(dependencies), {
-        persistent: true,
-        ignoreInitial: false,
-      })
-
-      filesystemWatcher.on("change", async (filePath) => {
-        console.log(`File ${filePath} changed`)
-        await updateFile(filePath)
-      })
-
-      filesystemWatcher.on("add", async (filePath) => {
-        console.log(`File ${filePath} added`)
-        await updateFile(filePath)
-      })
-
-      eventsWatcher.on("FILE_UPDATED", async (ev) => {
-        if (ev.file_path === "manual-edits.json") {
-          console.log("Manual edits updated, updating on filesystem...")
-          const { file } = await fetch(
-            `http://localhost:${port}/api/files/get?file_path=manual-edits.json`,
-          ).then((r) => r.json())
-          fs.writeFileSync(
-            path.join(fileDir, "manual-edits.json"),
-            file.text_content,
-          )
-        }
+      const server = new DevServer({
+        port,
+        componentFilePath: absolutePath,
       })
 
-      console.log(`Watching ${file} and its dependencies...`)
+      await server.start()
+      await server.addEntrypoint()
     })
 }

package/dist/main.js

@@ -5,13 +5,74 @@ import { Command } from "commander";
 
 // cli/dev/register.ts
 import * as path4 from "node:path";
-import * as chokidar from "chokidar";
-import * as fs4 from "node:fs";
 
-// lib/server/createServer.ts
-import * as http from "node:http";
+// lib/dependency-analysis/installNodeModuleTypesForSnippet.ts
 import * as fs from "node:fs";
 import * as path from "node:path";
+import * as ts from "typescript";
+async function installNodeModuleTypesForSnippet(snippetPath) {
+  const content = fs.readFileSync(snippetPath, "utf-8");
+  const sourceFile = ts.createSourceFile(
+    snippetPath,
+    content,
+    ts.ScriptTarget.Latest,
+    true
+  );
+  const imports = [];
+  function visit(node) {
+    if (ts.isImportDeclaration(node)) {
+      const moduleSpecifier = node.moduleSpecifier;
+      if (moduleSpecifier && ts.isStringLiteral(moduleSpecifier)) {
+        const importPath = moduleSpecifier.text;
+        if (importPath.startsWith("@tsci/")) {
+          imports.push(importPath);
+        }
+      }
+    }
+    ts.forEachChild(node, visit);
+  }
+  visit(sourceFile);
+  let projectRoot = path.dirname(snippetPath);
+  while (projectRoot !== path.parse(projectRoot).root) {
+    if (fs.existsSync(path.join(projectRoot, "package.json"))) {
+      break;
+    }
+    projectRoot = path.dirname(projectRoot);
+  }
+  for (const importPath of imports) {
+    const [owner, name] = importPath.replace("@tsci/", "").split(".");
+    try {
+      const response = await fetch(
+        `https://registry-api.tscircuit.com/snippets/get?owner_name=${owner}&unscoped_name=${name}`
+      );
+      if (!response.ok) {
+        console.warn(`Failed to fetch types for ${importPath}`);
+        continue;
+      }
+      const data = await response.json();
+      if (data.snippet.dts) {
+        const packageDir = path.join(
+          projectRoot,
+          "node_modules",
+          "@tsci",
+          `${owner}.${name}`
+        );
+        fs.mkdirSync(packageDir, { recursive: true });
+        fs.writeFileSync(path.join(packageDir, "index.d.ts"), data.snippet.dts);
+      }
+    } catch (error) {
+      console.warn(`Error fetching types for ${importPath}:`, error);
+    }
+  }
+}
+
+// cli/dev/DevServer.ts
+import ky from "ky";
+
+// lib/server/createHttpServer.ts
+import * as http from "node:http";
+import * as fs2 from "node:fs";
+import * as path2 from "node:path";
 import { getNodeHandler } from "winterspec/adapters/node";
 
 // package.json
@@ -19,7 +80,7 @@ var package_default = {
   name: "@tscircuit/cli",
   main: "dist/main.js",
   type: "module",
-  version: "0.1.3",
+  version: "0.1.4",
   bin: {
     tsci: "./dist/main.js"
   },
@@ -34,16 +95,19 @@ var package_default = {
   devDependencies: {
     "@biomejs/biome": "^1.9.4",
     "@tscircuit/core": "^0.0.249",
-    "@types/bun": "latest",
+    "@types/bun": "^1.1.15",
     "@types/configstore": "^6.0.2",
     "@types/react": "^19.0.1",
-    tsup: "^8.3.5"
+    "get-port": "^7.1.0",
+    tempy: "^3.1.0",
+    tsup: "^8.3.5",
+    "typed-ky": "^0.0.4"
   },
   peerDependencies: {
     typescript: "^5.0.0"
   },
   dependencies: {
-    "@tscircuit/file-server": "^0.0.11",
+    "@tscircuit/file-server": "^0.0.13",
     "@tscircuit/runframe": "^0.0.47",
     chokidar: "^4.0.1",
     commander: "^12.1.0",
@@ -55,7 +119,7 @@ var package_default = {
   }
 };
 
-// lib/server/createServer.ts
+// lib/server/createHttpServer.ts
 import winterspecBundle from "@tscircuit/file-server/dist/bundle.js";
 
 // lib/site/getIndex.ts
@@ -74,19 +138,19 @@ var getIndex = async () => {
   </html>`;
 };
 
-// lib/server/createServer.ts
-var createServer2 = async (port = 3e3) => {
+// lib/server/createHttpServer.ts
+var createHttpServer = async (port = 3e3) => {
   const fileServerHandler = getNodeHandler(winterspecBundle, {});
   const server = http.createServer(async (req, res) => {
     const url = new URL(req.url, `http://${req.headers.host}`);
     if (url.pathname === "/standalone.min.js") {
-      const standaloneFilePath = process.env.RUNFRAME_STANDALONE_FILE_PATH || path.resolve(
+      const standaloneFilePath = process.env.RUNFRAME_STANDALONE_FILE_PATH || path2.resolve(
         process.cwd(),
         "node_modules",
         "@tscircuit/runframe/dist/standalone.min.js"
       );
       try {
-        const content = fs.readFileSync(standaloneFilePath, "utf8");
+        const content = fs2.readFileSync(standaloneFilePath, "utf8");
         res.writeHead(200, {
           "Content-Type": "application/javascript; charset=utf-8"
         });
@@ -115,147 +179,14 @@ var createServer2 = async (port = 3e3) => {
     res.writeHead(404);
     res.end("Not found");
   });
-  return new Promise((resolve4) => {
+  return new Promise((resolve3) => {
     server.listen(port, () => {
       console.log(`Server running at http://localhost:${port}`);
-      resolve4();
+      resolve3({ server });
     });
   });
 };
 
-// lib/dependency-analysis/getLocalFileDependencies.ts
-import * as ts from "typescript";
-import * as path2 from "path";
-import * as fs2 from "fs";
-function getLocalFileDependencies(pathToTsxFile) {
-  const absolutePath = path2.resolve(pathToTsxFile);
-  const baseDir = path2.dirname(absolutePath);
-  const content = fs2.readFileSync(absolutePath, "utf-8");
-  const sourceFile = ts.createSourceFile(
-    absolutePath,
-    content,
-    ts.ScriptTarget.Latest,
-    true
-  );
-  const dependencies = /* @__PURE__ */ new Set();
-  function visit(node) {
-    if (ts.isImportDeclaration(node) || ts.isExportDeclaration(node)) {
-      const moduleSpecifier = node.moduleSpecifier;
-      if (moduleSpecifier && ts.isStringLiteral(moduleSpecifier)) {
-        const importPath = moduleSpecifier.text;
-        if (importPath.startsWith(".")) {
-          resolveAndAddDependency(importPath);
-        }
-      }
-    }
-    if (ts.isCallExpression(node) && node.expression.kind === ts.SyntaxKind.ImportKeyword) {
-      const argument = node.arguments[0];
-      if (argument && ts.isStringLiteral(argument)) {
-        const importPath = argument.text;
-        if (importPath.startsWith(".")) {
-          resolveAndAddDependency(importPath);
-        }
-      }
-    }
-    ts.forEachChild(node, visit);
-  }
-  function resolveAndAddDependency(importPath) {
-    const extensions = [
-      ".tsx",
-      ".ts",
-      ".jsx",
-      ".js",
-      ".css",
-      ".scss",
-      ".sass",
-      ".less"
-    ];
-    let resolvedPath = path2.resolve(baseDir, importPath);
-    if (fs2.existsSync(resolvedPath)) {
-      dependencies.add(resolvedPath);
-      return;
-    }
-    for (const ext of extensions) {
-      const pathWithExt = resolvedPath + ext;
-      if (fs2.existsSync(pathWithExt)) {
-        dependencies.add(pathWithExt);
-        return;
-      }
-    }
-    if (fs2.existsSync(resolvedPath) && fs2.statSync(resolvedPath).isDirectory()) {
-      for (const ext of extensions) {
-        const indexPath = path2.join(resolvedPath, `index${ext}`);
-        if (fs2.existsSync(indexPath)) {
-          dependencies.add(indexPath);
-          return;
-        }
-      }
-    }
-  }
-  visit(sourceFile);
-  return Array.from(dependencies);
-}
-
-// lib/dependency-analysis/installNodeModuleTypes.ts
-import * as fs3 from "node:fs";
-import * as path3 from "node:path";
-import * as ts2 from "typescript";
-async function installTypes(snippetPath) {
-  const content = fs3.readFileSync(snippetPath, "utf-8");
-  const sourceFile = ts2.createSourceFile(
-    snippetPath,
-    content,
-    ts2.ScriptTarget.Latest,
-    true
-  );
-  const imports = [];
-  function visit(node) {
-    if (ts2.isImportDeclaration(node)) {
-      const moduleSpecifier = node.moduleSpecifier;
-      if (moduleSpecifier && ts2.isStringLiteral(moduleSpecifier)) {
-        const importPath = moduleSpecifier.text;
-        if (importPath.startsWith("@tsci/")) {
-          imports.push(importPath);
-        }
-      }
-    }
-    ts2.forEachChild(node, visit);
-  }
-  visit(sourceFile);
-  let projectRoot = path3.dirname(snippetPath);
-  while (projectRoot !== path3.parse(projectRoot).root) {
-    if (fs3.existsSync(path3.join(projectRoot, "package.json"))) {
-      break;
-    }
-    projectRoot = path3.dirname(projectRoot);
-  }
-  for (const importPath of imports) {
-    const [owner, name] = importPath.replace("@tsci/", "").split(".");
-    try {
-      const response = await fetch(
-        `https://registry-api.tscircuit.com/snippets/get?owner_name=${owner}&unscoped_name=${name}`
-      );
-      if (!response.ok) {
-        console.warn(`Failed to fetch types for ${importPath}`);
-        continue;
-      }
-      const data = await response.json();
-      if (data.snippet.dts) {
-        const packageDir = path3.join(
-          projectRoot,
-          "node_modules",
-          "@tsci",
-          `${owner}.${name}`
-        );
-        fs3.mkdirSync(packageDir, { recursive: true });
-        fs3.writeFileSync(path3.join(packageDir, "index.d.ts"), data.snippet.dts);
-      }
-    } catch (error) {
-      console.warn(`Error fetching types for ${importPath}:`, error);
-    }
-  }
-}
-
 // lib/server/EventsWatcher.ts
 import { EventEmitter } from "events";
 var EventsWatcher = class extends EventEmitter {
@@ -307,6 +238,130 @@ var EventsWatcher = class extends EventEmitter {
   }
 };
 
+// cli/dev/DevServer.ts
+import path3 from "node:path";
+import fs3 from "node:fs";
+import * as chokidar from "chokidar";
+var DevServer = class {
+  port;
+  /**
+   * The path to a component that exports a <board /> or <group /> component
+   */
+  componentFilePath;
+  projectDir;
+  /**
+   * The HTTP server that hosts the file server and event bus. You can use
+   * fsKy to communicate with the file server/event bus
+   */
+  httpServer;
+  /**
+   * Watches for events on the event bus by polling `api/events/list`
+   */
+  eventsWatcher;
+  /**
+   * A ky instance that can be used to communicate with the file server and
+   * event bus
+   */
+  fsKy;
+  /**
+   * A chokidar instance that watches the project directory for file changes
+   */
+  filesystemWatcher;
+  constructor({
+    port,
+    componentFilePath
+  }) {
+    this.port = port;
+    this.componentFilePath = componentFilePath;
+    this.projectDir = path3.dirname(componentFilePath);
+    this.fsKy = ky.create({
+      prefixUrl: `http://localhost:${port}`
+    });
+  }
+  async start() {
+    const { server } = await createHttpServer(this.port);
+    this.httpServer = server;
+    this.eventsWatcher = new EventsWatcher(`http://localhost:${this.port}`);
+    this.eventsWatcher.start();
+    this.eventsWatcher.on(
+      "FILE_UPDATED",
+      this.handleFileUpdatedEventFromServer.bind(this)
+    );
+    this.filesystemWatcher = chokidar.watch(this.projectDir, {
+      persistent: true,
+      ignoreInitial: true
+    });
+    this.filesystemWatcher.on(
+      "change",
+      (filePath) => this.handleFileChangedOnFilesystem(filePath)
+    );
+    this.filesystemWatcher.on(
+      "add",
+      (filePath) => this.handleFileChangedOnFilesystem(filePath)
+    );
+    this.upsertInitialFiles();
+  }
+  async addEntrypoint() {
+    const relativeComponentFilePath = path3.relative(
+      this.projectDir,
+      this.componentFilePath
+    );
+    await this.fsKy.post("api/files/upsert", {
+      json: {
+        file_path: "entrypoint.tsx",
+        text_content: `
+import MyCircuit from "./${relativeComponentFilePath}"
+
+circuit.add(<MyCircuit />)
+`
+      }
+    });
+  }
+  async handleFileUpdatedEventFromServer(ev) {
+    if (ev.initiator === "filesystem_change") return;
+    if (ev.file_path === "manual-edits.json") {
+      console.log("Manual edits updated, updating on filesystem...");
+      const { file } = await this.fsKy.get("api/files/get", {
+        searchParams: { file_path: ev.file_path }
+      }).json();
+      fs3.writeFileSync(
+        path3.join(this.projectDir, "manual-edits.json"),
+        file.text_content
+      );
+    }
+  }
+  async handleFileChangedOnFilesystem(absoluteFilePath) {
+    const relativeFilePath = path3.relative(this.projectDir, absoluteFilePath);
+    if (relativeFilePath.includes("manual-edits.json")) return;
+    await this.fsKy.post("api/files/upsert", {
+      json: {
+        file_path: relativeFilePath,
+        text_content: fs3.readFileSync(absoluteFilePath, "utf-8"),
+        initiator: "filesystem_change"
+      }
+    }).json();
+  }
+  async upsertInitialFiles() {
+    const fileNames = fs3.readdirSync(this.projectDir);
+    for (const fileName of fileNames) {
+      await this.fsKy.post("api/files/upsert", {
+        json: {
+          file_path: fileName,
+          text_content: fs3.readFileSync(
+            path3.join(this.projectDir, fileName),
+            "utf-8"
+          ),
+          initiator: "filesystem_change"
+        }
+      });
+    }
+  }
+  async stop() {
+    this.httpServer?.close();
+    this.eventsWatcher?.stop();
+  }
+};
+
 // cli/dev/register.ts
 var registerDev = (program2) => {
   program2.command("dev").description("Start development server for a snippet").argument("<file>", "Path to the snippet file").option("-p, --port <number>", "Port to run server on", "3000").action(async (file, options) => {
@@ -315,79 +370,17 @@ var registerDev = (program2) => {
     const port = parseInt(options.port);
     try {
       console.log("Installing types for imported snippets...");
-      await installTypes(absolutePath);
+      await installNodeModuleTypesForSnippet(absolutePath);
       console.log("Types installed successfully");
     } catch (error) {
       console.warn("Failed to install types:", error);
     }
-    await createServer2(port);
-    const eventsWatcher = new EventsWatcher(`http://localhost:${port}`);
-    eventsWatcher.start();
-    await fetch(`http://localhost:${port}/api/files/upsert`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({
-        file_path: "entrypoint.tsx",
-        text_content: `
-import MyCircuit from "./snippet.tsx"
-
-circuit.add(<MyCircuit />)
-`
-      })
-    });
-    const updateFile = async (filePath) => {
-      try {
-        const content = await fs4.promises.readFile(filePath, "utf-8");
-        const response = await fetch(
-          `http://localhost:${port}/api/files/upsert`,
-          {
-            method: "POST",
-            headers: { "Content-Type": "application/json" },
-            body: JSON.stringify({
-              file_path: path4.relative(fileDir, filePath),
-              text_content: content
-            })
-          }
-        );
-        if (!response.ok) {
-          console.error(`Failed to update ${filePath}`);
-        }
-      } catch (error) {
-        console.error(`Error updating ${filePath}:`, error);
-      }
-    };
-    const dependencies = /* @__PURE__ */ new Set([absolutePath]);
-    try {
-      const deps = getLocalFileDependencies(absolutePath);
-      deps.forEach((dep) => dependencies.add(dep));
-    } catch (error) {
-      console.warn("Failed to analyze dependencies:", error);
-    }
-    const filesystemWatcher = chokidar.watch(Array.from(dependencies), {
-      persistent: true,
-      ignoreInitial: false
-    });
-    filesystemWatcher.on("change", async (filePath) => {
-      console.log(`File ${filePath} changed`);
-      await updateFile(filePath);
-    });
-    filesystemWatcher.on("add", async (filePath) => {
-      console.log(`File ${filePath} added`);
-      await updateFile(filePath);
+    const server = new DevServer({
+      port,
+      componentFilePath: absolutePath
     });
-    eventsWatcher.on("FILE_UPDATED", async (ev) => {
-      if (ev.file_path === "manual-edits.json") {
-        console.log("Manual edits updated, updating on filesystem...");
-        const { file: file2 } = await fetch(
-          `http://localhost:${port}/api/files/get?file_path=manual-edits.json`
-        ).then((r) => r.json());
-        fs4.writeFileSync(
-          path4.join(fileDir, "manual-edits.json"),
-          file2.text_content
-        );
-      }
-    });
-    console.log(`Watching ${file} and its dependencies...`);
+    await server.start();
+    await server.addEntrypoint();
   });
 };
 
@@ -404,7 +397,7 @@ var getRegistryApiUrl = () => {
 import delay from "delay";
 
 // lib/registry-api/get-ky.ts
-import ky from "ky";
+import ky2 from "ky";
 var prettyResponseErrorHook = async (_request, _options, response) => {
   if (!response.ok) {
     try {
@@ -419,7 +412,7 @@ var prettyResponseErrorHook = async (_request, _options, response) => {
   }
 };
 var getKy = () => {
-  return ky.create({
+  return ky2.create({
     prefixUrl: getRegistryApiUrl(),
     hooks: {
       afterResponse: [prettyResponseErrorHook]
@@ -430,8 +423,8 @@ var getKy = () => {
 // cli/auth/login/register.ts
 var registerAuthLogin = (program2) => {
   program2.commands.find((c) => c.name() === "auth").command("login").description("Authenticate CLI, login to registry").action(async (args) => {
-    const ky2 = getKy();
-    const { login_page } = await ky2.post(
+    const ky3 = getKy();
+    const { login_page } = await ky3.post(
       "sessions/login_page/create",
       {
         json: {}
@@ -440,7 +433,7 @@ var registerAuthLogin = (program2) => {
     console.log("Please visit the following URL to log in:");
     console.log(login_page.url);
     while (true) {
-      const { login_page: new_login_page } = await ky2.post(
+      const { login_page: new_login_page } = await ky3.post(
         "sessions/login_page/get",
         {
           json: {
@@ -460,7 +453,7 @@ var registerAuthLogin = (program2) => {
       }
       await delay(1e3);
     }
-    const { session } = await ky2.post(
+    const { session } = await ky3.post(
       "sessions/login_page/exchange_for_cli_session",
       {
         json: {
@@ -501,7 +494,7 @@ var registerConfigPrint = (program2) => {
 };
 
 // cli/clone/register.ts
-import * as fs5 from "node:fs";
+import * as fs4 from "node:fs";
 import * as path5 from "node:path";
 var registerClone = (program2) => {
   program2.command("clone").description("Clone a snippet from the registry").argument("<snippet>", "Snippet to clone (e.g. author/snippetName)").action(async (snippetPath) => {
@@ -522,23 +515,23 @@ var registerClone = (program2) => {
       );
       process.exit(1);
     }
-    const ky2 = getKy();
+    const ky3 = getKy();
     try {
       console.log(`Cloning ${author}/${snippetName}...`);
-      const packageFileList = await ky2.post("package_files/list", {
+      const packageFileList = await ky3.post("package_files/list", {
         json: {
           package_name: `${author}/${snippetName}`,
           use_latest_version: true
         }
       }).json();
       const dirPath = `./${author}.${snippetName}`;
-      if (!fs5.existsSync(dirPath)) {
-        fs5.mkdirSync(dirPath);
+      if (!fs4.existsSync(dirPath)) {
+        fs4.mkdirSync(dirPath);
       }
       for (const fileInfo of packageFileList.package_files) {
         const filePath = fileInfo.file_path.startsWith("/") ? fileInfo.file_path.slice(1) : fileInfo.file_path;
         if (filePath.startsWith("dist/")) continue;
-        const fileContent = await ky2.post("package_files/get", {
+        const fileContent = await ky3.post("package_files/get", {
           json: {
             package_name: `${author}/${snippetName}`,
             file_path: fileInfo.file_path
@@ -546,10 +539,10 @@ var registerClone = (program2) => {
         }).json();
         const fullPath = path5.join(dirPath, filePath);
         const dirName = path5.dirname(fullPath);
-        if (!fs5.existsSync(dirName)) {
-          fs5.mkdirSync(dirName, { recursive: true });
+        if (!fs4.existsSync(dirName)) {
+          fs4.mkdirSync(dirName, { recursive: true });
         }
-        fs5.writeFileSync(fullPath, fileContent.package_file.content_text);
+        fs4.writeFileSync(fullPath, fileContent.package_file.content_text);
       }
       console.log(`Successfully cloned to ./${author}.${snippetName}/`);
     } catch (error) {
@@ -579,4 +572,4 @@ if (process.argv.length === 2) {
 } else {
   program.parse();
 }
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../cli/main.ts", "../cli/dev/register.ts", "../lib/server/createServer.ts", "../package.json", "../lib/site/getIndex.ts", "../lib/dependency-analysis/getLocalFileDependencies.ts", "../lib/dependency-analysis/installNodeModuleTypes.ts", "../lib/server/EventsWatcher.ts", "../lib/cli-config/index.ts", "../cli/auth/login/register.ts", "../lib/registry-api/get-ky.ts", "../cli/auth/logout/register.ts", "../cli/auth/register.ts", "../cli/config/register.ts", "../cli/config/print/register.ts", "../cli/clone/register.ts"],
  "sourcesContent": ["#!/usr/bin/env node\nimport { Command } from \"commander\"\nimport { registerDev } from \"./dev/register\"\nimport { registerAuthLogin } from \"./auth/login/register\"\nimport { registerAuthLogout } from \"./auth/logout/register\"\nimport { registerAuth } from \"./auth/register\"\nimport { registerConfig } from \"./config/register\"\nimport { registerConfigPrint } from \"./config/print/register\"\nimport { registerClone } from \"./clone/register\"\nimport { perfectCli } from \"perfect-cli\"\nimport pkg from \"../package.json\"\n\nconst program = new Command()\n\nprogram\n  .name(\"tsci\")\n  .description(\"CLI for developing tscircuit snippets\")\n  .version(pkg.version)\n\nregisterDev(program)\nregisterClone(program)\n\nregisterAuth(program)\nregisterAuthLogin(program)\nregisterAuthLogout(program)\n\nregisterConfig(program)\nregisterConfigPrint(program)\n\nif (process.argv.length === 2) {\n  perfectCli(program, process.argv)\n} else {\n  program.parse()\n}\n", "import type { Command } from \"commander\"\nimport * as path from \"node:path\"\nimport * as chokidar from \"chokidar\"\nimport * as fs from \"node:fs\"\nimport { createServer } from \"lib/server/createServer\"\nimport { getLocalFileDependencies } from \"lib/dependency-analysis/getLocalFileDependencies\"\nimport { installTypes } from \"../../lib/dependency-analysis/installNodeModuleTypes\"\nimport { EventsWatcher } from \"../../lib/server/EventsWatcher\"\n\nexport const registerDev = (program: Command) => {\n  program\n    .command(\"dev\")\n    .description(\"Start development server for a snippet\")\n    .argument(\"<file>\", \"Path to the snippet file\")\n    .option(\"-p, --port <number>\", \"Port to run server on\", \"3000\")\n    .action(async (file: string, options: { port: string }) => {\n      const absolutePath = path.resolve(file)\n      const fileDir = path.dirname(absolutePath)\n      const port = parseInt(options.port)\n\n      try {\n        console.log(\"Installing types for imported snippets...\")\n        await installTypes(absolutePath)\n        console.log(\"Types installed successfully\")\n      } catch (error) {\n        console.warn(\"Failed to install types:\", error)\n      }\n\n      // Start the server\n      await createServer(port)\n\n      const eventsWatcher = new EventsWatcher(`http://localhost:${port}`)\n      eventsWatcher.start()\n\n      await fetch(`http://localhost:${port}/api/files/upsert`, {\n        method: \"POST\",\n        headers: { \"Content-Type\": \"application/json\" },\n        body: JSON.stringify({\n          file_path: \"entrypoint.tsx\",\n          text_content: `\nimport MyCircuit from \"./snippet.tsx\"\n\ncircuit.add(<MyCircuit />)\n`,\n        }),\n      })\n\n      // Function to update file content\n      const updateFile = async (filePath: string) => {\n        try {\n          const content = await fs.promises.readFile(filePath, \"utf-8\")\n          const response = await fetch(\n            `http://localhost:${port}/api/files/upsert`,\n            {\n              method: \"POST\",\n              headers: { \"Content-Type\": \"application/json\" },\n              body: JSON.stringify({\n                file_path: path.relative(fileDir, filePath),\n                text_content: content,\n              }),\n            },\n          )\n          if (!response.ok) {\n            console.error(`Failed to update ${filePath}`)\n          }\n        } catch (error) {\n          console.error(`Error updating ${filePath}:`, error)\n        }\n      }\n\n      // Get initial dependencies\n      const dependencies = new Set([absolutePath])\n      try {\n        const deps = getLocalFileDependencies(absolutePath)\n        deps.forEach((dep) => dependencies.add(dep))\n      } catch (error) {\n        console.warn(\"Failed to analyze dependencies:\", error)\n      }\n\n      // Watch the main file and its dependencies\n      const filesystemWatcher = chokidar.watch(Array.from(dependencies), {\n        persistent: true,\n        ignoreInitial: false,\n      })\n\n      filesystemWatcher.on(\"change\", async (filePath) => {\n        console.log(`File ${filePath} changed`)\n        await updateFile(filePath)\n      })\n\n      filesystemWatcher.on(\"add\", async (filePath) => {\n        console.log(`File ${filePath} added`)\n        await updateFile(filePath)\n      })\n\n      eventsWatcher.on(\"FILE_UPDATED\", async (ev) => {\n        if (ev.file_path === \"manual-edits.json\") {\n          console.log(\"Manual edits updated, updating on filesystem...\")\n          const { file } = await fetch(\n            `http://localhost:${port}/api/files/get?file_path=manual-edits.json`,\n          ).then((r) => r.json())\n          fs.writeFileSync(\n            path.join(fileDir, \"manual-edits.json\"),\n            file.text_content,\n          )\n        }\n      })\n\n      console.log(`Watching ${file} and its dependencies...`)\n    })\n}\n", "import * as http from \"node:http\"\nimport * as fs from \"node:fs\"\nimport * as path from \"node:path\"\nimport { getNodeHandler } from \"winterspec/adapters/node\"\nimport pkg from \"../../package.json\"\n\n// @ts-ignore\nimport winterspecBundle from \"@tscircuit/file-server/dist/bundle.js\"\nimport { getIndex } from \"../site/getIndex\"\n\nexport const createServer = async (port: number = 3000) => {\n  const fileServerHandler = getNodeHandler(winterspecBundle as any, {})\n\n  const server = http.createServer(async (req, res) => {\n    const url = new URL(req.url!, `http://${req.headers.host}`)\n\n    if (url.pathname === \"/standalone.min.js\") {\n      const standaloneFilePath =\n        process.env.RUNFRAME_STANDALONE_FILE_PATH ||\n        path.resolve(\n          process.cwd(),\n          \"node_modules\",\n          \"@tscircuit/runframe/dist/standalone.min.js\",\n        )\n\n      try {\n        const content = fs.readFileSync(standaloneFilePath, \"utf8\")\n        res.writeHead(200, {\n          \"Content-Type\": \"application/javascript; charset=utf-8\",\n        })\n        res.end(content)\n        return\n      } catch (error) {\n        console.error(\"Error serving standalone.min.js:\", error)\n      }\n\n      res.writeHead(302, {\n        Location: `https://cdn.jsdelivr.net/npm/@tscircuit/runframe@${pkg.dependencies[\"@tscircuit/runframe\"].replace(/^[^0-9]+/, \"\")}/dist/standalone.min.js`,\n      })\n      res.end()\n      return\n    }\n\n    if (url.pathname === \"/\") {\n      const html = await getIndex()\n      res.writeHead(200, { \"Content-Type\": \"text/html\" })\n      res.end(html)\n      return\n    }\n\n    if (url.pathname.startsWith(\"/api/\")) {\n      req.url = req.url!.replace(\"/api/\", \"/\")\n      fileServerHandler(req, res)\n      return\n    }\n\n    res.writeHead(404)\n    res.end(\"Not found\")\n  })\n\n  return new Promise<void>((resolve) => {\n    server.listen(port, () => {\n      console.log(`Server running at http://localhost:${port}`)\n      resolve()\n    })\n  })\n}\n", "{\n  \"name\": \"@tscircuit/cli\",\n  \"main\": \"dist/main.js\",\n  \"type\": \"module\",\n  \"version\": \"0.1.3\",\n  \"bin\": {\n    \"tsci\": \"./dist/main.js\"\n  },\n  \"scripts\": {\n    \"start\": \"bun run dev\",\n    \"dev\": \"bun --hot ./cli/main.ts dev ./example-dir/snippet.tsx\",\n    \"build\": \"tsup-node cli/main.ts --format esm --sourcemap inline\",\n    \"format\": \"biome format --write .\",\n    \"format:check\": \"biome format .\",\n    \"cli\": \"bun ./cli/main.ts\"\n  },\n  \"devDependencies\": {\n    \"@biomejs/biome\": \"^1.9.4\",\n    \"@tscircuit/core\": \"^0.0.249\",\n    \"@types/bun\": \"latest\",\n    \"@types/configstore\": \"^6.0.2\",\n    \"@types/react\": \"^19.0.1\",\n    \"tsup\": \"^8.3.5\"\n  },\n  \"peerDependencies\": {\n    \"typescript\": \"^5.0.0\"\n  },\n  \"dependencies\": {\n    \"@tscircuit/file-server\": \"^0.0.11\",\n    \"@tscircuit/runframe\": \"^0.0.47\",\n    \"chokidar\": \"^4.0.1\",\n    \"commander\": \"^12.1.0\",\n    \"configstore\": \"^7.0.0\",\n    \"cosmiconfig\": \"^9.0.0\",\n    \"delay\": \"^6.0.0\",\n    \"ky\": \"^1.7.4\",\n    \"perfect-cli\": \"^1.0.20\"\n  }\n}\n", "import pkg from \"../../package.json\"\n\nexport const getIndex = async () => {\n  return `<html>\n    <head>\n    </head>\n    <body>\n      <script src=\"https://cdn.tailwindcss.com\"></script>\n      <div id=\"root\">loading...</div>\n      <script>\n      globalThis.process = { env: { NODE_ENV: \"production\" } }\n      </script>\n      <script src=\"/standalone.min.js\"></script>\n    </body>\n  </html>`\n}\n\n// <script src=\"https://cdn.jsdelivr.net/npm/@tscircuit/runframe@${pkg.dependencies[\"@tscircuit/runframe\"].replace(/^[^0-9]+/, \"\")}/dist/standalone.min.js\"></script>\n", "import * as ts from \"typescript\"\nimport * as path from \"path\"\nimport * as fs from \"fs\"\n\nfunction getLocalFileDependencies(pathToTsxFile: string): string[] {\n  // Ensure absolute path\n  const absolutePath = path.resolve(pathToTsxFile)\n  const baseDir = path.dirname(absolutePath)\n\n  // Read and parse the file\n  const content = fs.readFileSync(absolutePath, \"utf-8\")\n  const sourceFile = ts.createSourceFile(\n    absolutePath,\n    content,\n    ts.ScriptTarget.Latest,\n    true,\n  )\n\n  const dependencies = new Set<string>()\n\n  // Recursively visit nodes to find imports\n  function visit(node: ts.Node) {\n    if (ts.isImportDeclaration(node) || ts.isExportDeclaration(node)) {\n      const moduleSpecifier = node.moduleSpecifier\n      if (moduleSpecifier && ts.isStringLiteral(moduleSpecifier)) {\n        const importPath = moduleSpecifier.text\n        // Only process local imports (starting with . or ..)\n        if (importPath.startsWith(\".\")) {\n          resolveAndAddDependency(importPath)\n        }\n      }\n    }\n\n    // Handle dynamic imports\n    if (\n      ts.isCallExpression(node) &&\n      node.expression.kind === ts.SyntaxKind.ImportKeyword\n    ) {\n      const argument = node.arguments[0]\n      if (argument && ts.isStringLiteral(argument)) {\n        const importPath = argument.text\n        if (importPath.startsWith(\".\")) {\n          resolveAndAddDependency(importPath)\n        }\n      }\n    }\n\n    ts.forEachChild(node, visit)\n  }\n\n  // Helper to resolve and add dependency paths\n  function resolveAndAddDependency(importPath: string) {\n    const extensions = [\n      \".tsx\",\n      \".ts\",\n      \".jsx\",\n      \".js\",\n      \".css\",\n      \".scss\",\n      \".sass\",\n      \".less\",\n    ]\n    let resolvedPath = path.resolve(baseDir, importPath)\n\n    // Check if path exists as-is\n    if (fs.existsSync(resolvedPath)) {\n      dependencies.add(resolvedPath)\n      return\n    }\n\n    // Try with extensions\n    for (const ext of extensions) {\n      const pathWithExt = resolvedPath + ext\n      if (fs.existsSync(pathWithExt)) {\n        dependencies.add(pathWithExt)\n        return\n      }\n    }\n\n    // Check for index files in directories\n    if (\n      fs.existsSync(resolvedPath) &&\n      fs.statSync(resolvedPath).isDirectory()\n    ) {\n      for (const ext of extensions) {\n        const indexPath = path.join(resolvedPath, `index${ext}`)\n        if (fs.existsSync(indexPath)) {\n          dependencies.add(indexPath)\n          return\n        }\n      }\n    }\n  }\n\n  // Start the traversal\n  visit(sourceFile)\n\n  return Array.from(dependencies)\n}\n\nexport { getLocalFileDependencies }\n", "import * as fs from \"node:fs\"\nimport * as path from \"node:path\"\nimport * as ts from \"typescript\"\n\ninterface SnippetApiResponse {\n  snippet: {\n    dts: string\n  }\n}\n\nexport async function installTypes(snippetPath: string) {\n  const content = fs.readFileSync(snippetPath, \"utf-8\")\n  const sourceFile = ts.createSourceFile(\n    snippetPath,\n    content,\n    ts.ScriptTarget.Latest,\n    true,\n  )\n\n  const imports: string[] = []\n\n  function visit(node: ts.Node) {\n    if (ts.isImportDeclaration(node)) {\n      const moduleSpecifier = node.moduleSpecifier\n      if (moduleSpecifier && ts.isStringLiteral(moduleSpecifier)) {\n        const importPath = moduleSpecifier.text\n        if (importPath.startsWith(\"@tsci/\")) {\n          imports.push(importPath)\n        }\n      }\n    }\n    ts.forEachChild(node, visit)\n  }\n\n  visit(sourceFile)\n\n  let projectRoot = path.dirname(snippetPath)\n  while (projectRoot !== path.parse(projectRoot).root) {\n    if (fs.existsSync(path.join(projectRoot, \"package.json\"))) {\n      break\n    }\n    projectRoot = path.dirname(projectRoot)\n  }\n\n  for (const importPath of imports) {\n    const [owner, name] = importPath.replace(\"@tsci/\", \"\").split(\".\")\n    try {\n      const response = await fetch(\n        `https://registry-api.tscircuit.com/snippets/get?owner_name=${owner}&unscoped_name=${name}`,\n      )\n\n      if (!response.ok) {\n        console.warn(`Failed to fetch types for ${importPath}`)\n        continue\n      }\n\n      const data: SnippetApiResponse = await response.json()\n\n      if (data.snippet.dts) {\n        const packageDir = path.join(\n          projectRoot,\n          \"node_modules\",\n          \"@tsci\",\n          `${owner}.${name}`,\n        )\n        fs.mkdirSync(packageDir, { recursive: true })\n\n        fs.writeFileSync(path.join(packageDir, \"index.d.ts\"), data.snippet.dts)\n      }\n    } catch (error) {\n      console.warn(`Error fetching types for ${importPath}:`, error)\n    }\n  }\n}\n", "import { EventEmitter } from \"events\"\n\ninterface Event {\n  event_id: string\n  created_at: string\n  event_type: string\n  [key: string]: any\n}\n\ninterface EventsResponse {\n  event_list: Event[]\n}\n\nexport class EventsWatcher extends EventEmitter {\n  private lastPollTime: string\n  private pollInterval: number\n  private baseUrl: string\n  private polling = false\n  private timeoutId?: NodeJS.Timeout\n\n  constructor(baseUrl = \"http://localhost:3000\", pollInterval = 1000) {\n    super()\n    this.baseUrl = baseUrl\n    this.pollInterval = pollInterval\n    this.lastPollTime = new Date().toISOString()\n  }\n\n  async start() {\n    if (this.polling) return\n    this.polling = true\n    await this.poll()\n  }\n\n  stop() {\n    this.polling = false\n    if (this.timeoutId) {\n      clearTimeout(this.timeoutId)\n    }\n  }\n\n  private async poll() {\n    if (!this.polling) return\n\n    try {\n      const response = await fetch(\n        `${this.baseUrl}/api/events/list?since=${encodeURIComponent(this.lastPollTime)}`,\n      )\n\n      if (!response.ok) {\n        throw new Error(`HTTP error! status: ${response.status}`)\n      }\n\n      const data: EventsResponse = await response.json()\n\n      // Update last poll time to latest event or current time\n      const latestEvent = data.event_list[data.event_list.length - 1]\n      this.lastPollTime = latestEvent\n        ? latestEvent.created_at\n        : new Date().toISOString()\n\n      // Emit events in chronological order\n      data.event_list.forEach((event) => {\n        this.emit(event.event_type, event)\n        this.emit(\"*\", event)\n      })\n    } catch (error) {\n      this.emit(\"error\", error)\n    }\n    // Schedule next poll\n    this.timeoutId = globalThis.setTimeout(\n      () => this.poll(),\n      this.pollInterval,\n    ) as unknown as NodeJS.Timeout\n  }\n}\n", "import Configstore from \"configstore\"\nimport type { TypedConfigstore } from \"./TypedConfigStore\"\n\nexport interface CliConfig {\n  sessionToken?: string\n  githubUsername?: string\n  registryApiUrl?: string\n}\n\nexport const cliConfig: TypedConfigstore<CliConfig> = new Configstore(\n  \"tscircuit\",\n)\n\nexport const getRegistryApiUrl = (): string => {\n  return cliConfig.get(\"registryApiUrl\") ?? \"https://registry-api.tscircuit.com\"\n}\n", "import type { Command } from \"commander\"\nimport { cliConfig } from \"lib/cli-config\"\nimport delay from \"delay\"\nimport { getKy } from \"lib/registry-api/get-ky\"\nimport type { EndpointResponse } from \"lib/registry-api/endpoint-types\"\n\nexport const registerAuthLogin = (program: Command) => {\n  program.commands\n    .find((c) => c.name() === \"auth\")!\n    .command(\"login\")\n    .description(\"Authenticate CLI, login to registry\")\n    .action(async (args) => {\n      const ky = getKy()\n\n      const { login_page } = await ky\n        .post<EndpointResponse[\"sessions/login_page/create\"]>(\n          \"sessions/login_page/create\",\n          {\n            json: {},\n          },\n        )\n        .json()\n\n      console.log(\"Please visit the following URL to log in:\")\n      console.log(login_page.url)\n\n      // Wait until we receive confirmation\n      while (true) {\n        const { login_page: new_login_page } = await ky\n          .post<EndpointResponse[\"sessions/login_page/get\"]>(\n            \"sessions/login_page/get\",\n            {\n              json: {\n                login_page_id: login_page.login_page_id,\n              },\n              headers: {\n                Authorization: `Bearer ${login_page.login_page_auth_token}`,\n              },\n            },\n          )\n          .json()\n\n        if (new_login_page.was_login_successful) {\n          console.log(\"Logged in! Generating token...\")\n          break\n        }\n\n        if (new_login_page.is_expired) {\n          throw new Error(\"Login page expired\")\n        }\n\n        await delay(1000)\n      }\n\n      const { session } = await ky\n        .post<EndpointResponse[\"sessions/login_page/exchange_for_cli_session\"]>(\n          \"sessions/login_page/exchange_for_cli_session\",\n          {\n            json: {\n              login_page_id: login_page.login_page_id,\n            },\n            headers: {\n              Authorization: `Bearer ${login_page.login_page_auth_token}`,\n            },\n          },\n        )\n        .json()\n\n      cliConfig.set(\"sessionToken\", session.token)\n\n      console.log(\"Ready to use!\")\n    })\n}\n", "import { getRegistryApiUrl } from \"lib/cli-config\"\nimport ky, { type AfterResponseHook } from \"ky\"\n\nconst prettyResponseErrorHook: AfterResponseHook = async (\n  _request,\n  _options,\n  response,\n) => {\n  if (!response.ok) {\n    try {\n      const errorData = await response.json()\n      throw new Error(\n        `FAIL [${response.status}]: ${_request.method} ${\n          new URL(_request.url).pathname\n        } \\n\\n ${JSON.stringify(errorData, null, 2)}`,\n      )\n    } catch (e) {\n      //ignore, allow the error to be thrown\n    }\n  }\n}\n\nexport const getKy = () => {\n  return ky.create({\n    prefixUrl: getRegistryApiUrl(),\n    hooks: {\n      afterResponse: [prettyResponseErrorHook],\n    },\n  })\n}\n", "import type { Command } from \"commander\"\n\nexport const registerAuthLogout = (program: Command) => {\n  program.commands\n    .find((c) => c.name() === \"auth\")!\n    .command(\"logout\")\n    .description(\"Logout from registry\")\n    .action((args) => {\n      console.log(\"logout\")\n    })\n}\n", "import type { Command } from \"commander\"\n\nexport const registerAuth = (program: Command) => {\n  program.command(\"auth\").description(\"Login/logout\")\n}\n", "import type { Command } from \"commander\"\n\nexport const registerConfig = (program: Command) => {\n  program.command(\"config\").description(\"Manage tscircuit CLI configuration\")\n}\n", "import type { Command } from \"commander\"\nimport { cliConfig } from \"lib/cli-config\"\n\nexport const registerConfigPrint = (program: Command) => {\n  program.commands\n    .find((c) => c.name() === \"config\")!\n    .command(\"print\")\n    .description(\"Print the current config\")\n    .action(() => {\n      console.log(JSON.stringify(cliConfig.all, null, 2))\n    })\n}\n", "import type { Command } from \"commander\"\nimport { getKy } from \"lib/registry-api/get-ky\"\nimport * as fs from \"node:fs\"\nimport * as path from \"node:path\"\n\nexport const registerClone = (program: Command) => {\n  program\n    .command(\"clone\")\n    .description(\"Clone a snippet from the registry\")\n    .argument(\"<snippet>\", \"Snippet to clone (e.g. author/snippetName)\")\n    .action(async (snippetPath: string) => {\n      let author: string\n      let snippetName: string\n      if (!snippetPath.startsWith(\"@tsci/\") && snippetPath.includes(\"/\")) {\n        ;[author, snippetName] = snippetPath.split(\"/\")\n      } else {\n        const trimmedPath = snippetPath.replace(\"@tsci/\", \"\")\n        const firstDotIndex = trimmedPath.indexOf(\".\")\n        author = trimmedPath.slice(0, firstDotIndex)\n        snippetName = trimmedPath.slice(firstDotIndex + 1)\n      }\n\n      if (!author || !snippetName) {\n        console.error(\n          \"Invalid snippet path. Use format: author/snippetName, author.snippetName or @tsci/author.snippetName\",\n        )\n        process.exit(1)\n      }\n\n      const ky = getKy()\n\n      try {\n        console.log(`Cloning ${author}/${snippetName}...`)\n\n        const packageFileList = await ky\n          .post<{\n            package_files: Array<{\n              package_file_id: string\n              package_release_id: string\n              file_path: string\n              created_at: string\n            }>\n          }>(\"package_files/list\", {\n            json: {\n              package_name: `${author}/${snippetName}`,\n              use_latest_version: true,\n            },\n          })\n          .json()\n\n        // Create directory if it doesn't exist\n        const dirPath = `./${author}.${snippetName}`\n        if (!fs.existsSync(dirPath)) {\n          fs.mkdirSync(dirPath)\n        }\n\n        // Download each file that doesn't start with dist/\n        for (const fileInfo of packageFileList.package_files) {\n          const filePath = fileInfo.file_path.startsWith(\"/\")\n            ? fileInfo.file_path.slice(1)\n            : fileInfo.file_path\n\n          if (filePath.startsWith(\"dist/\")) continue\n\n          const fileContent = await ky\n            .post<{\n              package_file: {\n                content_text: string\n              }\n            }>(\"package_files/get\", {\n              json: {\n                package_name: `${author}/${snippetName}`,\n                file_path: fileInfo.file_path,\n              },\n            })\n            .json()\n\n          const fullPath = path.join(dirPath, filePath)\n          const dirName = path.dirname(fullPath)\n\n          // Create nested directories if they don't exist\n          if (!fs.existsSync(dirName)) {\n            fs.mkdirSync(dirName, { recursive: true })\n          }\n\n          fs.writeFileSync(fullPath, fileContent.package_file.content_text)\n        }\n\n        console.log(`Successfully cloned to ./${author}.${snippetName}/`)\n      } catch (error) {\n        if (error instanceof Error) {\n          console.error(\"Failed to clone snippet:\", error.message)\n        } else {\n          console.error(\"Failed to clone snippet:\", error)\n        }\n        process.exit(1)\n      }\n    })\n}\n"],
  "mappings": "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",
  "names": ["path", "fs", "createServer", "resolve", "path", "fs", "fs", "path", "ts", "program", "createServer", "file", "program", "ky", "program", "program", "program", "program", "fs", "path", "program", "ky"]
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../cli/main.ts", "../cli/dev/register.ts", "../lib/dependency-analysis/installNodeModuleTypesForSnippet.ts", "../cli/dev/DevServer.ts", "../lib/server/createHttpServer.ts", "../package.json", "../lib/site/getIndex.ts", "../lib/server/EventsWatcher.ts", "../lib/cli-config/index.ts", "../cli/auth/login/register.ts", "../lib/registry-api/get-ky.ts", "../cli/auth/logout/register.ts", "../cli/auth/register.ts", "../cli/config/register.ts", "../cli/config/print/register.ts", "../cli/clone/register.ts"],
  "sourcesContent": ["#!/usr/bin/env node\nimport { Command } from \"commander\"\nimport { registerDev } from \"./dev/register\"\nimport { registerAuthLogin } from \"./auth/login/register\"\nimport { registerAuthLogout } from \"./auth/logout/register\"\nimport { registerAuth } from \"./auth/register\"\nimport { registerConfig } from \"./config/register\"\nimport { registerConfigPrint } from \"./config/print/register\"\nimport { registerClone } from \"./clone/register\"\nimport { perfectCli } from \"perfect-cli\"\nimport pkg from \"../package.json\"\n\nconst program = new Command()\n\nprogram\n  .name(\"tsci\")\n  .description(\"CLI for developing tscircuit snippets\")\n  .version(pkg.version)\n\nregisterDev(program)\nregisterClone(program)\n\nregisterAuth(program)\nregisterAuthLogin(program)\nregisterAuthLogout(program)\n\nregisterConfig(program)\nregisterConfigPrint(program)\n\nif (process.argv.length === 2) {\n  perfectCli(program, process.argv)\n} else {\n  program.parse()\n}\n", "import type { Command } from \"commander\"\nimport * as path from \"node:path\"\nimport * as chokidar from \"chokidar\"\nimport * as fs from \"node:fs\"\nimport { createHttpServer } from \"lib/server/createHttpServer\"\nimport { getLocalFileDependencies } from \"lib/dependency-analysis/getLocalFileDependencies\"\nimport { installNodeModuleTypesForSnippet } from \"../../lib/dependency-analysis/installNodeModuleTypesForSnippet\"\nimport { EventsWatcher } from \"../../lib/server/EventsWatcher\"\nimport { DevServer } from \"./DevServer\"\n\nexport const registerDev = (program: Command) => {\n  program\n    .command(\"dev\")\n    .description(\"Start development server for a snippet\")\n    .argument(\"<file>\", \"Path to the snippet file\")\n    .option(\"-p, --port <number>\", \"Port to run server on\", \"3000\")\n    .action(async (file: string, options: { port: string }) => {\n      const absolutePath = path.resolve(file)\n      const fileDir = path.dirname(absolutePath)\n      const port = parseInt(options.port)\n\n      try {\n        console.log(\"Installing types for imported snippets...\")\n        await installNodeModuleTypesForSnippet(absolutePath)\n        console.log(\"Types installed successfully\")\n      } catch (error) {\n        console.warn(\"Failed to install types:\", error)\n      }\n\n      const server = new DevServer({\n        port,\n        componentFilePath: absolutePath,\n      })\n\n      await server.start()\n      await server.addEntrypoint()\n    })\n}\n", "import * as fs from \"node:fs\"\nimport * as path from \"node:path\"\nimport * as ts from \"typescript\"\n\ninterface SnippetApiResponse {\n  snippet: {\n    dts: string\n  }\n}\n\nexport async function installNodeModuleTypesForSnippet(snippetPath: string) {\n  const content = fs.readFileSync(snippetPath, \"utf-8\")\n  const sourceFile = ts.createSourceFile(\n    snippetPath,\n    content,\n    ts.ScriptTarget.Latest,\n    true,\n  )\n\n  const imports: string[] = []\n\n  function visit(node: ts.Node) {\n    if (ts.isImportDeclaration(node)) {\n      const moduleSpecifier = node.moduleSpecifier\n      if (moduleSpecifier && ts.isStringLiteral(moduleSpecifier)) {\n        const importPath = moduleSpecifier.text\n        if (importPath.startsWith(\"@tsci/\")) {\n          imports.push(importPath)\n        }\n      }\n    }\n    ts.forEachChild(node, visit)\n  }\n\n  visit(sourceFile)\n\n  let projectRoot = path.dirname(snippetPath)\n  while (projectRoot !== path.parse(projectRoot).root) {\n    if (fs.existsSync(path.join(projectRoot, \"package.json\"))) {\n      break\n    }\n    projectRoot = path.dirname(projectRoot)\n  }\n\n  for (const importPath of imports) {\n    const [owner, name] = importPath.replace(\"@tsci/\", \"\").split(\".\")\n    try {\n      const response = await fetch(\n        `https://registry-api.tscircuit.com/snippets/get?owner_name=${owner}&unscoped_name=${name}`,\n      )\n\n      if (!response.ok) {\n        console.warn(`Failed to fetch types for ${importPath}`)\n        continue\n      }\n\n      const data: SnippetApiResponse = await response.json()\n\n      if (data.snippet.dts) {\n        const packageDir = path.join(\n          projectRoot,\n          \"node_modules\",\n          \"@tsci\",\n          `${owner}.${name}`,\n        )\n        fs.mkdirSync(packageDir, { recursive: true })\n\n        fs.writeFileSync(path.join(packageDir, \"index.d.ts\"), data.snippet.dts)\n      }\n    } catch (error) {\n      console.warn(`Error fetching types for ${importPath}:`, error)\n    }\n  }\n}\n", "import ky from \"ky\"\nimport type { FileServerRoutes } from \"lib/file-server/FileServerRoutes\"\nimport { createHttpServer } from \"lib/server/createHttpServer\"\nimport { EventsWatcher } from \"lib/server/EventsWatcher\"\nimport type http from \"node:http\"\nimport type { TypedKyInstance } from \"typed-ky\"\nimport path from \"node:path\"\nimport fs from \"node:fs\"\nimport type { FileUpdatedEvent } from \"lib/file-server/FileServerEvent\"\nimport * as chokidar from \"chokidar\"\n\nexport class DevServer {\n  port: number\n  /**\n   * The path to a component that exports a <board /> or <group /> component\n   */\n  componentFilePath: string\n\n  projectDir: string\n\n  /**\n   * The HTTP server that hosts the file server and event bus. You can use\n   * fsKy to communicate with the file server/event bus\n   */\n  httpServer?: http.Server\n  /**\n   * Watches for events on the event bus by polling `api/events/list`\n   */\n  eventsWatcher?: EventsWatcher\n  /**\n   * A ky instance that can be used to communicate with the file server and\n   * event bus\n   */\n  fsKy: TypedKyInstance<keyof FileServerRoutes, FileServerRoutes>\n  /**\n   * A chokidar instance that watches the project directory for file changes\n   */\n  filesystemWatcher?: chokidar.FSWatcher\n\n  constructor({\n    port,\n    componentFilePath,\n  }: {\n    port: number\n    componentFilePath: string\n  }) {\n    this.port = port\n    this.componentFilePath = componentFilePath\n    this.projectDir = path.dirname(componentFilePath)\n    this.fsKy = ky.create({\n      prefixUrl: `http://localhost:${port}`,\n    }) as any\n  }\n\n  async start() {\n    const { server } = await createHttpServer(this.port)\n    this.httpServer = server\n\n    this.eventsWatcher = new EventsWatcher(`http://localhost:${this.port}`)\n    this.eventsWatcher.start()\n\n    this.eventsWatcher.on(\n      \"FILE_UPDATED\",\n      this.handleFileUpdatedEventFromServer.bind(this),\n    )\n\n    this.filesystemWatcher = chokidar.watch(this.projectDir, {\n      persistent: true,\n      ignoreInitial: true,\n    })\n\n    this.filesystemWatcher.on(\"change\", (filePath) =>\n      this.handleFileChangedOnFilesystem(filePath),\n    )\n    this.filesystemWatcher.on(\"add\", (filePath) =>\n      this.handleFileChangedOnFilesystem(filePath),\n    )\n\n    this.upsertInitialFiles()\n  }\n\n  async addEntrypoint() {\n    const relativeComponentFilePath = path.relative(\n      this.projectDir,\n      this.componentFilePath,\n    )\n    await this.fsKy.post(\"api/files/upsert\", {\n      json: {\n        file_path: \"entrypoint.tsx\",\n        text_content: `\nimport MyCircuit from \"./${relativeComponentFilePath}\"\n\ncircuit.add(<MyCircuit />)\n`,\n      },\n    })\n  }\n\n  async handleFileUpdatedEventFromServer(ev: FileUpdatedEvent) {\n    if (ev.initiator === \"filesystem_change\") return\n\n    if (ev.file_path === \"manual-edits.json\") {\n      console.log(\"Manual edits updated, updating on filesystem...\")\n      const { file } = await this.fsKy\n        .get(\"api/files/get\", {\n          searchParams: { file_path: ev.file_path },\n        })\n        .json()\n      fs.writeFileSync(\n        path.join(this.projectDir, \"manual-edits.json\"),\n        file.text_content,\n      )\n    }\n  }\n\n  async handleFileChangedOnFilesystem(absoluteFilePath: string) {\n    const relativeFilePath = path.relative(this.projectDir, absoluteFilePath)\n\n    // We've temporarily disabled upserting manual edits from filesystem changes\n    // because it can be edited by the browser\n    if (relativeFilePath.includes(\"manual-edits.json\")) return\n\n    await this.fsKy\n      .post(\"api/files/upsert\", {\n        json: {\n          file_path: relativeFilePath,\n          text_content: fs.readFileSync(absoluteFilePath, \"utf-8\"),\n          initiator: \"filesystem_change\",\n        },\n      })\n      .json()\n  }\n\n  async upsertInitialFiles() {\n    // Scan project directory for all files and upsert them\n    const fileNames = fs.readdirSync(this.projectDir)\n    for (const fileName of fileNames) {\n      await this.fsKy.post(\"api/files/upsert\", {\n        json: {\n          file_path: fileName,\n          text_content: fs.readFileSync(\n            path.join(this.projectDir, fileName),\n            \"utf-8\",\n          ),\n          initiator: \"filesystem_change\",\n        },\n      })\n    }\n  }\n\n  async stop() {\n    this.httpServer?.close()\n    this.eventsWatcher?.stop()\n  }\n}\n", "import * as http from \"node:http\"\nimport * as fs from \"node:fs\"\nimport * as path from \"node:path\"\nimport { getNodeHandler } from \"winterspec/adapters/node\"\nimport pkg from \"../../package.json\"\n\n// @ts-ignore\nimport winterspecBundle from \"@tscircuit/file-server/dist/bundle.js\"\nimport { getIndex } from \"../site/getIndex\"\n\nexport const createHttpServer = async (port = 3000) => {\n  const fileServerHandler = getNodeHandler(winterspecBundle as any, {})\n\n  const server = http.createServer(async (req, res) => {\n    const url = new URL(req.url!, `http://${req.headers.host}`)\n\n    if (url.pathname === \"/standalone.min.js\") {\n      const standaloneFilePath =\n        process.env.RUNFRAME_STANDALONE_FILE_PATH ||\n        path.resolve(\n          process.cwd(),\n          \"node_modules\",\n          \"@tscircuit/runframe/dist/standalone.min.js\",\n        )\n\n      try {\n        const content = fs.readFileSync(standaloneFilePath, \"utf8\")\n        res.writeHead(200, {\n          \"Content-Type\": \"application/javascript; charset=utf-8\",\n        })\n        res.end(content)\n        return\n      } catch (error) {\n        console.error(\"Error serving standalone.min.js:\", error)\n      }\n\n      res.writeHead(302, {\n        Location: `https://cdn.jsdelivr.net/npm/@tscircuit/runframe@${pkg.dependencies[\"@tscircuit/runframe\"].replace(/^[^0-9]+/, \"\")}/dist/standalone.min.js`,\n      })\n      res.end()\n      return\n    }\n\n    if (url.pathname === \"/\") {\n      const html = await getIndex()\n      res.writeHead(200, { \"Content-Type\": \"text/html\" })\n      res.end(html)\n      return\n    }\n\n    if (url.pathname.startsWith(\"/api/\")) {\n      req.url = req.url!.replace(\"/api/\", \"/\")\n      fileServerHandler(req, res)\n      return\n    }\n\n    res.writeHead(404)\n    res.end(\"Not found\")\n  })\n\n  return new Promise<{ server: http.Server }>((resolve) => {\n    server.listen(port, () => {\n      console.log(`Server running at http://localhost:${port}`)\n      resolve({ server })\n    })\n  })\n}\n", "{\n  \"name\": \"@tscircuit/cli\",\n  \"main\": \"dist/main.js\",\n  \"type\": \"module\",\n  \"version\": \"0.1.4\",\n  \"bin\": {\n    \"tsci\": \"./dist/main.js\"\n  },\n  \"scripts\": {\n    \"start\": \"bun run dev\",\n    \"dev\": \"bun --hot ./cli/main.ts dev ./example-dir/snippet.tsx\",\n    \"build\": \"tsup-node cli/main.ts --format esm --sourcemap inline\",\n    \"format\": \"biome format --write .\",\n    \"format:check\": \"biome format .\",\n    \"cli\": \"bun ./cli/main.ts\"\n  },\n  \"devDependencies\": {\n    \"@biomejs/biome\": \"^1.9.4\",\n    \"@tscircuit/core\": \"^0.0.249\",\n    \"@types/bun\": \"^1.1.15\",\n    \"@types/configstore\": \"^6.0.2\",\n    \"@types/react\": \"^19.0.1\",\n    \"get-port\": \"^7.1.0\",\n    \"tempy\": \"^3.1.0\",\n    \"tsup\": \"^8.3.5\",\n    \"typed-ky\": \"^0.0.4\"\n  },\n  \"peerDependencies\": {\n    \"typescript\": \"^5.0.0\"\n  },\n  \"dependencies\": {\n    \"@tscircuit/file-server\": \"^0.0.13\",\n    \"@tscircuit/runframe\": \"^0.0.47\",\n    \"chokidar\": \"^4.0.1\",\n    \"commander\": \"^12.1.0\",\n    \"configstore\": \"^7.0.0\",\n    \"cosmiconfig\": \"^9.0.0\",\n    \"delay\": \"^6.0.0\",\n    \"ky\": \"^1.7.4\",\n    \"perfect-cli\": \"^1.0.20\"\n  }\n}\n", "import pkg from \"../../package.json\"\n\nexport const getIndex = async () => {\n  return `<html>\n    <head>\n    </head>\n    <body>\n      <script src=\"https://cdn.tailwindcss.com\"></script>\n      <div id=\"root\">loading...</div>\n      <script>\n      globalThis.process = { env: { NODE_ENV: \"production\" } }\n      </script>\n      <script src=\"/standalone.min.js\"></script>\n    </body>\n  </html>`\n}\n\n// <script src=\"https://cdn.jsdelivr.net/npm/@tscircuit/runframe@${pkg.dependencies[\"@tscircuit/runframe\"].replace(/^[^0-9]+/, \"\")}/dist/standalone.min.js\"></script>\n", "import { EventEmitter } from \"events\"\n\ninterface Event {\n  event_id: string\n  created_at: string\n  event_type: string\n  [key: string]: any\n}\n\ninterface EventsResponse {\n  event_list: Event[]\n}\n\nexport class EventsWatcher extends EventEmitter {\n  private lastPollTime: string\n  private pollInterval: number\n  private baseUrl: string\n  private polling = false\n  private timeoutId?: NodeJS.Timeout\n\n  constructor(baseUrl = \"http://localhost:3000\", pollInterval = 1000) {\n    super()\n    this.baseUrl = baseUrl\n    this.pollInterval = pollInterval\n    this.lastPollTime = new Date().toISOString()\n  }\n\n  async start() {\n    if (this.polling) return\n    this.polling = true\n    await this.poll()\n  }\n\n  stop() {\n    this.polling = false\n    if (this.timeoutId) {\n      clearTimeout(this.timeoutId)\n    }\n  }\n\n  private async poll() {\n    if (!this.polling) return\n\n    try {\n      const response = await fetch(\n        `${this.baseUrl}/api/events/list?since=${encodeURIComponent(this.lastPollTime)}`,\n      )\n\n      if (!response.ok) {\n        throw new Error(`HTTP error! status: ${response.status}`)\n      }\n\n      const data: EventsResponse = await response.json()\n\n      // Update last poll time to latest event or current time\n      const latestEvent = data.event_list[data.event_list.length - 1]\n      this.lastPollTime = latestEvent\n        ? latestEvent.created_at\n        : new Date().toISOString()\n\n      // Emit events in chronological order\n      data.event_list.forEach((event) => {\n        this.emit(event.event_type, event)\n        this.emit(\"*\", event)\n      })\n    } catch (error) {\n      this.emit(\"error\", error)\n    }\n    // Schedule next poll\n    this.timeoutId = globalThis.setTimeout(\n      () => this.poll(),\n      this.pollInterval,\n    ) as unknown as NodeJS.Timeout\n  }\n}\n", "import Configstore from \"configstore\"\nimport type { TypedConfigstore } from \"./TypedConfigStore\"\n\nexport interface CliConfig {\n  sessionToken?: string\n  githubUsername?: string\n  registryApiUrl?: string\n}\n\nexport const cliConfig: TypedConfigstore<CliConfig> = new Configstore(\n  \"tscircuit\",\n)\n\nexport const getRegistryApiUrl = (): string => {\n  return cliConfig.get(\"registryApiUrl\") ?? \"https://registry-api.tscircuit.com\"\n}\n", "import type { Command } from \"commander\"\nimport { cliConfig } from \"lib/cli-config\"\nimport delay from \"delay\"\nimport { getKy } from \"lib/registry-api/get-ky\"\nimport type { EndpointResponse } from \"lib/registry-api/endpoint-types\"\n\nexport const registerAuthLogin = (program: Command) => {\n  program.commands\n    .find((c) => c.name() === \"auth\")!\n    .command(\"login\")\n    .description(\"Authenticate CLI, login to registry\")\n    .action(async (args) => {\n      const ky = getKy()\n\n      const { login_page } = await ky\n        .post<EndpointResponse[\"sessions/login_page/create\"]>(\n          \"sessions/login_page/create\",\n          {\n            json: {},\n          },\n        )\n        .json()\n\n      console.log(\"Please visit the following URL to log in:\")\n      console.log(login_page.url)\n\n      // Wait until we receive confirmation\n      while (true) {\n        const { login_page: new_login_page } = await ky\n          .post<EndpointResponse[\"sessions/login_page/get\"]>(\n            \"sessions/login_page/get\",\n            {\n              json: {\n                login_page_id: login_page.login_page_id,\n              },\n              headers: {\n                Authorization: `Bearer ${login_page.login_page_auth_token}`,\n              },\n            },\n          )\n          .json()\n\n        if (new_login_page.was_login_successful) {\n          console.log(\"Logged in! Generating token...\")\n          break\n        }\n\n        if (new_login_page.is_expired) {\n          throw new Error(\"Login page expired\")\n        }\n\n        await delay(1000)\n      }\n\n      const { session } = await ky\n        .post<EndpointResponse[\"sessions/login_page/exchange_for_cli_session\"]>(\n          \"sessions/login_page/exchange_for_cli_session\",\n          {\n            json: {\n              login_page_id: login_page.login_page_id,\n            },\n            headers: {\n              Authorization: `Bearer ${login_page.login_page_auth_token}`,\n            },\n          },\n        )\n        .json()\n\n      cliConfig.set(\"sessionToken\", session.token)\n\n      console.log(\"Ready to use!\")\n    })\n}\n", "import { getRegistryApiUrl } from \"lib/cli-config\"\nimport ky, { type AfterResponseHook } from \"ky\"\n\nconst prettyResponseErrorHook: AfterResponseHook = async (\n  _request,\n  _options,\n  response,\n) => {\n  if (!response.ok) {\n    try {\n      const errorData = await response.json()\n      throw new Error(\n        `FAIL [${response.status}]: ${_request.method} ${\n          new URL(_request.url).pathname\n        } \\n\\n ${JSON.stringify(errorData, null, 2)}`,\n      )\n    } catch (e) {\n      //ignore, allow the error to be thrown\n    }\n  }\n}\n\nexport const getKy = () => {\n  return ky.create({\n    prefixUrl: getRegistryApiUrl(),\n    hooks: {\n      afterResponse: [prettyResponseErrorHook],\n    },\n  })\n}\n", "import type { Command } from \"commander\"\n\nexport const registerAuthLogout = (program: Command) => {\n  program.commands\n    .find((c) => c.name() === \"auth\")!\n    .command(\"logout\")\n    .description(\"Logout from registry\")\n    .action((args) => {\n      console.log(\"logout\")\n    })\n}\n", "import type { Command } from \"commander\"\n\nexport const registerAuth = (program: Command) => {\n  program.command(\"auth\").description(\"Login/logout\")\n}\n", "import type { Command } from \"commander\"\n\nexport const registerConfig = (program: Command) => {\n  program.command(\"config\").description(\"Manage tscircuit CLI configuration\")\n}\n", "import type { Command } from \"commander\"\nimport { cliConfig } from \"lib/cli-config\"\n\nexport const registerConfigPrint = (program: Command) => {\n  program.commands\n    .find((c) => c.name() === \"config\")!\n    .command(\"print\")\n    .description(\"Print the current config\")\n    .action(() => {\n      console.log(JSON.stringify(cliConfig.all, null, 2))\n    })\n}\n", "import type { Command } from \"commander\"\nimport { getKy } from \"lib/registry-api/get-ky\"\nimport * as fs from \"node:fs\"\nimport * as path from \"node:path\"\n\nexport const registerClone = (program: Command) => {\n  program\n    .command(\"clone\")\n    .description(\"Clone a snippet from the registry\")\n    .argument(\"<snippet>\", \"Snippet to clone (e.g. author/snippetName)\")\n    .action(async (snippetPath: string) => {\n      let author: string\n      let snippetName: string\n      if (!snippetPath.startsWith(\"@tsci/\") && snippetPath.includes(\"/\")) {\n        ;[author, snippetName] = snippetPath.split(\"/\")\n      } else {\n        const trimmedPath = snippetPath.replace(\"@tsci/\", \"\")\n        const firstDotIndex = trimmedPath.indexOf(\".\")\n        author = trimmedPath.slice(0, firstDotIndex)\n        snippetName = trimmedPath.slice(firstDotIndex + 1)\n      }\n\n      if (!author || !snippetName) {\n        console.error(\n          \"Invalid snippet path. Use format: author/snippetName, author.snippetName or @tsci/author.snippetName\",\n        )\n        process.exit(1)\n      }\n\n      const ky = getKy()\n\n      try {\n        console.log(`Cloning ${author}/${snippetName}...`)\n\n        const packageFileList = await ky\n          .post<{\n            package_files: Array<{\n              package_file_id: string\n              package_release_id: string\n              file_path: string\n              created_at: string\n            }>\n          }>(\"package_files/list\", {\n            json: {\n              package_name: `${author}/${snippetName}`,\n              use_latest_version: true,\n            },\n          })\n          .json()\n\n        // Create directory if it doesn't exist\n        const dirPath = `./${author}.${snippetName}`\n        if (!fs.existsSync(dirPath)) {\n          fs.mkdirSync(dirPath)\n        }\n\n        // Download each file that doesn't start with dist/\n        for (const fileInfo of packageFileList.package_files) {\n          const filePath = fileInfo.file_path.startsWith(\"/\")\n            ? fileInfo.file_path.slice(1)\n            : fileInfo.file_path\n\n          if (filePath.startsWith(\"dist/\")) continue\n\n          const fileContent = await ky\n            .post<{\n              package_file: {\n                content_text: string\n              }\n            }>(\"package_files/get\", {\n              json: {\n                package_name: `${author}/${snippetName}`,\n                file_path: fileInfo.file_path,\n              },\n            })\n            .json()\n\n          const fullPath = path.join(dirPath, filePath)\n          const dirName = path.dirname(fullPath)\n\n          // Create nested directories if they don't exist\n          if (!fs.existsSync(dirName)) {\n            fs.mkdirSync(dirName, { recursive: true })\n          }\n\n          fs.writeFileSync(fullPath, fileContent.package_file.content_text)\n        }\n\n        console.log(`Successfully cloned to ./${author}.${snippetName}/`)\n      } catch (error) {\n        if (error instanceof Error) {\n          console.error(\"Failed to clone snippet:\", error.message)\n        } else {\n          console.error(\"Failed to clone snippet:\", error)\n        }\n        process.exit(1)\n      }\n    })\n}\n"],
  "mappings": "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",
  "names": ["path", "fs", "path", "resolve", "path", "fs", "program", "ky", "program", "ky", "program", "program", "program", "program", "fs", "path", "program", "ky"]
}


package/lib/dependency-analysis/{installNodeModuleTypes.ts → installNodeModuleTypesForSnippet.ts}

@@ -8,7 +8,7 @@ interface SnippetApiResponse {
   }
 }
 
-export async function installTypes(snippetPath: string) {
+export async function installNodeModuleTypesForSnippet(snippetPath: string) {
   const content = fs.readFileSync(snippetPath, "utf-8")
   const sourceFile = ts.createSourceFile(
     snippetPath,

package/lib/file-server/FileServerEvent.ts

@@ -0,0 +1,7 @@
+export interface FileUpdatedEvent {
+  event_id: string
+  event_type: "FILE_UPDATED"
+  file_path: string
+  initiator?: "filesystem_change" | "browser_edit"
+  created_at: string
+}

package/lib/file-server/FileServerRoutes.ts

@@ -0,0 +1,38 @@
+export interface FileServerRoutes {
+  "api/files/get": {
+    GET: {
+      searchParams: {
+        file_path: string
+      }
+      responseJson: {
+        file: {
+          file_id: string
+          file_path: string
+          text_content: string
+        }
+      }
+    }
+  }
+  "api/files/upsert": {
+    POST: {
+      requestJson: {
+        file_path: string
+        text_content: string
+        initiator?: "filesystem_change"
+      }
+      responseJson: {
+        file: {
+          file_id: string
+          file_path: string
+        }
+      }
+    }
+  }
+  "api/files/list": {
+    GET: {
+      responseJson: {
+        file_list: { file_id: string; file_path: string }[]
+      }
+    }
+  }
+}

package/lib/index.ts

@@ -1,2 +1,2 @@
-export { createServer } from "./server/createServer"
+export { createHttpServer } from "./server/createHttpServer"
 export { getLocalFileDependencies } from "./dependency-analysis/getLocalFileDependencies"

package/lib/server/{createServer.ts → createHttpServer.ts}

@@ -8,7 +8,7 @@ import pkg from "../../package.json"
 import winterspecBundle from "@tscircuit/file-server/dist/bundle.js"
 import { getIndex } from "../site/getIndex"
 
-export const createServer = async (port: number = 3000) => {
+export const createHttpServer = async (port = 3000) => {
   const fileServerHandler = getNodeHandler(winterspecBundle as any, {})
 
   const server = http.createServer(async (req, res) => {
@@ -58,10 +58,10 @@ export const createServer = async (port: number = 3000) => {
     res.end("Not found")
   })
 
-  return new Promise<void>((resolve) => {
+  return new Promise<{ server: http.Server }>((resolve) => {
     server.listen(port, () => {
       console.log(`Server running at http://localhost:${port}`)
-      resolve()
+      resolve({ server })
     })
   })
 }

package/package.json

@@ -2,7 +2,7 @@
   "name": "@tscircuit/cli",
   "main": "dist/main.js",
   "type": "module",
-  "version": "0.1.4",
+  "version": "0.1.5",
   "bin": {
     "tsci": "./dist/main.js"
   },
@@ -17,16 +17,19 @@
   "devDependencies": {
     "@biomejs/biome": "^1.9.4",
     "@tscircuit/core": "^0.0.249",
-    "@types/bun": "latest",
+    "@types/bun": "^1.1.15",
     "@types/configstore": "^6.0.2",
     "@types/react": "^19.0.1",
-    "tsup": "^8.3.5"
+    "get-port": "^7.1.0",
+    "tempy": "^3.1.0",
+    "tsup": "^8.3.5",
+    "typed-ky": "^0.0.4"
   },
   "peerDependencies": {
     "typescript": "^5.0.0"
   },
   "dependencies": {
-    "@tscircuit/file-server": "^0.0.11",
+    "@tscircuit/file-server": "^0.0.13",
     "@tscircuit/runframe": "^0.0.47",
     "chokidar": "^4.0.1",
     "commander": "^12.1.0",

package/tests/fixtures/get-test-fixture.ts

@@ -0,0 +1,25 @@
+import * as tempy from "tempy"
+import getPort from "get-port"
+
+interface Params {
+  vfs?: Record<string, string>
+}
+
+export const getTestFixture = async (params: Params) => {
+  // Create temp directory
+  const tempDirPath = await tempy.temporaryDirectory()
+  const devServerPort = await getPort()
+
+  // Write virtual filesystem files
+  if (params.vfs) {
+    for (const [filePath, content] of Object.entries(params.vfs)) {
+      await Bun.write(`${tempDirPath}/${filePath}`, content)
+    }
+  }
+
+  return {
+    tempDirPath,
+    devServerPort,
+    devServerUrl: `http://localhost:${devServerPort}`,
+  }
+}

package/tests/test1-dev-server-basic.test.ts

@@ -0,0 +1,40 @@
+import { test, expect, afterEach } from "bun:test"
+import { DevServer } from "cli/dev/DevServer"
+import { getTestFixture } from "tests/fixtures/get-test-fixture"
+
+test("test1 basic dev server filesystem watching", async () => {
+  const { tempDirPath, devServerPort, devServerUrl } = await getTestFixture({
+    vfs: {
+      "snippet.tsx": `
+      export const MyCircuit = () => (
+        <board width="10mm" height="10mm">
+          <chip name="U1" footprint="soic8" />
+        </board>
+      )
+      `,
+      "manual-edits.json": "{}",
+    },
+  })
+
+  const devServer = new DevServer({
+    port: devServerPort,
+    componentFilePath: `${tempDirPath}/snippet.tsx`,
+  })
+
+  await devServer.start()
+  await devServer.addEntrypoint()
+
+  const { file_list } = await devServer.fsKy.get("api/files/list").json()
+
+  expect(file_list.map((f) => f.file_path).sort()).toMatchInlineSnapshot(`
+[
+  "entrypoint.tsx",
+  "manual-edits.json",
+  "snippet.tsx",
+]
+`)
+
+  afterEach(async () => {
+    await devServer.stop()
+  })
+})

package/tsconfig.json

@@ -10,7 +10,8 @@
     "baseUrl": ".",
     "paths": {
       "lib/*": ["lib/*"],
-      "cli/*": ["cli/*"]
+      "cli/*": ["cli/*"],
+      "tests/*": ["tests/*"]
     },
 
     // Bundler mode