@tscircuit/cli 0.0.2

package/lib/cmd-fns/auth-login.ts

@@ -0,0 +1,59 @@
+import { AppContext } from "../util/app-context"
+import delay from "delay"
+
+export const authLogin = async (ctx: AppContext, args: any) => {
+  const {
+    data: { login_page },
+  } = await ctx.axios.post("/sessions/login_page/create", {})
+
+  console.log("Please visit the following URL to log in:")
+  console.log(login_page.url)
+
+  // Wait until we receive confirmation
+  while (true) {
+    const {
+      data: { login_page: new_login_page },
+    } = await ctx.axios.post(
+      "/sessions/login_page/get",
+      {
+        login_page_id: login_page.login_page_id,
+      },
+      {
+        headers: {
+          Authorization: `Bearer ${login_page.login_page_auth_token}`,
+        },
+      }
+    )
+
+    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(1000)
+  }
+
+  const {
+    data: { session },
+  } = await ctx.axios.post(
+    "/sessions/login_page/exchange_for_cli_session",
+    {
+      login_page_id: login_page.login_page_id,
+    },
+    {
+      headers: {
+        Authorization: `Bearer ${login_page.login_page_auth_token}`,
+      },
+    }
+  )
+
+  ctx.profile_config.set("session_token", session.token)
+
+  // TODO test query
+
+  console.log("Ready to use!")
+}

package/lib/cmd-fns/auth-logout.ts

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

package/lib/cmd-fns/auth-sessions-create.ts

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

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

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

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

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

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

@@ -0,0 +1,6 @@
+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/lib/cmd-fns/config-reveal-location.ts

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

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

@@ -0,0 +1,7 @@
+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/lib/cmd-fns/config-set-registry.ts

@@ -0,0 +1,7 @@
+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)
+  ctx.profile_config.set("registry_url", params.server)
+}

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

@@ -0,0 +1,7 @@
+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/lib/cmd-fns/dev.ts

