@tscircuit/cli 0.1.43-dev.3 → 0.1.43

package/dist/main.js

@@ -0,0 +1,1260 @@
+#!/usr/bin/env node
+
+// cli/main.ts
+import { Command } from "commander";
+
+// cli/init/register.ts
+import * as fs4 from "node:fs";
+import * as path5 from "node:path";
+
+// lib/shared/detect-pkg-manager.ts
+import fs from "fs";
+var detectPackageManager = () => {
+  const userAgent = process.env.npm_config_user_agent || "";
+  if (userAgent.startsWith("yarn")) return "yarn";
+  if (userAgent.startsWith("pnpm")) return "pnpm";
+  if (userAgent.startsWith("bun")) return "bun";
+  if (fs.existsSync("yarn.lock")) return "yarn";
+  if (fs.existsSync("pnpm-lock.yaml")) return "pnpm";
+  if (fs.existsSync("bun.lockb")) return "bun";
+  return "npm";
+};
+
+// lib/shared/setup-tsci-packages.ts
+import fs2 from "node:fs";
+import path from "node:path";
+import { execSync } from "node:child_process";
+function setupTsciProject(directory = process.cwd(), dependencies = ["@types/react", "@tscircuit/core"]) {
+  const projectPath = path.resolve(directory);
+  if (!fs2.existsSync(projectPath)) {
+    fs2.mkdirSync(projectPath, { recursive: true });
+  }
+  const packageManager = detectPackageManager();
+  console.log(`Initializing project in ${projectPath}...`);
+  process.chdir(projectPath);
+  if (!fs2.existsSync("package.json")) {
+    const initCommand = packageManager === "yarn" ? "yarn init -y" : packageManager === "pnpm" ? "pnpm init" : packageManager === "bun" ? "bun init -y" : "npm init -y";
+    execSync(initCommand, { stdio: "inherit" });
+    console.log("Project initialized successfully.");
+  }
+  const packageJsonPath = path.join(projectPath, "package.json");
+  const packageJson = JSON.parse(fs2.readFileSync(packageJsonPath, "utf-8"));
+  fs2.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2));
+  console.log("Updated package.json to remove unnecessary fields.");
+  if (dependencies.length > 0) {
+    console.log("Installing dependencies...");
+    const installCommand = packageManager === "yarn" ? `yarn add -D ${dependencies.join(" ")}` : packageManager === "pnpm" ? `pnpm add -D ${dependencies.join(" ")}` : packageManager === "bun" ? `bun add -D ${dependencies.join(" ")}` : `npm install -D ${dependencies.join(" ")}`;
+    execSync(installCommand, { stdio: "inherit" });
+    console.log("Dependencies installed successfully.");
+  }
+  return packageJson.name || "unknown";
+}
+
+// lib/shared/generate-ts-config.ts
+import path2 from "node:path";
+
+// lib/shared/write-file-if-not-exists.ts
+import fs3 from "fs";
+var writeFileIfNotExists = (filePath, content) => {
+  if (!fs3.existsSync(filePath)) {
+    fs3.writeFileSync(filePath, content.trimStart(), "utf-8");
+    console.info(`Created: ${filePath}`);
+  } else {
+    console.info(`Skipped: ${filePath} already exists`);
+  }
+};
+
+// lib/shared/generate-ts-config.ts
+var generateTsConfig = (dir) => {
+  const tsconfigPath = path2.join(dir, "tsconfig.json");
+  const tsconfigContent = JSON.stringify(
+    {
+      compilerOptions: {
+        target: "ES6",
+        module: "ESNext",
+        jsx: "react-jsx",
+        outDir: "dist",
+        strict: true,
+        esModuleInterop: true,
+        moduleResolution: "node",
+        skipLibCheck: true,
+        forceConsistentCasingInFileNames: true,
+        resolveJsonModule: true,
+        sourceMap: true,
+        allowSyntheticDefaultImports: true,
+        experimentalDecorators: true
+      }
+    },
+    null,
+    2
+  );
+  writeFileIfNotExists(tsconfigPath, tsconfigContent);
+};
+
+// lib/shared/generate-gitignore-file.ts
+import path3 from "node:path";
+var generateGitIgnoreFile = (dir) => {
+  const gitignorePath = path3.join(dir, ".gitignore");
+  const gitignoreContent = `# Dependencies
+node_modules/
+
+# Build output
+dist/
+build/
+
+# Environment variables
+.env
+.env.local
+.env.*.local
+
+# IDE files
+.vscode/
+.idea/
+*.swp
+*.swo
+
+# OS files
+.DS_Store
+Thumbs.db
+
+# Debug logs
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+`;
+  writeFileIfNotExists(gitignorePath, gitignoreContent);
+};
+
+// lib/shared/generate-package-json.ts
+import * as path4 from "node:path";
+var generatePackageJson = (dir) => {
+  const packageJsonPath = path4.join(dir, "package.json");
+  const packageJsonContent = {
+    name: path4.basename(dir),
+    version: "1.0.0",
+    description: "A TSCircuit project",
+    main: "index.tsx",
+    keywords: ["tscircuit", "electronics"],
+    scripts: {
+      dev: "tsci dev",
+      build: "tsci build"
+    }
+  };
+  writeFileIfNotExists(
+    packageJsonPath,
+    JSON.stringify(packageJsonContent, null, 2)
+  );
+};
+
+// cli/init/register.ts
+var registerInit = (program2) => {
+  program2.command("init").description(
+    "Initialize a new TSCircuit project in the specified directory (or current directory if none is provided)"
+  ).argument(
+    "[directory]",
+    "Directory name (optional, defaults to current directory)"
+  ).action((directory) => {
+    const projectDir = directory ? path5.resolve(process.cwd(), directory) : process.cwd();
+    fs4.mkdirSync(projectDir, { recursive: true });
+    writeFileIfNotExists(
+      path5.join(projectDir, "index.tsx"),
+      `
+import "@tscircuit/core";
+
+export default () => (
+  <board width="10mm" height="10mm">
+    <resistor resistance="1k" footprint="0402" name="R1" schX={3} pcbX={3} />
+    <capacitor capacitance="1000pF" footprint="0402" name="C1" schX={-3} pcbX={-3} />
+    <trace from=".R1 > .pin1" to=".C1 > .pin1" />
+  </board>
+);
+`
+    );
+    writeFileIfNotExists(
+      path5.join(projectDir, ".npmrc"),
+      `
+@tsci:registry=https://npm.tscircuit.com
+`
+    );
+    generatePackageJson(projectDir);
+    generateTsConfig(projectDir);
+    generateGitIgnoreFile(projectDir);
+    setupTsciProject(projectDir);
+    console.info(
+      `\u{1F389} Initialization complete! Run ${directory ? `"cd ${directory}" & ` : ""}"tsci dev" to start developing.`
+    );
+    process.exit(0);
+  });
+};
+
+// cli/dev/register.ts
+import * as fs11 from "node:fs";
+import * as net from "node:net";
+import * as path11 from "node:path";
+
+// lib/dependency-analysis/installNodeModuleTypesForSnippet.ts
+import * as fs5 from "node:fs";
+import * as path6 from "node:path";
+import * as ts from "typescript";
+async function installNodeModuleTypesForSnippet(snippetPath) {
+  const content = fs5.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 = path6.dirname(snippetPath);
+  while (projectRoot !== path6.parse(projectRoot).root) {
+    if (fs5.existsSync(path6.join(projectRoot, "package.json"))) {
+      break;
+    }
+    projectRoot = path6.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 = path6.join(
+          projectRoot,
+          "node_modules",
+          "@tsci",
+          `${owner}.${name}`
+        );
+        fs5.mkdirSync(packageDir, { recursive: true });
+        fs5.writeFileSync(path6.join(packageDir, "index.d.ts"), data.snippet.dts);
+      }
+    } catch (error) {
+      console.warn(`Error fetching types for ${importPath}:`, error);
+    }
+  }
+}
+
+// cli/dev/DevServer.ts
+import ky2 from "ky";
+
+// lib/server/createHttpServer.ts
+import * as http from "node:http";
+import * as fs6 from "node:fs";
+import * as path7 from "node:path";
+import { getNodeHandler } from "winterspec/adapters/node";
+
+// package.json
+var package_default = {
+  name: "@tscircuit/cli",
+  main: "dist/main.js",
+  type: "module",
+  version: "0.1.42",
+  bin: {
+    tsci: "./dist/main.js"
+  },
+  scripts: {
+    start: "bun run dev",
+    dev: "bun --hot ./cli/main.ts dev ./example-dir/snippet1-basic.tsx",
+    build: "tsup-node cli/main.ts --format esm --sourcemap inline",
+    format: "biome format --write .",
+    "format:check": "biome format .",
+    cli: "bun ./cli/main.ts"
+  },
+  devDependencies: {
+    "@biomejs/biome": "^1.9.4",
+    "@tscircuit/core": "^0.0.249",
+    "@tscircuit/fake-snippets": "^0.0.6",
+    "@types/bun": "^1.1.15",
+    "@types/configstore": "^6.0.2",
+    "@types/react": "^19.0.8",
+    "@types/semver": "^7.5.8",
+    "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/eval": "^0.0.96",
+    "@tscircuit/file-server": "^0.0.13",
+    "@tscircuit/runframe": "^0.0.167",
+    "bun-match-svg": "^0.0.9",
+    chokidar: "4.0.1",
+    "circuit-json-to-readable-netlist": "^0.0.8",
+    "circuit-to-svg": "^0.0.101",
+    commander: "^12.1.0",
+    configstore: "^7.0.0",
+    cosmiconfig: "^9.0.0",
+    delay: "^6.0.0",
+    "dsn-converter": "^0.0.63",
+    "jwt-decode": "^4.0.0",
+    ky: "^1.7.4",
+    "make-vfs": "^1.0.15",
+    "perfect-cli": "^1.0.20",
+    redaxios: "^0.5.1",
+    semver: "^7.6.3"
+  }
+};
+
+// lib/server/createHttpServer.ts
+import winterspecBundle from "@tscircuit/file-server/dist/bundle.js";
+
+// lib/site/getIndex.ts
+var getIndex = async () => {
+  return `<html>
+    <head>
+    </head>
+    <body>
+      <script src="https://cdn.tailwindcss.com"></script>
+      <div id="root">loading...</div>
+      <script>
+      globalThis.process = { env: { NODE_ENV: "production" } }
+      </script>
+      <script src="/standalone.min.js"></script>
+    </body>
+  </html>`;
+};
+
+// lib/server/createHttpServer.ts
+var createHttpServer = async (port = 3020) => {
+  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 || path7.resolve(
+        process.cwd(),
+        "node_modules",
+        "@tscircuit/runframe/dist/standalone.min.js"
+      );
+      try {
+        const content = fs6.readFileSync(standaloneFilePath, "utf8");
+        res.writeHead(200, {
+          "Content-Type": "application/javascript; charset=utf-8"
+        });
+        res.end(content);
+        return;
+      } catch (error) {
+        console.info(
+          "Local runframe standalone not found, falling back to the production version."
+        );
+      }
+      res.writeHead(302, {
+        Location: `https://cdn.jsdelivr.net/npm/@tscircuit/runframe@${package_default.dependencies["@tscircuit/runframe"].replace(/^[^0-9]+/, "")}/dist/standalone.min.js`
+      });
+      res.end();
+      return;
+    }
+    if (url.pathname === "/") {
+      const html = await getIndex();
+      res.writeHead(200, { "Content-Type": "text/html" });
+      res.end(html);
+      return;
+    }
+    if (url.pathname.startsWith("/api/")) {
+      req.url = req.url.replace("/api/", "/");
+      fileServerHandler(req, res);
+      return;
+    }
+    res.writeHead(404);
+    res.end("Not found");
+  });
+  return new Promise((resolve7) => {
+    server.listen(port, () => {
+      console.log(`Server running at http://localhost:${port}`);
+      resolve7({ server });
+    });
+  });
+};
+
+// lib/server/EventsWatcher.ts
+import { EventEmitter } from "events";
+var EventsWatcher = class extends EventEmitter {
+  lastPollTime;
+  pollInterval;
+  baseUrl;
+  polling = false;
+  timeoutId;
+  constructor(baseUrl = "http://localhost:3000", pollInterval = 1e3) {
+    super();
+    this.baseUrl = baseUrl;
+    this.pollInterval = pollInterval;
+    this.lastPollTime = (/* @__PURE__ */ new Date()).toISOString();
+  }
+  async start() {
+    if (this.polling) return;
+    this.polling = true;
+    await this.poll();
+  }
+  stop() {
+    this.polling = false;
+    if (this.timeoutId) {
+      clearTimeout(this.timeoutId);
+    }
+  }
+  async poll() {
+    if (!this.polling) return;
+    try {
+      const response = await fetch(
+        `${this.baseUrl}/api/events/list?since=${encodeURIComponent(this.lastPollTime)}`
+      );
+      if (!response.ok) {
+        throw new Error(`HTTP error! status: ${response.status}`);
+      }
+      const data = await response.json();
+      const latestEvent = data.event_list[data.event_list.length - 1];
+      this.lastPollTime = latestEvent ? latestEvent.created_at : (/* @__PURE__ */ new Date()).toISOString();
+      data.event_list.forEach((event) => {
+        this.emit(event.event_type, event);
+        this.emit("*", event);
+      });
+    } catch (error) {
+      this.emit("error", error);
+    }
+    this.timeoutId = globalThis.setTimeout(
+      () => this.poll(),
+      this.pollInterval
+    );
+  }
+};
+
+// cli/dev/DevServer.ts
+import path10 from "node:path";
+import fs10 from "node:fs";
+import * as chokidar from "chokidar";
+
+// lib/dependency-analysis/FilesystemTypesHandler.ts
+import * as fs8 from "node:fs";
+import * as path8 from "node:path";
+
+// lib/dependency-analysis/findImportsInSnippet.ts
+import * as fs7 from "node:fs";
+import * as ts2 from "typescript";
+function findImportsInSnippet(snippetPath) {
+  const content = fs7.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);
+  return imports;
+}
+
+// lib/dependency-analysis/FilesystemTypesHandler.ts
+var FilesystemTypesHandler = class {
+  projectRoot;
+  constructor(initialDir) {
+    this.projectRoot = this.findProjectRoot(initialDir);
+  }
+  async handleInitialTypeDependencies(filePath) {
+    console.log("Checking initial type dependencies...");
+    try {
+      if (!this.areTypesInstalled(filePath)) {
+        console.log("Installing missing initial types...");
+        await installNodeModuleTypesForSnippet(filePath);
+      }
+    } catch (error) {
+      console.warn("Error handling initial type dependencies:", error);
+    }
+  }
+  async handleFileTypeDependencies(filePath) {
+    try {
+      if (!this.areTypesInstalled(filePath)) {
+        console.log("Installing missing file types...");
+        await installNodeModuleTypesForSnippet(filePath);
+      }
+    } catch (error) {
+      console.warn("Failed to verify types:", error);
+    }
+  }
+  areTypesInstalled(filePath) {
+    const imports = findImportsInSnippet(filePath);
+    return imports.every((imp) => this.checkTypeExists(imp));
+  }
+  checkTypeExists(importPath) {
+    if (!importPath.startsWith("@tsci/")) return true;
+    const pathWithoutPrefix = importPath.replace("@tsci/", "");
+    const [owner, name] = pathWithoutPrefix.split(".");
+    const typePath = path8.join(
+      this.projectRoot,
+      "node_modules",
+      "@tsci",
+      `${owner}.${name}`,
+      "index.d.ts"
+    );
+    return fs8.existsSync(typePath);
+  }
+  findProjectRoot(startDir) {
+    let root = path8.resolve(startDir);
+    while (root !== path8.parse(root).root) {
+      if (fs8.existsSync(path8.join(root, "package.json"))) {
+        return root;
+      }
+      root = path8.dirname(root);
+    }
+    return startDir;
+  }
+};
+
+// lib/cli-config/index.ts
+import Configstore from "configstore";
+import { jwtDecode } from "jwt-decode";
+var cliConfig = new Configstore(
+  "tscircuit"
+);
+var getSessionToken = () => {
+  return cliConfig.get("sessionToken");
+};
+var setSessionToken = (token) => {
+  cliConfig.set("sessionToken", token);
+  const decoded = jwtDecode(token);
+  cliConfig.set("githubUsername", decoded.github_username);
+};
+var clearSession = () => {
+  cliConfig.delete("sessionToken");
+  cliConfig.delete("githubUsername");
+};
+var getRegistryApiUrl = () => {
+  return cliConfig.get("registryApiUrl") ?? "https://registry-api.tscircuit.com";
+};
+
+// lib/registry-api/get-ky.ts
+import ky from "ky";
+var prettyResponseErrorHook = async (_request, _options, response) => {
+  if (!response.ok) {
+    try {
+      const errorData = await response.json();
+      throw new Error(
+        `FAIL [${response.status}]: ${_request.method} ${new URL(_request.url).pathname} 
+
+ ${JSON.stringify(errorData, null, 2)}`
+      );
+    } catch (e) {
+    }
+  }
+};
+var getKy = () => {
+  return ky.create({
+    prefixUrl: getRegistryApiUrl(),
+    hooks: {
+      afterResponse: [prettyResponseErrorHook]
+    }
+  });
+};
+
+// lib/shared/push-snippet.ts
+import * as fs9 from "node:fs";
+import * as path9 from "node:path";
+import semver from "semver";
+var pushSnippet = async ({
+  filePath,
+  onExit = (code) => process.exit(code),
+  onError = (message) => console.error(message),
+  onSuccess = (message) => console.log(message)
+}) => {
+  const sessionToken = cliConfig.get("sessionToken");
+  if (!sessionToken) {
+    onError(
+      "You need to log in to save snippet. Run 'tsci login' to authenticate."
+    );
+    return onExit(1);
+  }
+  let snippetFilePath = null;
+  if (filePath) {
+    snippetFilePath = path9.resolve(filePath);
+  } else {
+    const defaultEntrypoint = path9.resolve("index.tsx");
+    if (fs9.existsSync(defaultEntrypoint)) {
+      snippetFilePath = defaultEntrypoint;
+      onSuccess("No file provided. Using 'index.tsx' as the entrypoint.");
+    } else {
+      onError(
+        "No entrypoint found. Run 'tsci init' to bootstrap a basic project."
+      );
+      return onExit(1);
+    }
+  }
+  const packageJsonPath = path9.resolve(
+    path9.join(path9.dirname(snippetFilePath), "package.json")
+  );
+  let packageJson = {};
+  if (fs9.existsSync(packageJsonPath)) {
+    try {
+      packageJson = JSON.parse(fs9.readFileSync(packageJsonPath).toString());
+    } catch {
+      onError("Invalid package.json provided");
+      return onExit(1);
+    }
+  }
+  if (!fs9.existsSync(snippetFilePath)) {
+    onError(`File not found: ${snippetFilePath}`);
+    return onExit(1);
+  }
+  const ky3 = getKy();
+  const packageName = (packageJson.name ?? path9.parse(snippetFilePath).name).replace(/^@/, "");
+  const packageAuthor = packageJson.author?.split(" ")[0] ?? cliConfig.get("githubUsername");
+  const packageIdentifier = `${packageAuthor}/${packageName}`;
+  let packageVersion = packageJson.version ?? await ky3.post("package_releases/list", {
+    json: { package_name: packageIdentifier }
+  }).json().then(
+    (response) => response.package_releases?.[response.package_releases.length - 1]?.version
+  ).catch((error) => {
+    onError(`Failed to retrieve latest package version: ${error}`);
+    return onExit(1);
+  });
+  if (!packageVersion) {
+    onError("Failed to retrieve package version.");
+    return onExit(1);
+  }
+  const updatePackageJsonVersion = (newVersion) => {
+    if (packageJson.version) {
+      try {
+        packageJson.version = newVersion ?? `${packageVersion}`;
+        fs9.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2));
+      } catch (error) {
+        onError(`Failed to update package.json version: ${error}`);
+      }
+    }
+  };
+  const doesPackageExist = await ky3.post("packages/get", {
+    json: { name: packageIdentifier },
+    throwHttpErrors: false
+  }).json().then((response) => !(response.error?.error_code === "package_not_found"));
+  if (!doesPackageExist) {
+    await ky3.post("packages/create", {
+      json: { name: packageIdentifier },
+      headers: { Authorization: `Bearer ${sessionToken}` }
+    }).catch((error) => {
+      onError(`Error creating package: ${error}`);
+      return onExit(1);
+    });
+  }
+  const doesReleaseExist = await ky3.post("package_releases/get", {
+    json: {
+      package_name_with_version: `${packageIdentifier}@${packageVersion}`
+    },
+    throwHttpErrors: false
+  }).json().then((response) => {
+    if (response.package_release?.version) {
+      packageVersion = response.package_release.version;
+      updatePackageJsonVersion(response.package_release.version);
+      return true;
+    }
+    return !(response.error?.error_code === "package_release_not_found");
+  });
+  if (doesReleaseExist) {
+    const bumpedVersion = semver.inc(packageVersion, "patch");
+    onSuccess(
+      `Incrementing Package Version ${packageVersion} -> ${bumpedVersion}`
+    );
+    packageVersion = bumpedVersion;
+    updatePackageJsonVersion(packageVersion);
+  }
+  await ky3.post("package_releases/create", {
+    json: {
+      package_name_with_version: `${packageIdentifier}@${packageVersion}`
+    },
+    throwHttpErrors: false
+  }).catch((error) => {
+    onError(`Error creating release: ${error}`);
+    return onExit(1);
+  });
+  onSuccess("\n");
+  const directoryFiles = fs9.readdirSync(path9.dirname(snippetFilePath));
+  for (const file of directoryFiles) {
+    const fileExtension = path9.extname(file).replace(".", "");
+    if (!["json", "tsx", "ts"].includes(fileExtension)) continue;
+    const fileContent = fs9.readFileSync(path9.join(path9.dirname(snippetFilePath), file)).toString() ?? "";
+    await ky3.post("package_files/create", {
+      json: {
+        file_path: file,
+        content_text: fileContent,
+        package_name_with_version: `${packageIdentifier}@${packageVersion}`
+      },
+      throwHttpErrors: false
+    }).then(() => {
+      onSuccess(`Uploaded file ${file} to the registry.`);
+    }).catch((error) => {
+      onError(`Error uploading file ${file}: ${error}`);
+    });
+  }
+  onSuccess(
+    [
+      `Successfully pushed package ${packageIdentifier}@${packageVersion} to the registry!`,
+      `https://tscircuit.com/${packageIdentifier}`
+    ].join(" ")
+  );
+};
+
+// cli/dev/DevServer.ts
+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;
+  typesHandler;
+  constructor({
+    port,
+    componentFilePath
+  }) {
+    this.port = port;
+    this.componentFilePath = componentFilePath;
+    this.projectDir = path10.dirname(componentFilePath);
+    this.fsKy = ky2.create({
+      prefixUrl: `http://localhost:${port}`
+    });
+    this.typesHandler = new FilesystemTypesHandler(this.projectDir);
+  }
+  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.eventsWatcher.on(
+      "REQUEST_TO_SAVE_SNIPPET",
+      this.saveSnippet.bind(this)
+    );
+    this.filesystemWatcher = chokidar.watch(this.projectDir, {
+      persistent: true,
+      ignoreInitial: true,
+      ignored: ["**/node_modules/**", "**/.git/**"]
+    });
+    this.filesystemWatcher.on(
+      "change",
+      (filePath) => this.handleFileChangedOnFilesystem(filePath)
+    );
+    this.filesystemWatcher.on(
+      "add",
+      (filePath) => this.handleFileChangedOnFilesystem(filePath)
+    );
+    this.upsertInitialFiles();
+    this.typesHandler?.handleInitialTypeDependencies(this.componentFilePath);
+  }
+  async addEntrypoint() {
+    const relativeComponentFilePath = path10.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();
+      fs10.writeFileSync(
+        path10.join(this.projectDir, "manual-edits.json"),
+        file.text_content
+      );
+    }
+  }
+  async handleFileChangedOnFilesystem(absoluteFilePath) {
+    const relativeFilePath = path10.relative(this.projectDir, absoluteFilePath);
+    if (relativeFilePath.includes("manual-edits.json")) return;
+    await this.typesHandler?.handleFileTypeDependencies(absoluteFilePath);
+    console.log(`${relativeFilePath} saved. Applying changes...`);
+    await this.fsKy.post("api/files/upsert", {
+      json: {
+        file_path: relativeFilePath,
+        text_content: fs10.readFileSync(absoluteFilePath, "utf-8"),
+        initiator: "filesystem_change"
+      }
+    }).json();
+  }
+  async upsertInitialFiles() {
+    const relevantFiles = /* @__PURE__ */ new Set([
+      "entrypoint.tsx",
+      "manual-edits.json",
+      "snippet.tsx",
+      path10.basename(this.componentFilePath)
+      // Include the main component file
+    ]);
+    const fileNames = fs10.readdirSync(this.projectDir);
+    for (const fileName of fileNames) {
+      if (fs10.statSync(path10.join(this.projectDir, fileName)).isDirectory() || !relevantFiles.has(fileName))
+        continue;
+      const fileContent = fs10.readFileSync(
+        path10.join(this.projectDir, fileName),
+        "utf-8"
+      );
+      await this.fsKy.post("api/files/upsert", {
+        json: {
+          file_path: fileName,
+          text_content: fileContent,
+          initiator: "filesystem_change"
+        }
+      });
+    }
+  }
+  async saveSnippet() {
+    const postEvent = async (event) => this.fsKy.post("api/events/create", {
+      json: { event_type: event },
+      throwHttpErrors: false
+    });
+    await pushSnippet({
+      filePath: this.componentFilePath,
+      onExit: (e) => {
+        console.error("Failed to save snippet", e);
+        postEvent("FAILED_TO_SAVE_SNIPPET");
+      },
+      onError: (e) => {
+        console.error("Failed to save snippet", e);
+        postEvent("FAILED_TO_SAVE_SNIPPET");
+      },
+      onSuccess: () => {
+        postEvent("SNIPPET_SAVED");
+      }
+    });
+  }
+  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", "3020").action(async (file, options) => {
+    let port = parseInt(options.port);
+    const isPortAvailable = (port2) => {
+      return new Promise((resolve7) => {
+        const server2 = net.createServer();
+        server2.once("error", () => resolve7(false));
+        server2.once("listening", () => {
+          server2.close(() => resolve7(true));
+        });
+        server2.listen(port2);
+      });
+    };
+    while (!await isPortAvailable(port)) {
+      console.log(`Port ${port} is in use, trying port ${port + 1}...`);
+      port += 1;
+    }
+    let absolutePath;
+    if (file) {
+      absolutePath = path11.resolve(file);
+      if (!absolutePath.endsWith(".tsx")) {
+        console.error("Error: Only .tsx files are supported");
+        return;
+      }
+    } else {
+      const entrypointPath = path11.resolve("index.tsx");
+      if (fs11.existsSync(entrypointPath)) {
+        absolutePath = entrypointPath;
+        console.log("Found entrypoint at:", entrypointPath);
+      } else {
+        console.log(
+          "No entrypoint found. Run 'tsci init' to bootstrap a basic project."
+        );
+        return;
+      }
+    }
+    const fileDir = path11.dirname(absolutePath);
+    try {
+      console.log("Installing types for imported snippets...");
+      await installNodeModuleTypesForSnippet(absolutePath);
+      console.log("Types installed successfully");
+    } catch (error) {
+      console.warn("Failed to install types:", error);
+    }
+    const server = new DevServer({
+      port,
+      componentFilePath: absolutePath
+    });
+    await server.start();
+    await server.addEntrypoint();
+  });
+};
+
+// cli/auth/login/register.ts
+import delay from "delay";
+var registerAuthLogin = (program2) => {
+  const loginAction = async () => {
+    const sessionToken = getSessionToken();
+    if (sessionToken) {
+      console.log(
+        "Already logged in! Use 'tsci logout' if you need to switch accounts."
+      );
+      return;
+    }
+    const ky3 = getKy();
+    const { login_page } = await ky3.post(
+      "sessions/login_page/create",
+      {
+        json: {}
+      }
+    ).json();
+    console.log("Please visit the following URL to log in:");
+    console.log(login_page.url);
+    while (true) {
+      const { login_page: new_login_page } = await ky3.post(
+        "sessions/login_page/get",
+        {
+          json: {
+            login_page_id: login_page.login_page_id
+          },
+          headers: {
+            Authorization: `Bearer ${login_page.login_page_auth_token}`
+          }
+        }
+      ).json();
+      if (new_login_page.was_login_successful) {
+        console.log("Logged in! Generating token...");
+        break;
+      }
+      if (new_login_page.is_expired) {
+        throw new Error("Login page expired");
+      }
+      await delay(1e3);
+    }
+    const { session } = await ky3.post(
+      "sessions/login_page/exchange_for_cli_session",
+      {
+        json: {
+          login_page_id: login_page.login_page_id
+        },
+        headers: {
+          Authorization: `Bearer ${login_page.login_page_auth_token}`
+        }
+      }
+    ).json();
+    setSessionToken(session.token);
+    console.log("\nReady to use!");
+  };
+  program2.commands.find((c) => c.name() === "auth").command("login").description("Authenticate CLI, login to registry").action(loginAction);
+  program2.command("login").description("Login to tscircuit registry").action(loginAction);
+};
+
+// cli/auth/logout/register.ts
+var registerAuthLogout = (program2) => {
+  const logoutAction = () => {
+    clearSession();
+    console.log("You have been logged out!");
+  };
+  program2.commands.find((c) => c.name() === "auth").command("logout").description("Logout from registry").action(logoutAction);
+  program2.command("logout").description("Logout from tscircuit registry").action(logoutAction);
+};
+
+// cli/auth/register.ts
+var registerAuth = (program2) => {
+  program2.command("auth").description("Login/logout");
+};
+
+// cli/config/register.ts
+var registerConfig = (program2) => {
+  program2.command("config").description("Manage tscircuit CLI configuration");
+};
+
+// cli/config/print/register.ts
+var registerConfigPrint = (program2) => {
+  program2.commands.find((c) => c.name() === "config").command("print").description("Print the current config").action(() => {
+    console.log(JSON.stringify(cliConfig.all, null, 2));
+  });
+};
+
+// cli/clone/register.ts
+import * as fs12 from "node:fs";
+import * as path12 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) => {
+    const match = snippetPath.match(/^(?:@tsci\/)?([^/.]+)[/.](.+)$/);
+    if (!match) {
+      console.error(
+        "Invalid snippet path. Use format: author/snippetName, author.snippetName, or @tsci/author.snippetName"
+      );
+      process.exit(1);
+    }
+    const [, author, snippetName] = match;
+    console.log(`Cloning ${author}/${snippetName}...`);
+    const ky3 = getKy();
+    let packageFileList;
+    try {
+      packageFileList = await ky3.post(
+        "package_files/list",
+        {
+          json: {
+            package_name: `${author}/${snippetName}`,
+            use_latest_version: true
+          }
+        }
+      ).json();
+    } catch (error) {
+      console.error(
+        "Failed to fetch package files:",
+        error instanceof Error ? error.message : error
+      );
+      process.exit(1);
+    }
+    const dirPath = path12.resolve(`${author}.${snippetName}`);
+    fs12.mkdirSync(dirPath, { recursive: true });
+    for (const fileInfo of packageFileList.package_files) {
+      const filePath = fileInfo.file_path.replace(/^\/|dist\//g, "");
+      if (!filePath) continue;
+      const fullPath = path12.join(dirPath, filePath);
+      fs12.mkdirSync(path12.dirname(fullPath), { recursive: true });
+      try {
+        const fileContent = await ky3.post(
+          "package_files/get",
+          {
+            json: {
+              package_name: `${author}/${snippetName}`,
+              file_path: fileInfo.file_path
+            }
+          }
+        ).json();
+        let fileText = fileContent.package_file.content_text;
+        if (filePath.endsWith(".tsx") && !fileText.includes("@tscircuit/core")) {
+          fileText = `import "@tscircuit/core";
+
+${fileText}`;
+        }
+        fs12.writeFileSync(fullPath, fileText);
+      } catch (error) {
+        console.warn(
+          `Skipping ${filePath} due to error:`,
+          error instanceof Error ? error.message : error
+        );
+      }
+    }
+    fs12.writeFileSync(
+      path12.join(dirPath, ".npmrc"),
+      "@tsci:registry=https://npm.tscircuit.com"
+    );
+    generateTsConfig(dirPath);
+    setupTsciProject(dirPath);
+    console.log(`Successfully cloned to ${dirPath}/`);
+    console.log(
+      `Run "cd ${path12.dirname(dirPath)} && tsci dev" to start developing.`
+    );
+  });
+};
+
+// cli/main.ts
+import { perfectCli } from "perfect-cli";
+import semver2 from "semver";
+
+// cli/export/register.ts
+import { createCircuitWebWorker } from "@tscircuit/eval";
+import webWorkerBundleUrl from "@tscircuit/eval/blob-url";
+import { getVirtualFileSystemFromDirPath } from "make-vfs";
+import path13 from "node:path";
+import fs13 from "node:fs";
+import {
+  convertCircuitJsonToSchematicSvg,
+  convertCircuitJsonToPcbSvg
+} from "circuit-to-svg";
+import { convertCircuitJsonToDsnString } from "dsn-converter";
+import { convertCircuitJsonToReadableNetlist } from "circuit-json-to-readable-netlist";
+var ALLOWED_FORMATS = [
+  "json",
+  "circuit-json",
+  "schematic-svg",
+  "pcb-svg",
+  "gerbers",
+  "readable-netlist",
+  "gltf",
+  "specctra-dsn"
+];
+var OUTPUT_EXTENSIONS = {
+  json: ".circuit.json",
+  "circuit-json": ".circuit.json",
+  "schematic-svg": "-schematic.svg",
+  "pcb-svg": "-pcb.svg",
+  gerbers: "-gerbers.zip",
+  "readable-netlist": "-readable.netlist",
+  gltf: ".gltf",
+  "specctra-dsn": ".dsn"
+};
+var registerExport = (program2) => {
+  program2.command("export").description("Export tscircuit code to various formats").argument("<file>", "Path to the snippet file").option("-f, --format <format>", "Output format").option("-o, --output <path>", "Output file path").action(async (file, options) => {
+    const { format = "circuit-json" } = options;
+    let { output } = options;
+    if (!ALLOWED_FORMATS.includes(format)) {
+      throw new Error(
+        `Invalid format: ${format}
+Supported formats: ${ALLOWED_FORMATS.join(",")}`
+      );
+    }
+    if (!output) {
+      output = path13.basename(file).replace(/\.[^.]+$/, "");
+    }
+    const worker = await createCircuitWebWorker({
+      webWorkerUrl: webWorkerBundleUrl
+    });
+    const projectDir = path13.dirname(file);
+    const relativeComponentPath = path13.relative(projectDir, file);
+    await worker.executeWithFsMap({
+      entrypoint: "entrypoint.tsx",
+      fsMap: {
+        ...await getVirtualFileSystemFromDirPath({
+          dirPath: projectDir,
+          contentFormat: "string"
+        }),
+        "entrypoint.tsx": `
+import MyCircuit from "./${relativeComponentPath}"
+
+circuit.add(<MyCircuit />)
+        `
+      }
+    });
+    await worker.renderUntilSettled();
+    const circuitJson = await worker.getCircuitJson();
+    const outputPath = path13.join(
+      projectDir,
+      `${output}${OUTPUT_EXTENSIONS[format]}`
+    );
+    let outputContent;
+    switch (format) {
+      case "schematic-svg":
+        outputContent = convertCircuitJsonToSchematicSvg(circuitJson);
+        break;
+      case "pcb-svg":
+        outputContent = convertCircuitJsonToPcbSvg(circuitJson);
+        break;
+      case "specctra-dsn":
+        outputContent = convertCircuitJsonToDsnString(circuitJson);
+        break;
+      case "readable-netlist":
+        outputContent = convertCircuitJsonToReadableNetlist(circuitJson);
+        break;
+      default:
+        outputContent = JSON.stringify(circuitJson);
+    }
+    fs13.writeFileSync(outputPath, outputContent);
+    console.log(`Exported to ${outputPath}`);
+    process.exit(0);
+  });
+};
+
+// cli/auth/print-token/register.ts
+var registerAuthPrintToken = (program2) => {
+  program2.commands.find((c) => c.name() === "auth").command("print-token").description("Prints your auth token").action(() => {
+    const token = cliConfig.get("sessionToken");
+    if (!token) return console.log("You need to log in to access this.");
+    console.log("Your Token:\n", token);
+  });
+};
+
+// cli/auth/set-token/register.ts
+function validateJWTLength(token) {
+  const parts = token.split(".");
+  if (parts.length === 3 && parts.every((part) => part.length > 0)) {
+    return true;
+  } else {
+    return false;
+  }
+}
+var registerAuthSetToken = (program2) => {
+  program2.commands.find((c) => c.name() === "auth").command("set-token").description("Explicitly set your auth token").argument("<token>", "New token to manually configure").action((token) => {
+    if (!validateJWTLength(token))
+      return console.log("Invalid token provided");
+    setSessionToken(token);
+    console.log("Token manually updated.");
+  });
+};
+
+// cli/push/register.ts
+var registerPush = (program2) => {
+  program2.command("push").description("Save snippet code to Registry API").argument("[file]", "Path to the snippet file").action(async (filePath) => {
+    await pushSnippet({
+      filePath,
+      onExit: (code) => process.exit(code),
+      onError: (message) => console.error(message),
+      onSuccess: (message) => console.log(message)
+    });
+  });
+};
+
+// cli/main.ts
+var program = new Command();
+program.name("tsci").description("CLI for developing tscircuit snippets").version(semver2.inc(package_default.version, "patch") ?? package_default.version);
+registerInit(program);
+registerDev(program);
+registerClone(program);
+registerPush(program);
+registerAuth(program);
+registerAuthLogin(program);
+registerAuthLogout(program);
+registerAuthPrintToken(program);
+registerAuthSetToken(program);
+registerConfig(program);
+registerConfigPrint(program);
+registerExport(program);
+if (process.argv.length === 2) {
+  perfectCli(program, process.argv);
+} else {
+  program.parse();
+}
+export {
+  program
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../cli/main.ts", "../cli/init/register.ts", "../lib/shared/detect-pkg-manager.ts", "../lib/shared/setup-tsci-packages.ts", "../lib/shared/generate-ts-config.ts", "../lib/shared/write-file-if-not-exists.ts", "../lib/shared/generate-gitignore-file.ts", "../lib/shared/generate-package-json.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/dependency-analysis/FilesystemTypesHandler.ts", "../lib/dependency-analysis/findImportsInSnippet.ts", "../lib/cli-config/index.ts", "../lib/registry-api/get-ky.ts", "../lib/shared/push-snippet.ts", "../cli/auth/login/register.ts", "../cli/auth/logout/register.ts", "../cli/auth/register.ts", "../cli/config/register.ts", "../cli/config/print/register.ts", "../cli/clone/register.ts", "../cli/export/register.ts", "../cli/auth/print-token/register.ts", "../cli/auth/set-token/register.ts", "../cli/push/register.ts"],
  "sourcesContent": ["#!/usr/bin/env node\nimport { Command } from \"commander\"\nimport { registerInit } from \"./init/register\"\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\"\nimport semver from \"semver\"\nimport { registerExport } from \"./export/register\"\nimport { registerAuthPrintToken } from \"./auth/print-token/register\"\nimport { registerAuthSetToken } from \"./auth/set-token/register\"\nimport { registerPush } from \"./push/register\"\n\nexport const program = new Command()\n\nprogram\n  .name(\"tsci\")\n  .description(\"CLI for developing tscircuit snippets\")\n  // HACK: at build time the version is old, we need to\n  // fix this at some point...\n  .version(semver.inc(pkg.version, \"patch\") ?? pkg.version)\n\nregisterInit(program)\n\nregisterDev(program)\nregisterClone(program)\nregisterPush(program)\n\nregisterAuth(program)\nregisterAuthLogin(program)\nregisterAuthLogout(program)\nregisterAuthPrintToken(program)\nregisterAuthSetToken(program)\n\nregisterConfig(program)\nregisterConfigPrint(program)\n\nregisterExport(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 { execSync } from \"node:child_process\"\nimport * as fs from \"node:fs\"\nimport * as path from \"node:path\"\nimport { setupTsciProject } from \"lib/shared/setup-tsci-packages\"\nimport { generateTsConfig } from \"lib/shared/generate-ts-config\"\nimport { writeFileIfNotExists } from \"lib/shared/write-file-if-not-exists\"\nimport { generateGitIgnoreFile } from \"lib/shared/generate-gitignore-file\"\nimport { generatePackageJson } from \"lib/shared/generate-package-json\"\n\nexport const registerInit = (program: Command) => {\n  program\n    .command(\"init\")\n    .description(\n      \"Initialize a new TSCircuit project in the specified directory (or current directory if none is provided)\",\n    )\n    .argument(\n      \"[directory]\",\n      \"Directory name (optional, defaults to current directory)\",\n    )\n    .action((directory?: string) => {\n      const projectDir = directory\n        ? path.resolve(process.cwd(), directory)\n        : process.cwd()\n\n      // Ensure the directory exists\n      fs.mkdirSync(projectDir, { recursive: true })\n\n      // Create essential project files\n      writeFileIfNotExists(\n        path.join(projectDir, \"index.tsx\"),\n        `\nimport \"@tscircuit/core\";\n\nexport default () => (\n  <board width=\"10mm\" height=\"10mm\">\n    <resistor resistance=\"1k\" footprint=\"0402\" name=\"R1\" schX={3} pcbX={3} />\n    <capacitor capacitance=\"1000pF\" footprint=\"0402\" name=\"C1\" schX={-3} pcbX={-3} />\n    <trace from=\".R1 > .pin1\" to=\".C1 > .pin1\" />\n  </board>\n);\n`,\n      )\n\n      writeFileIfNotExists(\n        path.join(projectDir, \".npmrc\"),\n        `\n@tsci:registry=https://npm.tscircuit.com\n`,\n      )\n\n      // Generate package.json\n      generatePackageJson(projectDir)\n      // Generate tsconfig.json\n      generateTsConfig(projectDir)\n      // Create .gitignore file\n      generateGitIgnoreFile(projectDir)\n      // Setup project dependencies\n      setupTsciProject(projectDir)\n\n      console.info(\n        `\uD83C\uDF89 Initialization complete! Run ${directory ? `\"cd ${directory}\" & ` : \"\"}\"tsci dev\" to start developing.`,\n      )\n      process.exit(0)\n    })\n}\n", "import fs from \"fs\"\n\n// Detect the package manager being used in the project\nexport const detectPackageManager = (): string => {\n  const userAgent = process.env.npm_config_user_agent || \"\"\n  if (userAgent.startsWith(\"yarn\")) return \"yarn\"\n  if (userAgent.startsWith(\"pnpm\")) return \"pnpm\"\n  if (userAgent.startsWith(\"bun\")) return \"bun\"\n\n  if (fs.existsSync(\"yarn.lock\")) return \"yarn\"\n  if (fs.existsSync(\"pnpm-lock.yaml\")) return \"pnpm\"\n  if (fs.existsSync(\"bun.lockb\")) return \"bun\"\n\n  return \"npm\" // Default to npm\n}\n", "import { detectPackageManager } from \"./detect-pkg-manager\"\nimport fs from \"node:fs\"\nimport path from \"node:path\"\nimport { execSync } from \"node:child_process\"\n\nexport function setupTsciProject(\n  directory = process.cwd(),\n  dependencies = [\"@types/react\", \"@tscircuit/core\"],\n) {\n  const projectPath = path.resolve(directory)\n  if (!fs.existsSync(projectPath)) {\n    fs.mkdirSync(projectPath, { recursive: true })\n  }\n  const packageManager = detectPackageManager()\n\n  console.log(`Initializing project in ${projectPath}...`)\n  process.chdir(projectPath)\n\n  if (!fs.existsSync(\"package.json\")) {\n    const initCommand =\n      packageManager === \"yarn\"\n        ? \"yarn init -y\"\n        : packageManager === \"pnpm\"\n          ? \"pnpm init\"\n          : packageManager === \"bun\"\n            ? \"bun init -y\"\n            : \"npm init -y\"\n\n    execSync(initCommand, { stdio: \"inherit\" })\n    console.log(\"Project initialized successfully.\")\n  }\n\n  // Read and modify package.json\n  const packageJsonPath = path.join(projectPath, \"package.json\")\n  const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, \"utf-8\"))\n\n  fs.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2))\n  console.log(\"Updated package.json to remove unnecessary fields.\")\n\n  if (dependencies.length > 0) {\n    console.log(\"Installing dependencies...\")\n    const installCommand =\n      packageManager === \"yarn\"\n        ? `yarn add -D ${dependencies.join(\" \")}`\n        : packageManager === \"pnpm\"\n          ? `pnpm add -D ${dependencies.join(\" \")}`\n          : packageManager === \"bun\"\n            ? `bun add -D ${dependencies.join(\" \")}`\n            : `npm install -D ${dependencies.join(\" \")}`\n\n    execSync(installCommand, { stdio: \"inherit\" })\n    console.log(\"Dependencies installed successfully.\")\n  }\n\n  return packageJson.name || \"unknown\"\n}\n", "import path from \"node:path\"\nimport { writeFileIfNotExists } from \"./write-file-if-not-exists\"\n\n// Generate a React-compatible tsconfig.json\nexport const generateTsConfig = (dir: string) => {\n  const tsconfigPath = path.join(dir, \"tsconfig.json\")\n  const tsconfigContent = JSON.stringify(\n    {\n      compilerOptions: {\n        target: \"ES6\",\n        module: \"ESNext\",\n        jsx: \"react-jsx\",\n        outDir: \"dist\",\n        strict: true,\n        esModuleInterop: true,\n        moduleResolution: \"node\",\n        skipLibCheck: true,\n        forceConsistentCasingInFileNames: true,\n        resolveJsonModule: true,\n        sourceMap: true,\n        allowSyntheticDefaultImports: true,\n        experimentalDecorators: true,\n      },\n    },\n    null,\n    2,\n  )\n  writeFileIfNotExists(tsconfigPath, tsconfigContent)\n}\n", "import fs from \"fs\"\n\nexport const writeFileIfNotExists = (filePath: string, content: string) => {\n  if (!fs.existsSync(filePath)) {\n    fs.writeFileSync(filePath, content.trimStart(), \"utf-8\")\n    console.info(`Created: ${filePath}`)\n  } else {\n    console.info(`Skipped: ${filePath} already exists`)\n  }\n}\n", "import { writeFileIfNotExists } from \"./write-file-if-not-exists\"\nimport path from \"node:path\"\n\nexport const generateGitIgnoreFile = (dir: string) => {\n  const gitignorePath = path.join(dir, \".gitignore\")\n  const gitignoreContent = `# Dependencies\nnode_modules/\n\n# Build output\ndist/\nbuild/\n\n# Environment variables\n.env\n.env.local\n.env.*.local\n\n# IDE files\n.vscode/\n.idea/\n*.swp\n*.swo\n\n# OS files\n.DS_Store\nThumbs.db\n\n# Debug logs\nnpm-debug.log*\nyarn-debug.log*\nyarn-error.log*\n`\n\n  writeFileIfNotExists(gitignorePath, gitignoreContent)\n}\n", "import * as path from \"node:path\"\nimport { writeFileIfNotExists } from \"./write-file-if-not-exists\"\n\nexport const generatePackageJson = (dir: string) => {\n  const packageJsonPath = path.join(dir, \"package.json\")\n  const packageJsonContent = {\n    name: path.basename(dir),\n    version: \"1.0.0\",\n    description: \"A TSCircuit project\",\n    main: \"index.tsx\",\n    keywords: [\"tscircuit\", \"electronics\"],\n    scripts: {\n      dev: \"tsci dev\",\n      build: \"tsci build\",\n    },\n  }\n\n  writeFileIfNotExists(\n    packageJsonPath,\n    JSON.stringify(packageJsonContent, null, 2),\n  )\n}\n", "import type { Command } from \"commander\"\nimport * as fs from \"node:fs\"\nimport * as net from \"node:net\"\nimport * as path from \"node:path\"\nimport { installNodeModuleTypesForSnippet } from \"../../lib/dependency-analysis/installNodeModuleTypesForSnippet\"\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\", \"3020\")\n    .action(async (file: string, options: { port: string }) => {\n      let port = parseInt(options.port)\n\n      const isPortAvailable = (port: number): Promise<boolean> => {\n        return new Promise((resolve) => {\n          const server = net.createServer()\n          server.once(\"error\", () => resolve(false))\n          server.once(\"listening\", () => {\n            server.close(() => resolve(true))\n          })\n          server.listen(port)\n        })\n      }\n\n      while (!(await isPortAvailable(port))) {\n        console.log(`Port ${port} is in use, trying port ${port + 1}...`)\n        port += 1\n      }\n\n      let absolutePath: string\n\n      if (file) {\n        absolutePath = path.resolve(file)\n        if (!absolutePath.endsWith(\".tsx\")) {\n          console.error(\"Error: Only .tsx files are supported\")\n          return\n        }\n      } else {\n        const entrypointPath = path.resolve(\"index.tsx\")\n        if (fs.existsSync(entrypointPath)) {\n          absolutePath = entrypointPath\n          console.log(\"Found entrypoint at:\", entrypointPath)\n        } else {\n          console.log(\n            \"No entrypoint found. Run 'tsci init' to bootstrap a basic project.\",\n          )\n          return\n        }\n      }\n\n      const fileDir = path.dirname(absolutePath)\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\"\nimport { FilesystemTypesHandler } from \"lib/dependency-analysis/FilesystemTypesHandler\"\nimport { pushSnippet } from \"lib/shared/push-snippet\"\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  private typesHandler?: FilesystemTypesHandler\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    this.typesHandler = new FilesystemTypesHandler(this.projectDir)\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.eventsWatcher.on(\n      \"REQUEST_TO_SAVE_SNIPPET\",\n      this.saveSnippet.bind(this),\n    )\n\n    this.filesystemWatcher = chokidar.watch(this.projectDir, {\n      persistent: true,\n      ignoreInitial: true,\n      ignored: [\"**/node_modules/**\", \"**/.git/**\"],\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    this.typesHandler?.handleInitialTypeDependencies(this.componentFilePath)\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    // 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.typesHandler?.handleFileTypeDependencies(absoluteFilePath)\n\n    console.log(`${relativeFilePath} saved. Applying changes...`)\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    // Define the list of files we care about\n    const relevantFiles = new Set([\n      \"entrypoint.tsx\",\n      \"manual-edits.json\",\n      \"snippet.tsx\",\n      path.basename(this.componentFilePath), // Include the main component file\n    ])\n\n    // Scan project directory for relevant files and upsert them\n    const fileNames = fs.readdirSync(this.projectDir)\n    for (const fileName of fileNames) {\n      // Skip directories and non-relevant files\n      if (\n        fs.statSync(path.join(this.projectDir, fileName)).isDirectory() ||\n        !relevantFiles.has(fileName)\n      )\n        continue\n      const fileContent = fs.readFileSync(\n        path.join(this.projectDir, fileName),\n        \"utf-8\",\n      )\n      await this.fsKy.post(\"api/files/upsert\", {\n        json: {\n          file_path: fileName,\n          text_content: fileContent,\n          initiator: \"filesystem_change\",\n        },\n      })\n    }\n  }\n\n  private async saveSnippet() {\n    const postEvent = async (\n      event: \"FAILED_TO_SAVE_SNIPPET\" | \"SNIPPET_SAVED\",\n    ) =>\n      this.fsKy.post(\"api/events/create\", {\n        json: { event_type: event },\n        throwHttpErrors: false,\n      })\n\n    await pushSnippet({\n      filePath: this.componentFilePath,\n      onExit: (e) => {\n        console.error(\"Failed to save snippet\", e)\n        postEvent(\"FAILED_TO_SAVE_SNIPPET\")\n      },\n      onError: (e) => {\n        console.error(\"Failed to save snippet\", e)\n        postEvent(\"FAILED_TO_SAVE_SNIPPET\")\n      },\n      onSuccess: () => {\n        postEvent(\"SNIPPET_SAVED\")\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 = 3020) => {\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.info(\n          \"Local runframe standalone not found, falling back to the production version.\",\n        )\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.42\",\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/snippet1-basic.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    \"@tscircuit/fake-snippets\": \"^0.0.6\",\n    \"@types/bun\": \"^1.1.15\",\n    \"@types/configstore\": \"^6.0.2\",\n    \"@types/react\": \"^19.0.8\",\n    \"@types/semver\": \"^7.5.8\",\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/eval\": \"^0.0.96\",\n    \"@tscircuit/file-server\": \"^0.0.13\",\n    \"@tscircuit/runframe\": \"^0.0.167\",\n    \"bun-match-svg\": \"^0.0.9\",\n    \"chokidar\": \"4.0.1\",\n    \"circuit-json-to-readable-netlist\": \"^0.0.8\",\n    \"circuit-to-svg\": \"^0.0.101\",\n    \"commander\": \"^12.1.0\",\n    \"configstore\": \"^7.0.0\",\n    \"cosmiconfig\": \"^9.0.0\",\n    \"delay\": \"^6.0.0\",\n    \"dsn-converter\": \"^0.0.63\",\n    \"jwt-decode\": \"^4.0.0\",\n    \"ky\": \"^1.7.4\",\n    \"make-vfs\": \"^1.0.15\",\n    \"perfect-cli\": \"^1.0.20\",\n    \"redaxios\": \"^0.5.1\",\n    \"semver\": \"^7.6.3\"\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 * as fs from \"node:fs\"\nimport * as path from \"node:path\"\nimport { findImportsInSnippet } from \"./findImportsInSnippet\"\nimport { installNodeModuleTypesForSnippet } from \"./installNodeModuleTypesForSnippet\"\n\nexport class FilesystemTypesHandler {\n  private projectRoot: string\n\n  constructor(initialDir: string) {\n    this.projectRoot = this.findProjectRoot(initialDir)\n  }\n\n  async handleInitialTypeDependencies(filePath: string) {\n    console.log(\"Checking initial type dependencies...\")\n    try {\n      if (!this.areTypesInstalled(filePath)) {\n        console.log(\"Installing missing initial types...\")\n        await installNodeModuleTypesForSnippet(filePath)\n      }\n    } catch (error) {\n      console.warn(\"Error handling initial type dependencies:\", error)\n    }\n  }\n\n  async handleFileTypeDependencies(filePath: string) {\n    try {\n      if (!this.areTypesInstalled(filePath)) {\n        console.log(\"Installing missing file types...\")\n        await installNodeModuleTypesForSnippet(filePath)\n      }\n    } catch (error) {\n      console.warn(\"Failed to verify types:\", error)\n    }\n  }\n\n  private areTypesInstalled(filePath: string): boolean {\n    const imports = findImportsInSnippet(filePath)\n    return imports.every((imp) => this.checkTypeExists(imp))\n  }\n\n  private checkTypeExists(importPath: string): boolean {\n    if (!importPath.startsWith(\"@tsci/\")) return true\n\n    const pathWithoutPrefix = importPath.replace(\"@tsci/\", \"\")\n    const [owner, name] = pathWithoutPrefix.split(\".\")\n\n    const typePath = path.join(\n      this.projectRoot,\n      \"node_modules\",\n      \"@tsci\",\n      `${owner}.${name}`,\n      \"index.d.ts\",\n    )\n\n    return fs.existsSync(typePath)\n  }\n\n  private findProjectRoot(startDir: string): string {\n    let root = path.resolve(startDir)\n    while (root !== path.parse(root).root) {\n      if (fs.existsSync(path.join(root, \"package.json\"))) {\n        return root\n      }\n      root = path.dirname(root)\n    }\n    return startDir\n  }\n}\n", "import * as fs from \"node:fs\"\nimport * as ts from \"typescript\"\n\nexport function findImportsInSnippet(snippetPath: string): 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  return imports\n}\n", "import Configstore from \"configstore\"\nimport type { TypedConfigstore } from \"./TypedConfigStore\"\nimport { jwtDecode } from \"jwt-decode\"\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 getSessionToken = (): string | undefined => {\n  return cliConfig.get(\"sessionToken\")\n}\n\nexport const setSessionToken = (token: string) => {\n  cliConfig.set(\"sessionToken\", token)\n  const decoded = jwtDecode<{\n    github_username: string\n  }>(token)\n  cliConfig.set(\"githubUsername\", decoded.github_username)\n}\n\nexport const clearSession = () => {\n  cliConfig.delete(\"sessionToken\")\n  cliConfig.delete(\"githubUsername\")\n}\n\nexport const getRegistryApiUrl = (): string => {\n  return cliConfig.get(\"registryApiUrl\") ?? \"https://registry-api.tscircuit.com\"\n}\n", "import { getRegistryApiUrl } from \"lib/cli-config\"\nimport ky, { type AfterResponseHook } from \"ky\"\n\nexport const 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 { cliConfig } from \"lib/cli-config\"\nimport { getKy } from \"lib/registry-api/get-ky\"\nimport * as fs from \"node:fs\"\nimport * as path from \"node:path\"\nimport semver from \"semver\"\n\ntype PushOptions = {\n  filePath?: string\n  onExit?: (code: number) => void\n  onError?: (message: string) => void\n  onSuccess?: (message: string) => void\n}\n\nexport const pushSnippet = async ({\n  filePath,\n  onExit = (code) => process.exit(code),\n  onError = (message) => console.error(message),\n  onSuccess = (message) => console.log(message),\n}: PushOptions) => {\n  const sessionToken = cliConfig.get(\"sessionToken\")\n  if (!sessionToken) {\n    onError(\n      \"You need to log in to save snippet. Run 'tsci login' to authenticate.\",\n    )\n    return onExit(1)\n  }\n\n  let snippetFilePath: string | null = null\n  if (filePath) {\n    snippetFilePath = path.resolve(filePath)\n  } else {\n    const defaultEntrypoint = path.resolve(\"index.tsx\")\n    if (fs.existsSync(defaultEntrypoint)) {\n      snippetFilePath = defaultEntrypoint\n      onSuccess(\"No file provided. Using 'index.tsx' as the entrypoint.\")\n    } else {\n      onError(\n        \"No entrypoint found. Run 'tsci init' to bootstrap a basic project.\",\n      )\n      return onExit(1)\n    }\n  }\n\n  const packageJsonPath = path.resolve(\n    path.join(path.dirname(snippetFilePath), \"package.json\"),\n  )\n  let packageJson: { name?: string; author?: string; version?: string } = {}\n  if (fs.existsSync(packageJsonPath)) {\n    try {\n      packageJson = JSON.parse(fs.readFileSync(packageJsonPath).toString())\n    } catch {\n      onError(\"Invalid package.json provided\")\n      return onExit(1)\n    }\n  }\n\n  if (!fs.existsSync(snippetFilePath)) {\n    onError(`File not found: ${snippetFilePath}`)\n    return onExit(1)\n  }\n\n  const ky = getKy()\n  const packageName = (\n    packageJson.name ?? path.parse(snippetFilePath).name\n  ).replace(/^@/, \"\")\n  const packageAuthor =\n    packageJson.author?.split(\" \")[0] ?? cliConfig.get(\"githubUsername\")\n  const packageIdentifier = `${packageAuthor}/${packageName}`\n\n  let packageVersion =\n    packageJson.version ??\n    (await ky\n      .post<{\n        error?: { error_code: string }\n        package_releases?: { version: string; is_latest: boolean }[]\n      }>(\"package_releases/list\", {\n        json: { package_name: packageIdentifier },\n      })\n      .json()\n      .then(\n        (response) =>\n          response.package_releases?.[response.package_releases.length - 1]\n            ?.version,\n      )\n      .catch((error) => {\n        onError(`Failed to retrieve latest package version: ${error}`)\n        return onExit(1)\n      }))\n\n  if (!packageVersion) {\n    onError(\"Failed to retrieve package version.\")\n    return onExit(1)\n  }\n\n  const updatePackageJsonVersion = (newVersion?: string) => {\n    if (packageJson.version) {\n      try {\n        packageJson.version = newVersion ?? `${packageVersion}`\n        fs.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2))\n      } catch (error) {\n        onError(`Failed to update package.json version: ${error}`)\n      }\n    }\n  }\n\n  const doesPackageExist = await ky\n    .post<{ error?: { error_code: string } }>(\"packages/get\", {\n      json: { name: packageIdentifier },\n      throwHttpErrors: false,\n    })\n    .json()\n    .then((response) => !(response.error?.error_code === \"package_not_found\"))\n\n  if (!doesPackageExist) {\n    await ky\n      .post(\"packages/create\", {\n        json: { name: packageIdentifier },\n        headers: { Authorization: `Bearer ${sessionToken}` },\n      })\n      .catch((error) => {\n        onError(`Error creating package: ${error}`)\n        return onExit(1)\n      })\n  }\n\n  const doesReleaseExist = await ky\n    .post<{\n      error?: { error_code: string }\n      package_release?: { version: string }\n    }>(\"package_releases/get\", {\n      json: {\n        package_name_with_version: `${packageIdentifier}@${packageVersion}`,\n      },\n      throwHttpErrors: false,\n    })\n    .json()\n    .then((response) => {\n      if (response.package_release?.version) {\n        packageVersion = response.package_release.version\n        updatePackageJsonVersion(response.package_release.version)\n        return true\n      }\n      return !(response.error?.error_code === \"package_release_not_found\")\n    })\n\n  if (doesReleaseExist) {\n    const bumpedVersion = semver.inc(packageVersion, \"patch\")!\n    onSuccess(\n      `Incrementing Package Version ${packageVersion} -> ${bumpedVersion}`,\n    )\n    packageVersion = bumpedVersion\n    updatePackageJsonVersion(packageVersion)\n  }\n\n  await ky\n    .post(\"package_releases/create\", {\n      json: {\n        package_name_with_version: `${packageIdentifier}@${packageVersion}`,\n      },\n      throwHttpErrors: false,\n    })\n    .catch((error) => {\n      onError(`Error creating release: ${error}`)\n      return onExit(1)\n    })\n\n  onSuccess(\"\\n\")\n\n  const directoryFiles = fs.readdirSync(path.dirname(snippetFilePath))\n  for (const file of directoryFiles) {\n    const fileExtension = path.extname(file).replace(\".\", \"\")\n    if (![\"json\", \"tsx\", \"ts\"].includes(fileExtension)) continue\n    const fileContent =\n      fs\n        .readFileSync(path.join(path.dirname(snippetFilePath), file))\n        .toString() ?? \"\"\n    await ky\n      .post(\"package_files/create\", {\n        json: {\n          file_path: file,\n          content_text: fileContent,\n          package_name_with_version: `${packageIdentifier}@${packageVersion}`,\n        },\n        throwHttpErrors: false,\n      })\n      .then(() => {\n        onSuccess(`Uploaded file ${file} to the registry.`)\n      })\n      .catch((error) => {\n        onError(`Error uploading file ${file}: ${error}`)\n      })\n  }\n\n  onSuccess(\n    [\n      `Successfully pushed package ${packageIdentifier}@${packageVersion} to the registry!`,\n      `https://tscircuit.com/${packageIdentifier}`,\n    ].join(\" \"),\n  )\n}\n", "import type { Command } from \"commander\"\nimport { setSessionToken, getSessionToken } 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  // Define the login action once to share between both commands\n  const loginAction = async () => {\n    const sessionToken = getSessionToken()\n    if (sessionToken) {\n      console.log(\n        \"Already logged in! Use 'tsci logout' if you need to switch accounts.\",\n      )\n      return\n    }\n\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    setSessionToken(session.token)\n    console.log(\"\\nReady to use!\")\n  }\n\n  // Register the auth login subcommand\n  program.commands\n    .find((c) => c.name() === \"auth\")!\n    .command(\"login\")\n    .description(\"Authenticate CLI, login to registry\")\n    .action(loginAction)\n\n  // Register the top-level login command as an alias\n  program\n    .command(\"login\")\n    .description(\"Login to tscircuit registry\")\n    .action(loginAction)\n}\n", "import type { Command } from \"commander\"\nimport { clearSession } from \"lib/cli-config\"\n\nexport const registerAuthLogout = (program: Command) => {\n  const logoutAction = () => {\n    clearSession()\n    console.log(\"You have been logged out!\")\n  }\n\n  // Register the auth logout subcommand\n  program.commands\n    .find((c) => c.name() === \"auth\")!\n    .command(\"logout\")\n    .description(\"Logout from registry\")\n    .action(logoutAction)\n\n  // Register the top-level logout command as an alias\n  program\n    .command(\"logout\")\n    .description(\"Logout from tscircuit registry\")\n    .action(logoutAction)\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\"\nimport { setupTsciProject } from \"lib/shared/setup-tsci-packages\"\nimport { generateTsConfig } from \"lib/shared/generate-ts-config\"\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      const match = snippetPath.match(/^(?:@tsci\\/)?([^/.]+)[/.](.+)$/)\n      if (!match) {\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 [, author, snippetName] = match\n      console.log(`Cloning ${author}/${snippetName}...`)\n\n      const ky = getKy()\n      let packageFileList\n      try {\n        packageFileList = await ky\n          .post<{ package_files: Array<{ file_path: string }> }>(\n            \"package_files/list\",\n            {\n              json: {\n                package_name: `${author}/${snippetName}`,\n                use_latest_version: true,\n              },\n            },\n          )\n          .json()\n      } catch (error) {\n        console.error(\n          \"Failed to fetch package files:\",\n          error instanceof Error ? error.message : error,\n        )\n        process.exit(1)\n      }\n\n      const dirPath = path.resolve(`${author}.${snippetName}`)\n      fs.mkdirSync(dirPath, { recursive: true })\n\n      for (const fileInfo of packageFileList.package_files) {\n        const filePath = fileInfo.file_path.replace(/^\\/|dist\\//g, \"\")\n        if (!filePath) continue\n\n        const fullPath = path.join(dirPath, filePath)\n        fs.mkdirSync(path.dirname(fullPath), { recursive: true })\n\n        try {\n          const fileContent = await ky\n            .post<{ package_file: { content_text: string } }>(\n              \"package_files/get\",\n              {\n                json: {\n                  package_name: `${author}/${snippetName}`,\n                  file_path: fileInfo.file_path,\n                },\n              },\n            )\n            .json()\n\n          let fileText = fileContent.package_file.content_text\n\n          // Ensure all .tsx files contain \"import '@tscircuit/core';\"\n          if (\n            filePath.endsWith(\".tsx\") &&\n            !fileText.includes(\"@tscircuit/core\")\n          ) {\n            fileText = `import \"@tscircuit/core\";\\n\\n${fileText}`\n          }\n\n          fs.writeFileSync(fullPath, fileText)\n        } catch (error) {\n          console.warn(\n            `Skipping ${filePath} due to error:`,\n            error instanceof Error ? error.message : error,\n          )\n        }\n      }\n\n      fs.writeFileSync(\n        path.join(dirPath, \".npmrc\"),\n        \"@tsci:registry=https://npm.tscircuit.com\",\n      )\n\n      generateTsConfig(dirPath)\n      setupTsciProject(dirPath)\n\n      console.log(`Successfully cloned to ${dirPath}/`)\n      console.log(\n        `Run \"cd ${path.dirname(dirPath)} && tsci dev\" to start developing.`,\n      )\n    })\n}\n", "import type { Command } from \"commander\"\nimport { createCircuitWebWorker } from \"@tscircuit/eval\"\nimport webWorkerBundleUrl from \"@tscircuit/eval/blob-url\"\nimport { getVirtualFileSystemFromDirPath } from \"make-vfs\"\nimport path from \"node:path\"\nimport fs from \"node:fs\"\nimport {\n  convertCircuitJsonToSchematicSvg,\n  convertCircuitJsonToPcbSvg,\n} from \"circuit-to-svg\"\nimport { convertCircuitJsonToDsnString } from \"dsn-converter\"\nimport { convertCircuitJsonToReadableNetlist } from \"circuit-json-to-readable-netlist\"\n\nconst ALLOWED_FORMATS = [\n  \"json\",\n  \"circuit-json\",\n  \"schematic-svg\",\n  \"pcb-svg\",\n  \"gerbers\",\n  \"readable-netlist\",\n  \"gltf\",\n  \"specctra-dsn\",\n] as const\n\ntype Format = (typeof ALLOWED_FORMATS)[number]\n\nconst OUTPUT_EXTENSIONS = {\n  json: \".circuit.json\",\n  \"circuit-json\": \".circuit.json\",\n  \"schematic-svg\": \"-schematic.svg\",\n  \"pcb-svg\": \"-pcb.svg\",\n  gerbers: \"-gerbers.zip\",\n  \"readable-netlist\": \"-readable.netlist\",\n  gltf: \".gltf\",\n  \"specctra-dsn\": \".dsn\",\n}\n\nexport const registerExport = (program: Command) => {\n  program\n    .command(\"export\")\n    .description(\"Export tscircuit code to various formats\")\n    .argument(\"<file>\", \"Path to the snippet file\")\n    .option(\"-f, --format <format>\", \"Output format\")\n    .option(\"-o, --output <path>\", \"Output file path\")\n    .action(async (file, options) => {\n      const { format = \"circuit-json\" } = options\n      let { output } = options\n      if (!ALLOWED_FORMATS.includes(format)) {\n        throw new Error(\n          `Invalid format: ${format}\\nSupported formats: ${ALLOWED_FORMATS.join(\",\")}`,\n        )\n      }\n\n      if (!output) {\n        output = path.basename(file).replace(/\\.[^.]+$/, \"\")\n      }\n\n      const worker = await createCircuitWebWorker({\n        webWorkerUrl: webWorkerBundleUrl,\n      })\n\n      const projectDir = path.dirname(file)\n\n      const relativeComponentPath = path.relative(projectDir, file)\n\n      await worker.executeWithFsMap({\n        entrypoint: \"entrypoint.tsx\",\n        fsMap: {\n          ...((await getVirtualFileSystemFromDirPath({\n            dirPath: projectDir,\n            contentFormat: \"string\",\n          })) as Record<string, string>),\n          \"entrypoint.tsx\": `\nimport MyCircuit from \"./${relativeComponentPath}\"\n\ncircuit.add(<MyCircuit />)\n        `,\n        },\n      })\n\n      await worker.renderUntilSettled()\n\n      const circuitJson = await worker.getCircuitJson()\n      const outputPath = path.join(\n        projectDir,\n        `${output}${OUTPUT_EXTENSIONS[format as Format]}`,\n      )\n\n      let outputContent: string\n\n      switch (format) {\n        case \"schematic-svg\":\n          outputContent = convertCircuitJsonToSchematicSvg(circuitJson)\n          break\n        case \"pcb-svg\":\n          outputContent = convertCircuitJsonToPcbSvg(circuitJson)\n          break\n        case \"specctra-dsn\":\n          outputContent = convertCircuitJsonToDsnString(circuitJson)\n          break\n        case \"readable-netlist\":\n          outputContent = convertCircuitJsonToReadableNetlist(circuitJson)\n          break\n        default:\n          outputContent = JSON.stringify(circuitJson)\n      }\n\n      fs.writeFileSync(outputPath, outputContent)\n\n      console.log(`Exported to ${outputPath}`)\n\n      process.exit(0)\n    })\n}\n", "import type { Command } from \"commander\"\nimport { cliConfig } from \"lib/cli-config\"\n\nexport const registerAuthPrintToken = (program: Command) => {\n  program.commands\n    .find((c) => c.name() === \"auth\")!\n    .command(\"print-token\")\n    .description(\"Prints your auth token\")\n    .action(() => {\n      const token = cliConfig.get(\"sessionToken\")\n      if (!token) return console.log(\"You need to log in to access this.\")\n      console.log(\"Your Token:\\n\", token)\n    })\n}\n", "import type { Command } from \"commander\"\nimport { setSessionToken } from \"lib/cli-config\"\n\nfunction validateJWTLength(token: string) {\n  const parts = token.split(\".\")\n\n  if (parts.length === 3 && parts.every((part) => part.length > 0)) {\n    return true\n  } else {\n    return false\n  }\n}\nexport const registerAuthSetToken = (program: Command) => {\n  program.commands\n    .find((c) => c.name() === \"auth\")!\n    .command(\"set-token\")\n    .description(\"Explicitly set your auth token\")\n    .argument(\"<token>\", \"New token to manually configure\")\n    .action((token) => {\n      if (!validateJWTLength(token))\n        return console.log(\"Invalid token provided\")\n      setSessionToken(token)\n      console.log(\"Token manually updated.\")\n    })\n}\n", "import { pushSnippet } from \"lib/shared/push-snippet\"\nimport type { Command } from \"commander\"\n\nexport const registerPush = (program: Command) => {\n  program\n    .command(\"push\")\n    .description(\"Save snippet code to Registry API\")\n    .argument(\"[file]\", \"Path to the snippet file\")\n    .action(async (filePath?: string) => {\n      await pushSnippet({\n        filePath,\n        onExit: (code) => process.exit(code),\n        onError: (message) => console.error(message),\n        onSuccess: (message) => console.log(message),\n      })\n    })\n}\n"],
  "mappings": "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",
  "names": ["fs", "path", "fs", "path", "fs", "path", "path", "path", "program", "fs", "path", "fs", "path", "ky", "fs", "path", "resolve", "path", "fs", "fs", "path", "fs", "ts", "fs", "path", "ky", "path", "ky", "fs", "program", "port", "resolve", "server", "program", "ky", "program", "program", "program", "program", "fs", "path", "program", "ky", "semver", "path", "fs", "program", "program", "program", "program", "semver"]
}
