@tscircuit/cli 0.0.393 → 0.1.1

package/cli/lib/cmd-fns/auth-sessions-get.ts

@@ -1,3 +0,0 @@
-import { AppContext } from "../util/app-context"
-
-export const authSessionsGet = async (ctx: AppContext, args: any) => {}

package/cli/lib/cmd-fns/auth-sessions-list.ts

@@ -1,5 +0,0 @@
-import { AppContext } from "../util/app-context"
-
-export const authSessionsList = async (ctx: AppContext, args: any) => {
-  await ctx.axios.get("/sessions/list")
-}

package/cli/lib/cmd-fns/config-clear.ts

@@ -1,5 +0,0 @@
-import { AppContext } from "../util/app-context"
-
-export const configClear = async (ctx: AppContext, args: any) => {
-  ctx.global_config.clear()
-}

package/cli/lib/cmd-fns/config-print-config.ts

@@ -1,6 +0,0 @@
-import { AppContext } from "../util/app-context"
-import { readFile } from "fs/promises"
-
-export const configPrintConfig = async (ctx: AppContext, args: any) => {
-  console.log((await readFile(ctx.global_config.path)).toString())
-}

package/cli/lib/cmd-fns/config-reveal-location.ts

@@ -1,5 +0,0 @@
-import { AppContext } from "../util/app-context"
-
-export const configRevealLocation = async (ctx: AppContext, args: any) => {
-  console.log(`tsci config path: ${ctx.global_config.path}`)
-}

package/cli/lib/cmd-fns/config-set-log-requests.ts

@@ -1,7 +0,0 @@
-import { AppContext } from "../util/app-context"
-import { z } from "zod"
-
-export const configSetLogRequests = async (ctx: AppContext, args: any) => {
-  const params = z.object({ logRequests: z.boolean() }).parse(args)
-  ctx.global_config.set("log_requests", params.logRequests)
-}

package/cli/lib/cmd-fns/config-set-registry.ts

@@ -1,9 +0,0 @@
-import { AppContext } from "../util/app-context"
-import { z } from "zod"
-
-export const configSetRegistry = async (ctx: AppContext, args: any) => {
-  const params = z.object({ server: z.string().url() }).parse(args)
-  // don't want to re-use auth token
-  ctx.profile_config.clear()
-  ctx.profile_config.set("registry_url", params.server)
-}

package/cli/lib/cmd-fns/config-set-runtime.ts

@@ -1,7 +0,0 @@
-import { AppContext } from "../util/app-context"
-import { z } from "zod"
-
-export const configSetRuntime = async (ctx: AppContext, args: any) => {
-  const params = z.object({ runtime: z.enum(["bun", "node"]) }).parse(args)
-  ctx.global_config.set("runtime", params.runtime)
-}

package/cli/lib/cmd-fns/config-set-session.ts

@@ -1,7 +0,0 @@
-import { AppContext } from "../util/app-context"
-import { z } from "zod"
-
-export const configSetSession = async (ctx: AppContext, args: any) => {
-  const params = z.object({ sessionToken: z.string() }).parse(args)
-  ctx.profile_config.set("session_token", params.sessionToken)
-}

package/cli/lib/cmd-fns/dev/check-if-initialized.ts

@@ -1,22 +0,0 @@
-import { AppContext } from "../../util/app-context"
-import kleur from "kleur"
-import * as Path from "path/posix"
-import { existsSync, readFileSync } from "fs"
-
-export const checkIfInitialized = async (ctx: AppContext) => {
-  const packageJsonPath = Path.join(ctx.cwd, "package.json")
-  if (!existsSync(packageJsonPath)) {
-    console.error(kleur.red(`No package.json found`))
-    return false
-  }
-
-  const packageJsonRaw = readFileSync(packageJsonPath, "utf-8")
-  if (!packageJsonRaw.includes("tscircuit")) {
-    console.error(
-      kleur.red(`No tscircuit dependencies are installed in this project.`),
-    )
-    return false
-  }
-
-  return true
-}