@@ -0,0 +1,217 @@
+import { AppContext } from "../util/app-context"
+import { z } from "zod"
+import kleur from "kleur"
+import { join as joinPath } from "path"
+import prompts from "prompts"
+import open from "open"
+import apiServer from "../../dev-server-api/dist/bundle"
+import frontendVfs from "../../dev-server-frontend/dist/bundle"
+import defaultAxios from "axios"
+import { readdirSync, readFileSync } from "fs"
+import { soupify } from "lib/soupify"
+import EdgeRuntimePrimitives from "@edge-runtime/primitives"
+import mime from "mime-types"
+
+export const devCmd = async (ctx: AppContext, args: any) => {
+  const params = z
+    .object({
+      cwd: z.string().optional().default(process.cwd()),
+      port: z.coerce.number().optional().default(3020),
+    })
+    .parse(args)
+
+  const { cwd, port } = params
+
+  // 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
+  // TODO
+
+  // Check that examples directory exists, if not create it and put inside
+  // a sample file ExampleCircuit.ts
+  // TODO
+
+  // Create .tscircuit directory if it doesn't exist
+  // TODO
+
+  // Add .tscircuit to .gitignore if it's not already there
+  // TODO
+
+  // Delete and recreate .tscircuit/dev-server.db
+
+  // INSIDE BACKGROUND SERVICE
+  // Soupify contents of examples directory, upload to sqlite db
+  // TODO
+  // Watch and re-soupify on file changes
+  // TODO
+
+  console.log(
+    kleur.green(
+      `\n--------------------------------------------\n\nStarting dev server http://localhost:${port}\n\n--------------------------------------------\n\n`
+    )
+  )
+  const serverUrl = `http://localhost:${port}`
+  const axios = defaultAxios.create({
+    baseURL: serverUrl,
+  })
+  axios.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)
+    }
+  )
+
+  const requestHandler = 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, {})
+      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",
+        },
+      })
+    }
+  }
+
+  let server: any
+  if (typeof Bun !== "undefined") {
+    server = Bun.serve({
+      fetch: requestHandler,
+      development: false,
+      port,
+    })
+  } else {
+    // Hono messes up the globals, only import it if we don't have Bun
+    const { Hono } = await import("hono")
+    const { serve } = await import("@hono/node-server")
+    const honoApp = new Hono()
+    honoApp.all("/*", (c) => requestHandler(c.req.raw))
+    server = serve({
+      fetch: honoApp.fetch,
+      port,
+    })
+  }
+
+  console.log("Running health check against dev server...")
+  await axios.get("/api/health")
+
+  // Soupify all examples
+  console.log(`Loading examples...`)
+  const examplesDir = joinPath(cwd, "examples")
+  const exampleFileNames = readdirSync(examplesDir)
+  for (const exampleFileName of exampleFileNames) {
+    try {
+      const examplePath = joinPath(examplesDir, exampleFileName)
+      const exampleContent = readFileSync(examplePath).toString()
+
+      let exportName = "default"
+
+      if (!exampleContent.includes("export default")) {
+        // try to infer an export if possible
+        const matches = Array.from(
+          exampleContent.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 "${exampleFileName}"`)
+        }
+        if (matches.length > 1) {
+          throw new Error(
+            `Multiple exports detected in "${exampleFileName}", only single exports currently working`
+          )
+        }
+        exportName = matches[0]
+      }
+
+      console.log("Soupifying...")
+      const soup = await soupify({
+        filePath: examplePath,
+        exportName,
+      })
+      console.log(`Soupified ${exampleFileName}!`)
+      console.log(`Uploading ${exampleFileName}...`)
+      await axios.post("/api/dev_package_examples/create", {
+        tscircuit_soup: soup,
+        file_path: examplePath,
+        export_name: exportName,
+      })
+      console.log(`Uploaded ${exampleFileName}!`)
+    } catch (e: any) {
+      console.log(kleur.red(e.toString()))
+    }
+  }
+
+  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: "Stop Server",
+          value: "stop",
+        },
+      ],
+    })
+    if (action === "open-in-browser") {
+      open(serverUrl)
+    } else if (!action || action === "stop") {
+      if (server.stop) server.stop()
+      if (server.close) server.close()
+      break
+    }
+  }
+}

package/lib/cmd-fns/index.ts

@@ -0,0 +1,27 @@
+export { configRevealLocation } from "./config-reveal-location"
+export { configSetRegistry } from "./config-set-registry"
+export { configSetSession } from "./config-set-session"
+export { configSetLogRequests } from "./config-set-log-requests"
+export { configPrintConfig } from "./config-print-config"
+export { authLogin } from "./auth-login"
+export { authLogout } from "./auth-logout"
+export { authSessionsCreate } from "./auth-sessions-create"
+export { authSessionsList } from "./auth-sessions-list"
+export { authSessionsGet } from "./auth-sessions-get"
+export { packagesList } from "./packages-list"
+export { packagesGet } from "./packages-get"
+export { packagesCreate } from "./packages-create"
+export { packageFilesUploadDirectory } from "./package-files-upload-directory"
+export { packageReleasesList } from "./package-releases-list"
+export { packageReleasesGet } from "./package-releases-get"
+export { packageReleasesCreate } from "./package-releases-create"
+export { packageFilesList } from "./package-files-list"
+export { packageFilesGet } from "./package-files-get"
+export { packageFilesDownload } from "./package-files-download"
+export { packageFilesCreate } from "./package-files-create"
+export { packageExamplesList } from "./package-examples-list"
+export { packageExamplesGet } from "./package-examples-get"
+export { packageExamplesCreate } from "./package-examples-create"
+export { publish } from "./publish"
+export { soupifyCmd as soupify } from "./soupify"
+export { devCmd as dev } from "./dev"

package/lib/cmd-fns/package-examples-create.ts

@@ -0,0 +1,33 @@
+import { soupify } from "lib/soupify"
+import { AppContext } from "../util/app-context"
+import { z } from "zod"
+import fs from "fs"
+
+export const packageExamplesCreate = async (ctx: AppContext, args: any) => {
+  const params = z
+    .object({
+      packageNameWithVersion: z.string(),
+      file: z.string(),
+      export: z.string().optional().default("default"),
+    })
+    .parse(args)
+
+  const tscircuit_soup = await soupify({
+    filePath: params.file,
+    exportName: params.export,
+  })
+
+  const fileContent = await fs.promises.readFile(params.file, "utf8")
+
+  const package_example = await ctx.axios
+    .post("/package_examples/create", {
+      package_name_with_version: params.packageNameWithVersion,
+      file_path: params.file,
+      export_name: params.export,
+      source_content: fileContent,
+      tscircuit_soup,
+    })
+    .then((r) => r.data.package_example)
+
+  console.log(package_example)
+}

package/lib/cmd-fns/package-examples-get.ts

@@ -0,0 +1,20 @@
+import { AppContext } from "../util/app-context"
+import { z } from "zod"
+
+export const packageExamplesGet = async (ctx: AppContext, args: any) => {
+  const params = z
+    .object({
+      packageExampleId: z.string().uuid(),
+    })
+    .parse(args)
+
+  const { packageExampleId: package_example_id } = params
+
+  const package_example = await ctx.axios
+    .post("/package_examples/get", {
+      package_example_id,
+    })
+    .then((r) => r.data.package_example)
+
+  console.log(package_example)
+}

package/lib/cmd-fns/package-examples-list.ts

@@ -0,0 +1,18 @@
+import { AppContext } from "../util/app-context"
+import { z } from "zod"
+
+export const packageExamplesList = async (ctx: AppContext, args: any) => {
+  const params = z
+    .object({
+      packageNameWithVersion: z.string(),
+    })
+    .parse(args)
+
+  const package_examples = await ctx.axios
+    .post("/package_examples/list", {
+      package_name_with_version: params.packageNameWithVersion,
+    })
+    .then((r) => r.data.package_examples)
+
+  console.log(package_examples)
+}

package/lib/cmd-fns/package-files-create.ts

@@ -0,0 +1,31 @@
+import { AppContext } from "../util/app-context"
+import { z } from "zod"
+import * as fs from "fs/promises"
+import kleur from "kleur"
+
+export const packageFilesCreate = async (ctx: AppContext, args: any) => {
+  const params = z
+    .object({
+      file: z.string(),
+      packageReleaseId: z.string().optional(),
+      packageNameWithVersion: z.string().optional(),
+    })
+    .parse(args)
+
+  const { file, packageNameWithVersion, packageReleaseId } = params
+
+  const fileContent = await fs.readFile(file)
+
+  const package_file = await ctx.axios
+    .post("/package_files/create", {
+      file_path: file,
+      content_text: fileContent.toString(),
+      package_name_with_version: packageNameWithVersion,
+      package_release_id: packageReleaseId,
+    })
+    .then((r) => r.data.package_file)
+
+  console.log(
+    `Package file created ${kleur.gray(package_file.package_file_id)}`
+  )
+}

package/lib/cmd-fns/package-files-download.ts

@@ -0,0 +1,29 @@
+import { AppContext } from "../util/app-context"
+import { z } from "zod"
+import * as fs from "fs/promises"
+
+export const packageFilesDownload = async (ctx: AppContext, args: any) => {
+  const params = z
+    .object({
+      packageNameWithVersion: z.string().optional(),
+      remoteFilePath: z.string().optional(),
+      output: z.string().optional(),
+    })
+    .parse(args)
+
+  const { packageNameWithVersion, remoteFilePath } = params
+
+  const packageContent = await ctx.axios
+    .post("/package_files/download", {
+      package_name_with_version: packageNameWithVersion,
+      file_path: remoteFilePath,
+    })
+    .then((r) => r.data)
+
+  if (params.output) {
+    console.log("Writing to", params.output)
+    await fs.writeFile(params.output, packageContent)
+  } else {
+    console.log(packageContent)
+  }
+}

package/lib/cmd-fns/package-files-get.ts

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

package/lib/cmd-fns/package-files-list.ts

@@ -0,0 +1,28 @@
+import { AppContext } from "../util/app-context"
+import { z } from "zod"
+
+export const packageFilesList = async (ctx: AppContext, args: any) => {
+  const params = z
+    .object({
+      packageReleaseId: z.string().optional(),
+      packageName: z.string().optional(),
+      packageNameWithVersion: z.string().optional(),
+      verbose: z.boolean().optional(),
+    })
+    .parse(args)
+
+  const package_files = await ctx.axios
+    .post("/package_files/list", {
+      package_release_id: params.packageReleaseId,
+      package_name: params.packageName,
+      use_latest_version: Boolean(params.packageName),
+      package_name_with_version: params.packageNameWithVersion,
+    })
+    .then((r) => r.data.package_files)
+
+  if (params.verbose) {
+    console.log(package_files)
+  } else {
+    console.log(package_files.map((f: any) => f.file_path).join("\n"))
+  }
+}

package/lib/cmd-fns/package-files-upload-directory.ts

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

package/lib/cmd-fns/package-releases-create.ts

@@ -0,0 +1,35 @@
+import { AppContext } from "../util/app-context"
+import { z } from "zod"
+import kleur from "kleur"
+
+export const packageReleasesCreate = async (ctx: AppContext, args: any) => {
+  args.version = args.releaseVersion
+  const params = z
+    .object({
+      packageNameWithVersion: z.string().optional(),
+      packageName: z.string().optional(),
+      version: z.string().optional(),
+    })
+    .refine((d) => {
+      if (d.packageNameWithVersion) return true
+      if (d.packageName && d.version) return true
+      return false
+    }, "Either packageNameWithVersion or packageName and version must be provided")
+    .parse(args)
+
+  let { packageNameWithVersion, packageName, version } = params
+
+  if (!packageNameWithVersion) {
+    packageNameWithVersion = `${packageName}@${version}`
+  }
+
+  const package_release = await ctx.axios
+    .post("/package_releases/create", {
+      package_name_with_version: packageNameWithVersion,
+    })
+    .then((r) => r.data.package_release)
+
+  console.log(
+    `Package release created! ${kleur.gray(package_release.package_release_id)}`
+  )
+}

package/lib/cmd-fns/package-releases-get.ts

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

package/lib/cmd-fns/package-releases-list.ts

@@ -0,0 +1,32 @@
+import { AppContext } from "../util/app-context"
+import { z } from "zod"
+
+export const packageReleasesList = async (ctx: AppContext, args: any) => {
+  const params = z
+    .object({
+      packageName: z.string().optional(),
+      verbose: z.boolean().optional(),
+    })
+    .parse(args)
+
+  const package_releases = await ctx.axios
+    .post("/package_releases/list", {
+      package_name: params.packageName,
+    })
+    .then((r) => r.data.package_releases)
+
+  if (package_releases.length === 0) {
+    console.log("No package releases found")
+    return
+  }
+
+  if (params.verbose) {
+    console.log(package_releases)
+  } else {
+    console.log(
+      package_releases
+        .map((f: any) => `${params.packageName}@${f.version}`)
+        .join("\n")
+    )
+  }
+}

package/lib/cmd-fns/packages-create.ts

@@ -0,0 +1,16 @@
+import { AppContext } from "../util/app-context"
+import { z } from "zod"
+
+export const packagesCreate = async (ctx: AppContext, args: any) => {
+  const params = z
+    .object({
+      name: z.string(),
+      description: z.string().optional(),
+      authorAccountId: z.string().optional(),
+    })
+    .parse(args)
+
+  await ctx.axios.post("/packages/create", params)
+
+  console.log(`Package "${params.name}" created!`)
+}

package/lib/cmd-fns/packages-get.ts

@@ -0,0 +1,16 @@
+import { AppContext } from "../util/app-context"
+import { z } from "zod"
+
+export const packagesGet = async (ctx: AppContext, args: any) => {
+  args.packageId = args.package_id
+  const params = z
+    .object({ package_id: z.string() })
+    .or(z.object({ name: z.string() }))
+    .parse(args)
+
+  const {
+    data: { package: pkg },
+  } = await ctx.axios.post("/packages/get", params)
+
+  console.log(pkg)
+}

package/lib/cmd-fns/packages-list.ts

@@ -0,0 +1,16 @@
+import { AppContext } from "../util/app-context"
+
+export const packagesList = async (ctx: AppContext, args: any) => {
+  const {
+    data: { packages },
+  } = await ctx.axios.post("/packages/list", {})
+
+  if (packages.length === 0) {
+    console.log("No packages found")
+  } else {
+    console.log("packages:")
+  }
+  for (const pkg of packages) {
+    console.log(`- ${pkg.name}`)
+  }
+}

package/lib/cmd-fns/publish.ts

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