package/cli/lib/cmd-fns/dev/derive-selector-from-pcb-component-id.ts

@@ -1,23 +0,0 @@
-import type { AnySoupElement } from "@tscircuit/soup"
-import { su } from "@tscircuit/soup-util"
-
-export const deriveSelectorFromPcbComponentId = ({
-  soup,
-  pcb_component_id,
-}: {
-  soup: AnySoupElement[]
-  pcb_component_id: string
-}) => {
-  const source_component = su(soup as any).source_component.getUsing({
-    pcb_component_id,
-  })
-  if (!source_component) {
-    throw new Error(
-      `Could not find source component for pcb_component_id="${pcb_component_id}"`,
-    )
-  }
-
-  // TODO travel up the tree to make the selector more specific
-
-  return `.${source_component.name}`
-}

package/cli/lib/cmd-fns/dev/dev-server-request-handler.ts

@@ -1,61 +0,0 @@
-import apiServer from "api/index"
-import frontendVfs from "frontend/dist/bundle"
-import EdgeRuntimePrimitives from "@edge-runtime/primitives"
-import mime from "mime-types"
-
-/**
- * Handles all requests to :3020, then proxies...
- *
- * /api/* : to the api server
- * /*     : to the static frontend bundle inside dev-server-frontend
- *
- */
-export const devServerRequestHandler = async (bunReq: Request) => {
-  const url = new URL(bunReq.url)
-  const requestType = url.pathname.startsWith("/api")
-    ? "api"
-    : url.pathname.startsWith("/preview")
-      ? "preview"
-      : "other"
-
-  if (requestType === "api") {
-    // We have to shim Bun's Request until they fix the issue where
-    // .clone() doesn't clone the body
-    // https://github.com/oven-sh/bun/pull/8668
-    const req = new EdgeRuntimePrimitives.Request(bunReq.url, {
-      headers: bunReq.headers,
-      method: bunReq.method,
-      body: bunReq.body,
-    })
-
-    const response = await apiServer.makeRequest(req as any, {})
-    return response
-  } else if (requestType === "preview") {
-    let frontendPath = url.pathname.replace("/preview", "")
-    if (frontendPath === "/" || frontendPath === "") {
-      frontendPath = "index.html"
-    }
-    frontendPath = frontendPath.replace(/^\//, "")
-
-    const fileContent: Buffer = (frontendVfs as any)[frontendPath]
-    if (!fileContent) {
-      return new Response("Not Found", { status: 404 })
-    }
-    return new Response(
-      // Buffer.from(fileContent.toString(), "base64").toString("utf-8"),
-      fileContent.toString("utf-8"),
-      {
-        headers: {
-          "Content-Type": mime.lookup(frontendPath) || "text/plain",
-        },
-      },
-    )
-  } else {
-    return new Response(null, {
-      status: 302,
-      headers: {
-        Location: "/preview",
-      },
-    })
-  }
-}

package/cli/lib/cmd-fns/dev/find-available-port.ts

@@ -1,32 +0,0 @@
-import net from "net"
-
-const MAX_PORT = 65535 // Maximum valid port number
-
-export const findAvailablePort = async (startPort: number): Promise<number> => {
-  let port = startPort
-
-  while (port <= MAX_PORT) {
-    if (!(await isPortInUse(port))) {
-      return port
-    }
-    port++
-  }
-
-  throw new Error(
-    `Unable to find an available port in range ${startPort}-${MAX_PORT}`,
-  )
-}
-
-const isPortInUse = (port: number): Promise<boolean> => {
-  return new Promise((resolve) => {
-    const server = net.createServer()
-    server.once("error", () => {
-      resolve(true)
-    })
-    server.once("listening", () => {
-      server.close()
-      resolve(false)
-    })
-    server.listen(port)
-  })
-}

package/cli/lib/cmd-fns/dev/fulfill-export-requests.ts

@@ -1,162 +0,0 @@
-import { AppContext } from "../../util/app-context"
-import kleur from "kleur"
-import { exportGerbersToZipBuffer } from "cli/lib/export-fns/export-gerbers"
-import { AxiosInstance } from "axios"
-import { exportPnpCsvToBuffer } from "cli/lib/export-fns/export-pnp-csv"
-import { exportBomCsvToBuffer } from "cli/lib/export-fns/export-bom-csv"
-import { soupify } from "cli/lib/soupify"
-import { ExportRequest } from "api/db/schema"
-import { exportKicadPcbToBuffer } from "cli/lib/export-fns/export-kicad-pcb"
-
-export const uploadBufferToExportFile = async ({
-  dev_server_axios,
-  file_buffer,
-  file_name,
-  export_request_id,
-}: {
-  dev_server_axios: AxiosInstance
-  file_buffer: Buffer
-  file_name: string
-  export_request_id: number
-}) => {
-  await dev_server_axios.post("/api/export_files/create", {
-    file_content_base64: file_buffer.toString("base64"),
-    file_name: file_name,
-    export_request_id: export_request_id,
-  })
-
-  console.log(kleur.gray(`  marking export request as complete...`))
-
-  await dev_server_axios.post("/api/export_requests/update", {
-    export_request_id: export_request_id,
-    is_complete: true,
-  })
-
-  console.log(kleur.green(`  done`))
-}
-
-export const fulfillExportRequests = async (
-  {
-    dev_server_axios,
-  }: {
-    dev_server_axios: AxiosInstance
-  },
-  ctx: AppContext,
-) => {
-  const export_requests: ExportRequest[] = await dev_server_axios
-    .post("/api/export_requests/list", {
-      is_complete: false,
-    })
-    .then((r) => r.data.export_requests)
-
-  for (const export_request of export_requests) {
-    console.log(
-      kleur.gray(
-        `Fulfilling export request ${export_request.export_request_id}`,
-      ),
-    )
-    console.log(
-      kleur.gray(`  example_file_path: ${export_request.example_file_path}`),
-    )
-
-    if (export_request.export_parameters.should_export_gerber_zip) {
-      console.log(kleur.gray(`\n  exporting gerbers...`))
-      const zip_buffer = await exportGerbersToZipBuffer(
-        {
-          example_file_path: export_request.example_file_path!,
-          export_name: export_request.export_name!,
-        },
-        ctx,
-      )
-
-      console.log(
-        kleur.gray(
-          `  uploading zip "${export_request.export_parameters.gerbers_zip_file_name}" to dev server...`,
-        ),
-      )
-
-      await uploadBufferToExportFile({
-        dev_server_axios,
-        file_buffer: zip_buffer,
-        file_name: export_request.export_parameters.gerbers_zip_file_name!,
-        export_request_id: export_request.export_request_id,
-      })
-    }
-
-    if (export_request.export_parameters.should_export_pnp_csv) {
-      console.log(kleur.gray(`\n  exporting pick'n'place...`))
-      const csv_buffer = await exportPnpCsvToBuffer(
-        {
-          example_file_path: export_request.example_file_path!,
-          export_name: export_request.export_name!,
-        },
-        ctx,
-      )
-
-      const pnpFileName = `${export_request.export_name}-${export_request.export_parameters.pnp_csv_file_name!}`
-
-      await uploadBufferToExportFile({
-        dev_server_axios,
-        file_buffer: csv_buffer,
-        file_name: pnpFileName,
-        export_request_id: export_request.export_request_id,
-      })
-    }
-
-    if (export_request.export_parameters.should_export_bom_csv) {
-      console.log(kleur.gray(`\n  exporting bill of materials...`))
-      const csv_buffer = await exportBomCsvToBuffer(
-        {
-          example_file_path: export_request.example_file_path!,
-          export_name: export_request.export_name!,
-        },
-        ctx,
-      )
-
-      const bomFileName = `${export_request.export_name}-${export_request.export_parameters.bom_csv_file_name!}`
-
-      await uploadBufferToExportFile({
-        dev_server_axios,
-        file_buffer: csv_buffer,
-        file_name: bomFileName,
-        export_request_id: export_request.export_request_id,
-      })
-    }
-
-    if (export_request.export_parameters.should_export_soup_json) {
-      console.log(kleur.gray(`\n  exporting soup...`))
-      const soup = await soupify(
-        {
-          filePath: export_request.example_file_path!,
-          exportName: export_request.export_name!,
-        },
-        ctx,
-      )
-
-      await uploadBufferToExportFile({
-        dev_server_axios,
-        file_buffer: Buffer.from(JSON.stringify(soup, null, 2), "utf-8"),
-        file_name: export_request.export_parameters.soup_json_file_name!,
-        export_request_id: export_request.export_request_id,
-      })
-    }
-
-    if (export_request.export_parameters.should_export_kicad_pcb) {
-      console.log(kleur.gray(`\n  exporting KiCad PCB...`))
-      const kicadPcbBuffer = await exportKicadPcbToBuffer(
-        {
-          example_file_path: export_request.example_file_path!,
-          export_name: export_request.export_name!,
-        },
-        ctx,
-      )
-
-      await uploadBufferToExportFile({
-        dev_server_axios,
-        file_buffer: kicadPcbBuffer,
-        file_name: export_request.export_parameters.kicad_pcb_file_name!,
-        export_request_id: export_request.export_request_id,
-      })
-    }
-  }
-}

package/cli/lib/cmd-fns/dev/get-dev-server-axios.ts

@@ -1,29 +0,0 @@
-import kleur from "kleur"
-import defaultAxios from "axios"
-
-export const getDevServerAxios = ({ serverUrl }: { serverUrl: string }) => {
-  const devServerAxios = defaultAxios.create({
-    baseURL: serverUrl,
-  })
-
-  // https://github.com/oven-sh/bun/issues/267
-  devServerAxios.defaults.headers.common["Accept-Encoding"] = "gzip"
-
-  devServerAxios.interceptors.response.use(
-    (res) => res,
-    (err) => {
-      console.log(
-        kleur.red(
-          `[ERR] ${err.response?.status} ${err.config.method?.toUpperCase()} ${
-            err.config.url
-          }\n\n${JSON.stringify(err.response?.data, null, "  ")}`
-            .replace(/\\n/g, "\n")
-            .replace(/\\"/g, '"'),
-        ),
-      )
-      console.log(kleur.yellow("[Request Body]:"), err.config.data)
-      return Promise.reject(err)
-    },
-  )
-  return devServerAxios
-}

package/cli/lib/cmd-fns/dev/index.ts

@@ -1,168 +0,0 @@
-import crypto from "crypto"
-import $ from "dax-sh"
-import fs from "fs"
-import kleur from "kleur"
-import posthog from "cli/lib/posthog"
-import open from "open"
-import * as Path from "path/posix"
-import prompts from "prompts"
-import { z } from "zod"
-import { AppContext } from "../../util/app-context"
-import { initCmd } from "../init"
-import { createOrModifyNpmrc } from "../init/create-or-modify-npmrc"
-import { checkIfInitialized } from "./check-if-initialized"
-import { findAvailablePort } from "./find-available-port"
-import { getDevServerAxios } from "./get-dev-server-axios"
-import { startDevServer } from "./start-dev-server"
-import { startEditEventWatcher } from "./start-edit-event-watcher"
-import { startExportRequestWatcher } from "./start-export-request-watcher"
-import { startFsWatcher } from "./start-fs-watcher"
-import { uploadExamplesFromDirectory } from "./upload-examples-from-directory"
-
-export const devCmd = async (ctx: AppContext, args: any) => {
-  const params = z
-    .object({
-      port: z.coerce.number().optional().default(3020),
-      core: z.boolean().optional(),
-    })
-    .parse(args)
-
-  let { port } = params
-  const { cwd } = ctx
-
-  // Find an available port
-  port = await findAvailablePort(port)
-
-  const projectHash = crypto.createHash("md5").update(cwd).digest("hex")
-
-  posthog.capture({
-    distinctId: projectHash,
-    event: "tsci_dev_started",
-    properties: {
-      port: port,
-    },
-  })
-
-  // In the future we should automatically run "tsci init" if the directory
-  // isn't properly initialized, for now we're just going to do a spot check
-  const isInitialized = await checkIfInitialized(ctx)
-
-  if (!isInitialized) {
-    const { confirmInitialize } = await prompts({
-      type: "confirm",
-      name: "confirmInitialize",
-      message: "Would you like to initialize this project now?",
-      initial: true,
-    })
-
-    if (confirmInitialize) {
-      return initCmd(ctx, {})
-    } else {
-      process.exit(1)
-    }
-  }
-
-  await createOrModifyNpmrc({ quiet: false }, ctx)
-
-  // Load package.json, install tscircuit if it's not installed. If any other
-  // tscircuit dependency like @tscircuit/builder is installed, then don't
-  // install anything. If there is nothing in the current directory, ask to
-  // instead run "tsci init"
-  // TODO
-
-  // Add .tscircuit to .gitignore if it's not already there
-  // TODO
-
-  // Delete old .tscircuit/dev-server.sqlite
-  // unlink(Path.join(cwd, ".tscircuit/dev-server.sqlite")).catch(() => { })
-
-  console.log(
-    kleur.green(
-      `\n--------------------------------------------\n\nStarting dev server http://127.0.0.1:${port}\n\n--------------------------------------------\n\n`,
-    ),
-  )
-  const serverUrl = `http://127.0.0.1:${port}`
-  const devServerAxios = getDevServerAxios({ serverUrl })
-
-  const server = await startDevServer({ port, devServerAxios })
-
-  // Reset the database, allows migration to re-run
-  await devServerAxios.post("/api/dev_server/reset").catch((e) => {
-    console.log("Failed to reset database, continuing anyway...")
-  })
-
-  // Add package name to the package_info table
-  const packageJsonPath = Path.resolve(cwd, "package.json")
-  const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"))
-  const packageName = packageJson.name
-
-  console.log(`Adding package info...`)
-  await devServerAxios.post(
-    "/api/package_info/create",
-    {
-      package_name: packageName,
-    },
-    ctx,
-  )
-
-  // Soupify all examples
-  console.log(`Loading examples...`)
-  await uploadExamplesFromDirectory({ devServerAxios, cwd }, ctx)
-
-  // Start watchers
-  const fs_watcher = await startFsWatcher({ cwd, devServerAxios }, ctx)
-  const er_watcher = await startExportRequestWatcher({ devServerAxios }, ctx)
-  const ee_watcher = await startEditEventWatcher({ devServerAxios }, ctx)
-
-  while (true) {
-    const { action } = await prompts({
-      type: "select",
-      name: "action", // Add this line
-      message: "Action:",
-      choices: [
-        {
-          title: "Open in Browser",
-          value: "open-in-browser",
-        },
-        {
-          title: "Open Directory in VS Code",
-          value: "open-in-vs-code",
-        },
-        {
-          title: "Stop Server",
-          value: "stop",
-        },
-      ],
-    })
-    if (action === "open-in-browser") {
-      open(serverUrl)
-      posthog.capture({
-        distinctId: projectHash,
-        event: "tsci_dev_open_browser",
-      })
-    } else if (action === "open-in-vs-code") {
-      await $`code ${cwd}`
-      posthog.capture({
-        distinctId: projectHash,
-        event: "tsci_dev_open_vscode",
-      })
-    } else if (!action || action === "stop") {
-      if (server.stop) server.stop()
-      if (server.close) server.close()
-      fs_watcher.stop()
-      er_watcher.stop()
-      ee_watcher.stop()
-
-      posthog.capture({
-        distinctId: projectHash,
-        event: "tsci_dev_stopped",
-      })
-
-      if (posthog.shutdown) {
-        await posthog.shutdown()
-      }
-
-      break
-    }
-  }
-}

package/cli/lib/cmd-fns/dev/infer-export-name-from-source.ts

@@ -1,17 +0,0 @@
-export const inferExportNameFromSource = (sourceContent: string): string => {
-  if (sourceContent.includes("export default")) {
-    return "default"
-  }
-  const matches = Array.from(
-    sourceContent.matchAll(/export\s+(const|function)\s+([A-Z]\w+)\s*=?/g),
-  ).map((m) => m[2])
-  if (matches.length === 0) {
-    throw new Error(`No export detected in "${sourceContent}"`)
-  }
-  if (matches.length > 1) {
-    throw new Error(
-      `Multiple exports detected in "${sourceContent}", only single exports currently working`,
-    )
-  }
-  return matches[0]
-}

package/cli/lib/cmd-fns/dev/mark-all-examples-loading.ts

@@ -1,18 +0,0 @@
-import { AxiosInstance } from "axios"
-
-export const markAllExamplesLoading = async ({
-  devServerAxios,
-}: {
-  devServerAxios: AxiosInstance
-}) => {
-  const examples = await devServerAxios
-    .post("/api/dev_package_examples/list")
-    .then((r) => r.data.dev_package_examples)
-
-  for (const example of examples) {
-    await devServerAxios.post("/api/dev_package_examples/update", {
-      dev_package_example_id: example.dev_package_example_id,
-      is_loading: true,
-    })
-  }
-}

package/cli/lib/cmd-fns/dev/soupify-and-upload-example-file.ts

@@ -1,62 +0,0 @@
-import kleur from "kleur"
-import { join as joinPath } from "path/posix"
-import { AxiosInstance } from "axios"
-import { readdirSync, readFileSync } from "fs"
-import { soupify } from "cli/lib/soupify"
-import { inferExportNameFromSource } from "./infer-export-name-from-source"
-import { AppContext } from "cli/lib/util/app-context"
-
-export const soupifyAndUploadExampleFile = async (
-  {
-    examplesDir,
-    exampleFileName,
-    devServerAxios,
-  }: {
-    examplesDir: string
-    exampleFileName: string
-    devServerAxios: AxiosInstance
-  },
-  ctx: Pick<AppContext, "runtime" | "params">,
-) => {
-  try {
-    const startTime = Date.now()
-    const examplePath = joinPath(examplesDir, exampleFileName)
-    const exampleContent = readFileSync(examplePath).toString()
-
-    const exportName = inferExportNameFromSource(exampleContent)
-
-    console.log(kleur.gray(`[soupifying] ${exampleFileName}...`))
-    const { soup, error } = await soupify(
-      {
-        filePath: examplePath,
-        exportName,
-      },
-      ctx,
-    )
-      .then((soup) => ({ soup, error: null }))
-      .catch((e) => ({ error: e, soup: undefined }))
-
-    if (error) {
-      console.log(kleur.red(`[   error  ] couldn't soupify ${exampleFileName}`))
-      console.log(error.toString())
-    }
-    console.log(kleur.gray(`[uploading ] ${exampleFileName}...`))
-    await devServerAxios.post("/api/dev_package_examples/create", {
-      tscircuit_soup: soup,
-      error: error?.toString() || null,
-      file_path: examplePath,
-      export_name: exportName,
-      is_loading: false,
-    })
-    const timeTaken = Date.now() - startTime
-    console.log(
-      kleur.gray(
-        `[   done   ] [ ${Math.round(timeTaken)
-          .toString()
-          .padStart(5, " ")}ms ] ${exampleFileName}!`,
-      ),
-    )
-  } catch (e: any) {
-    console.log(kleur.red(`[   error  ] ${e.toString()}`))
-  }
-}