@mohxmd/dbstudio 0.1.0 → 0.1.1

package/dist/index.js

@@ -0,0 +1,275 @@
+#!/usr/bin/env bun
+// @bun
+
+// lib/constants/help.ts
+var HELP = `
+dbstudio \u2014 spin up Drizzle Studio from any database URL
+
+Usage:
+  dbstudio <database-url> [options]
+
+Examples:
+  dbstudio postgresql://user:pass@localhost:5432/mydb
+  dbstudio mysql://user:pass@localhost:3306/mydb
+  dbstudio sqlite:./local.db
+
+  # Quick share (no CF account needed, temporary URL)
+  dbstudio postgresql://... --share
+
+  # Named tunnel (persistent URL, needs CF account + domain)
+  dbstudio postgresql://... --share --tunnel dbstudio --hostname db.yourteam.com
+
+Options:
+  --port <number>        Port to run studio on (default: 4983)
+  --host <string>        Host to bind to (default: 127.0.0.1, or 0.0.0.0 with --share)
+  --open                 Auto-open in browser
+  --share                Expose via Cloudflare Tunnel
+  --tunnel <name>        Named CF tunnel (requires --hostname)
+  --hostname <domain>    Public hostname for named tunnel
+  -h, --help             Show this help
+  -v, --version          Show version
+
+Tunnel setup (one time):
+  yay -S cloudflared
+  cloudflared tunnel login
+  cloudflared tunnel create <name>
+  # add CNAME in Cloudflare dashboard \u2192 <tunnel-id>.cfargotunnel.com
+`;
+
+// lib/utils/args.ts
+function getFlag(args, flag) {
+  const idx = args.indexOf(flag);
+  if (idx === -1)
+    return null;
+  const val = args[idx + 1];
+  return val && !val.startsWith("--") ? val : null;
+}
+function parseStudioOptions(args) {
+  const dbUrl = args[0];
+  if (!dbUrl || dbUrl.startsWith("--")) {
+    throw new Error("Please provide a database URL as the first argument.");
+  }
+  const shouldShare = args.includes("--share");
+  const tunnelName = getFlag(args, "--tunnel");
+  const publicHostname = getFlag(args, "--hostname");
+  if (tunnelName && !publicHostname) {
+    throw new Error(`--tunnel requires --hostname <your-domain>
+   Example: --tunnel dbstudio --hostname db.yourteam.com`);
+  }
+  const explicitHost = getFlag(args, "--host");
+  const host = explicitHost ?? (shouldShare ? "0.0.0.0" : "127.0.0.1");
+  return {
+    dbUrl,
+    port: getFlag(args, "--port") ?? "4983",
+    host,
+    shouldOpen: args.includes("--open"),
+    shouldShare,
+    tunnelName,
+    publicHostname
+  };
+}
+
+// lib/utils/dialect.ts
+function detectDialect(url) {
+  if (url.startsWith("postgresql://") || url.startsWith("postgres://"))
+    return "postgresql";
+  if (url.startsWith("mysql://") || url.startsWith("mysql2://"))
+    return "mysql";
+  if (url.startsWith("sqlite:") || url.startsWith("file:") || url === ":memory:" || url.endsWith(".db") || url.endsWith(".sqlite"))
+    return "sqlite";
+  throw new Error(`Could not detect dialect from URL: ${url}
+Supported: postgresql://, mysql://, sqlite:, file:`);
+}
+
+// lib/utils/config.ts
+import { writeFileSync, unlinkSync, existsSync } from "fs";
+import { tmpdir, homedir } from "os";
+import { join } from "path";
+var tempFiles = [];
+function cleanupAll() {
+  for (const f of tempFiles) {
+    if (existsSync(f))
+      unlinkSync(f);
+  }
+}
+function writeTempFile(name, content) {
+  const path = join(tmpdir(), `${name}-${Date.now()}`);
+  writeFileSync(path, content, "utf8");
+  tempFiles.push(path);
+  return path;
+}
+function generateDrizzleConfig(url, dialect) {
+  if (dialect === "sqlite") {
+    const filePath = url.replace(/^sqlite:\/\//, "").replace(/^sqlite:/, "").replace(/^file:\/\//, "").replace(/^file:/, "");
+    return `export default {
+  dialect: "sqlite",
+  dbCredentials: { url: "${filePath}" },
+};`;
+  }
+  return `export default {
+  dialect: "${dialect}",
+  dbCredentials: { url: "${url}" },
+};`;
+}
+function createDrizzleConfig(url, dialect) {
+  return writeTempFile("dbstudio.config.ts", generateDrizzleConfig(url, dialect));
+}
+function generateTunnelConfig(tunnelName, hostname, port) {
+  const credPath = join(homedir(), ".cloudflared");
+  return `tunnel: ${tunnelName}
+credentials-file: ${credPath}/${tunnelName}.json
+
+ingress:
+  - hostname: ${hostname}
+    service: http://localhost:${port}
+  - service: http_status:404
+`;
+}
+function createTunnelConfig(tunnelName, hostname, port) {
+  return writeTempFile("dbstudio-tunnel.yml", generateTunnelConfig(tunnelName, hostname, port));
+}
+
+// lib/commands/tunnel.ts
+import { spawn } from "child_process";
+function launchTunnel(options) {
+  const { port, tunnelName, publicHostname, shouldOpen } = options;
+  let tunnelArgs;
+  if (tunnelName && publicHostname) {
+    const tunnelConfigPath = createTunnelConfig(tunnelName, publicHostname, port);
+    tunnelArgs = ["tunnel", "--config", tunnelConfigPath, "run", tunnelName];
+  } else {
+    tunnelArgs = ["tunnel", "--url", `http://localhost:${port}`];
+  }
+  const tunnel = spawn("cloudflared", tunnelArgs, {
+    stdio: ["ignore", "pipe", "pipe"],
+    shell: false
+  });
+  tunnel.stderr?.on("data", (data) => {
+    const line = data.toString();
+    process.stderr.write(data);
+    if (!tunnelName) {
+      const match = line.match(/https:\/\/[a-z0-9-]+\.trycloudflare\.com/);
+      if (match) {
+        console.log(`
+\u2705 Public URL: ${match[0]}`);
+        console.log(`   Share this link with your team
+`);
+        if (shouldOpen) {
+          spawn("xdg-open", [match[0]], { stdio: "ignore" });
+        }
+      }
+    }
+  });
+  tunnel.on("error", (err) => {
+    console.error(`
+\u274C Failed to start cloudflared: ${err.message}`);
+    console.error(`   Install it with: yay -S cloudflared`);
+  });
+  tunnel.on("exit", (code) => {
+    if (code !== 0)
+      console.error(`
+\u26A0\uFE0F  Tunnel exited with code ${code}`);
+  });
+  return tunnel;
+}
+
+// lib/commands/studio.ts
+import { spawn as spawn2 } from "child_process";
+var procs = [];
+function killAll() {
+  for (const p of procs) {
+    if (!p.killed)
+      p.kill("SIGTERM");
+  }
+}
+function registerCleanup() {
+  process.on("exit", cleanupAll);
+  process.on("SIGINT", () => {
+    console.log(`
+
+\uD83D\uDC4B Shutting down dbstudio...`);
+    killAll();
+    cleanupAll();
+    process.exit(0);
+  });
+  process.on("SIGTERM", () => {
+    killAll();
+    cleanupAll();
+    process.exit(0);
+  });
+}
+async function runStudioCommand(options) {
+  const { dbUrl, port, host, shouldOpen, shouldShare, tunnelName, publicHostname } = options;
+  const dialect = detectDialect(dbUrl);
+  const drizzleConfig = createDrizzleConfig(dbUrl, dialect);
+  const safeUrl = dbUrl.replace(/:\/\/.*@/, "://<credentials>@");
+  registerCleanup();
+  console.log(`
+\uD83D\uDE80 dbstudio`);
+  console.log(`   Dialect : ${dialect}`);
+  console.log(`   URL     : ${safeUrl}`);
+  console.log(`   Studio  : https://local.drizzle.studio`);
+  if (shouldShare && !tunnelName) {
+    console.log(`   Tunnel  : starting... public URL coming shortly`);
+  }
+  if (tunnelName && publicHostname) {
+    console.log(`   Tunnel  : https://${publicHostname}`);
+  }
+  console.log();
+  const studioArgs = [
+    "drizzle-kit",
+    "studio",
+    `--config=${drizzleConfig}`,
+    `--port=${port}`,
+    `--host=${host}`
+  ];
+  if (shouldOpen && !shouldShare)
+    studioArgs.push("--open");
+  const studio = Bun.spawn(["bunx", ...studioArgs], {
+    stdin: "ignore",
+    stdout: "inherit",
+    stderr: "inherit"
+  });
+  if (shouldShare) {
+    await Bun.sleep(2000);
+    const tunnel = launchTunnel({ port, tunnelName, publicHostname, shouldOpen });
+    procs.push(tunnel);
+    if (shouldOpen && tunnelName && publicHostname) {
+      spawn2("xdg-open", [`https://${publicHostname}`], { stdio: "ignore" });
+    }
+  }
+  const exitCode = await studio.exited;
+  killAll();
+  cleanupAll();
+  return exitCode ?? 0;
+}
+
+// main.ts
+var args = process.argv.slice(2);
+if (args.length === 0 || args.includes("-h") || args.includes("--help")) {
+  console.log(HELP);
+  process.exit(0);
+}
+if (args.includes("-v") || args.includes("--version")) {
+  const pkg = await Bun.file(new URL("../package.json", import.meta.url)).json();
+  console.log(`dbstudio v${pkg.version}`);
+  process.exit(0);
+}
+try {
+  const options = parseStudioOptions(args);
+  const code = await runStudioCommand(options);
+  process.exit(code);
+} catch (error) {
+  const msg = error instanceof Error ? error.message : String(error);
+  if (msg.startsWith("Please provide")) {
+    console.error(`\u274C ${msg}`);
+    console.error("   Run dbstudio --help for usage.");
+  } else if (msg.startsWith("Could not detect")) {
+    console.error(`\u274C ${msg}`);
+  } else if (msg.startsWith("--tunnel requires")) {
+    console.error(`\u274C ${msg}`);
+  } else {
+    console.error(`\u274C Unexpected error: ${msg}`);
+  }
+  process.exit(1);
+}

package/package.json

@@ -1,16 +1,16 @@
 {
   "name": "@mohxmd/dbstudio",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Spin up Drizzle Studio from any database URL",
   "license": "MIT",
   "type": "module",
-  "module": "main.ts",
   "bin": {
-    "dbstudio": "./bin/dbstudio"
+    "dbstudio": "./dist/index.js"
   },
   "scripts": {
     "start": "bun main.ts",
     "dev": "bun --watch main.ts",
+    "build": "bun build main.ts --outfile dist/index.js --target bun",
     "compile": "bun build main.ts --compile --outfile bin/dbstudio",
     "compile:linux": "bun build main.ts --compile --target=bun-linux-x64 --outfile bin/dbstudio-linux",
     "compile:mac": "bun build main.ts --compile --target=bun-darwin-arm64 --outfile bin/dbstudio-mac"
@@ -19,8 +19,7 @@
     "bun": ">=1.0.0"
   },
   "files": [
-    "main.ts",
-    "lib",
+    "dist",
     "README.md",
     "LICENSE"
   ],
@@ -30,8 +29,5 @@
   },
   "devDependencies": {
     "@types/bun": "latest"
-  },
-  "peerDependencies": {
-    "typescript": "latest"
   }
 }

package/lib/commands/studio.ts

@@ -1,98 +0,0 @@
-import type { StudioOptions } from "../utils/args";
-import { detectDialect } from "../utils/dialect";
-import { createDrizzleConfig, cleanupAll } from "../utils/config";
-import { launchTunnel } from "./tunnel";
-import type { ChildProcess } from "child_process";
-
-const procs: ChildProcess[] = [];
-
-function killAll() {
-  for (const p of procs) {
-    if (!p.killed) p.kill("SIGTERM");
-  }
-}
-
-function registerCleanup() {
-  process.on("exit", cleanupAll);
-  process.on("SIGINT", () => {
-    console.log("\n\n👋 Shutting down dbstudio...");
-    killAll();
-    cleanupAll();
-    process.exit(0);
-  });
-  process.on("SIGTERM", () => {
-    killAll();
-    cleanupAll();
-    process.exit(0);
-  });
-}
-
-export async function runStudioCommand(options: StudioOptions): Promise<number> {
-  const { dbUrl, port, host, shouldOpen, shouldShare, tunnelName, publicHostname } = options;
-
-  const dialect       = detectDialect(dbUrl);
-  const drizzleConfig = createDrizzleConfig(dbUrl, dialect);
-  const safeUrl       = dbUrl.replace(/:\/\/.*@/, "://<credentials>@");
-
-  registerCleanup();
-
-  // Print startup info
-
-  console.log(`\n🚀 dbstudio`);
-  console.log(`   Dialect : ${dialect}`);
-  console.log(`   URL     : ${safeUrl}`);
-  console.log(`   Studio  : https://local.drizzle.studio`);
-
-  if (shouldShare && !tunnelName) {
-    console.log(`   Tunnel  : starting... public URL coming shortly`);
-  }
-  if (tunnelName && publicHostname) {
-    console.log(`   Tunnel  : https://${publicHostname}`);
-  }
-  console.log();
-
-  // Spawn drizzle-kit studio via bunx
-  // bunx is used so the binary works after `bun build --compile`
-  // without needing a local node_modules at runtime
-
-  const studioArgs = [
-    "drizzle-kit",
-    "studio",
-    `--config=${drizzleConfig}`,
-    `--port=${port}`,
-    `--host=${host}`,
-  ];
-
-  if (shouldOpen && !shouldShare) studioArgs.push("--open");
-
-  const studio = Bun.spawn(["bunx", ...studioArgs], {
-    stdin:  "ignore",
-    stdout: "inherit",
-    stderr: "inherit",
-  });
-
-  // Launch tunnel after studio boots
-
-  if (shouldShare) {
-    // give drizzle-kit studio a moment to start before tunnel connects
-    await Bun.sleep(2000);
-
-    const tunnel = launchTunnel({ port, tunnelName, publicHostname, shouldOpen });
-    // cast needed since launchTunnel returns node ChildProcess
-    procs.push(tunnel as unknown as ChildProcess);
-
-    if (shouldOpen && tunnelName && publicHostname) {
-      spawn("xdg-open", [`https://${publicHostname}`], { stdio: "ignore" });
-    }
-  }
-
-  // Wait for studio to exit
-
-  const exitCode = await studio.exited;
-  killAll();
-  cleanupAll();
-  return exitCode ?? 0;
-}
-
-// node spawn needed for tunnel (pipe stdio support)
-import { spawn } from "child_process";

package/lib/commands/tunnel.ts

@@ -1,60 +0,0 @@
-import { spawn } from "child_process";
-import { createTunnelConfig } from "../utils/config";
-
-export function launchTunnel(options: {
-  port: string;
-  tunnelName: string | null;
-  publicHostname: string | null;
-  shouldOpen: boolean;
-}) {
-  const { port, tunnelName, publicHostname, shouldOpen } = options;
-
-  let tunnelArgs: string[];
-
-  if (tunnelName && publicHostname) {
-    // named tunnel — generate temp config.yml, never touches ~/.cloudflared/config.yml
-    const tunnelConfigPath = createTunnelConfig(
-      tunnelName,
-      publicHostname,
-      port,
-    );
-    tunnelArgs = ["tunnel", "--config", tunnelConfigPath, "run", tunnelName];
-  } else {
-    // quick share — zero setup, temporary trycloudflare.com URL
-    tunnelArgs = ["tunnel", "--url", `http://localhost:${port}`];
-  }
-
-  const tunnel = spawn("cloudflared", tunnelArgs, {
-    stdio: ["ignore", "pipe", "pipe"],
-    shell: false,
-  });
-
-  // cloudflared prints the public URL to stderr
-  tunnel.stderr?.on("data", (data: Buffer) => {
-    const line = data.toString();
-    process.stderr.write(data);
-
-    // quick share: extract and highlight the URL when cloudflared prints it
-    if (!tunnelName) {
-      const match = line.match(/https:\/\/[a-z0-9-]+\.trycloudflare\.com/);
-      if (match) {
-        console.log(`\n✅ Public URL: ${match[0]}`);
-        console.log(`   Share this link with your team\n`);
-        if (shouldOpen) {
-          spawn("xdg-open", [match[0]], { stdio: "ignore" });
-        }
-      }
-    }
-  });
-
-  tunnel.on("error", (err) => {
-    console.error(`\n❌ Failed to start cloudflared: ${err.message}`);
-    console.error(`   Install it with: yay -S cloudflared`);
-  });
-
-  tunnel.on("exit", (code) => {
-    if (code !== 0) console.error(`\n⚠️  Tunnel exited with code ${code}`);
-  });
-
-  return tunnel;
-}

package/lib/constants/help.ts

@@ -1,33 +0,0 @@
-export const HELP = `
-dbstudio — spin up Drizzle Studio from any database URL
-
-Usage:
-  dbstudio <database-url> [options]
-
-Examples:
-  dbstudio postgresql://user:pass@localhost:5432/mydb
-  dbstudio mysql://user:pass@localhost:3306/mydb
-  dbstudio sqlite:./local.db
-
-  # Quick share (no CF account needed, temporary URL)
-  dbstudio postgresql://... --share
-
-  # Named tunnel (persistent URL, needs CF account + domain)
-  dbstudio postgresql://... --share --tunnel dbstudio --hostname db.yourteam.com
-
-Options:
-  --port <number>        Port to run studio on (default: 4983)
-  --host <string>        Host to bind to (default: 127.0.0.1, or 0.0.0.0 with --share)
-  --open                 Auto-open in browser
-  --share                Expose via Cloudflare Tunnel
-  --tunnel <name>        Named CF tunnel (requires --hostname)
-  --hostname <domain>    Public hostname for named tunnel
-  -h, --help             Show this help
-  -v, --version          Show version
-
-Tunnel setup (one time):
-  yay -S cloudflared
-  cloudflared tunnel login
-  cloudflared tunnel create <name>
-  # add CNAME in Cloudflare dashboard → <tunnel-id>.cfargotunnel.com
-`;

package/lib/utils/args.ts

@@ -1,50 +0,0 @@
-export type StudioOptions = {
-  dbUrl: string;
-  port: string;
-  host: string;
-  shouldOpen: boolean;
-  shouldShare: boolean;
-  tunnelName: string | null;
-  publicHostname: string | null;
-};
-
-/** Read a flag value in the form `--flag <value>`. */
-function getFlag(args: string[], flag: string): string | null {
-  const idx = args.indexOf(flag);
-  if (idx === -1) return null;
-  const val = args[idx + 1];
-  return val && !val.startsWith("--") ? val : null;
-}
-
-/** Parse and validate CLI arguments into studio runtime options. */
-export function parseStudioOptions(args: string[]): StudioOptions {
-  const dbUrl = args[0];
-
-  if (!dbUrl || dbUrl.startsWith("--")) {
-    throw new Error("Please provide a database URL as the first argument.");
-  }
-
-  const shouldShare = args.includes("--share");
-  const tunnelName = getFlag(args, "--tunnel");
-  const publicHostname = getFlag(args, "--hostname");
-
-  if (tunnelName && !publicHostname) {
-    throw new Error(
-      "--tunnel requires --hostname <your-domain>\n   Example: --tunnel dbstudio --hostname db.yourteam.com",
-    );
-  }
-
-  // when sharing, bind to all interfaces so cloudflared can reach studio
-  const explicitHost = getFlag(args, "--host");
-  const host = explicitHost ?? (shouldShare ? "0.0.0.0" : "127.0.0.1");
-
-  return {
-    dbUrl,
-    port: getFlag(args, "--port") ?? "4983",
-    host,
-    shouldOpen: args.includes("--open"),
-    shouldShare,
-    tunnelName,
-    publicHostname,
-  };
-}

package/lib/utils/config.ts

@@ -1,70 +0,0 @@
-import { writeFileSync, unlinkSync, existsSync } from "fs";
-import { tmpdir, homedir } from "os";
-import { join } from "path";
-import type { Dialect } from "./dialect";
-
-// Temp file registry
-
-const tempFiles: string[] = [];
-
-/** Remove all temporary files created by this process. */
-export function cleanupAll() {
-  for (const f of tempFiles) {
-    if (existsSync(f)) unlinkSync(f);
-  }
-}
-
-/** Write content to a uniquely named file in the OS temp directory. */
-function writeTempFile(name: string, content: string): string {
-  const path = join(tmpdir(), `${name}-${Date.now()}`);
-  writeFileSync(path, content, "utf8");
-  tempFiles.push(path);
-  return path;
-}
-
-// Drizzle config
-
-/** Build a minimal drizzle.config.ts string for the provided database URL. */
-function generateDrizzleConfig(url: string, dialect: Dialect): string {
-  if (dialect === "sqlite") {
-    const filePath = url
-      .replace(/^sqlite:\/\//, "")
-      .replace(/^sqlite:/, "")
-      .replace(/^file:\/\//, "")
-      .replace(/^file:/, "");
-    return `export default {
-  dialect: "sqlite",
-  dbCredentials: { url: "${filePath}" },
-};`;
-  }
-
-  return `export default {
-  dialect: "${dialect}",
-  dbCredentials: { url: "${url}" },
-};`;
-}
-
-/** Create a temp drizzle config file and return its path. */
-export function createDrizzleConfig(url: string, dialect: Dialect): string {
-  return writeTempFile("dbstudio.config.ts", generateDrizzleConfig(url, dialect));
-}
-
-// Cloudflare tunnel config
-
-/** Build a temporary cloudflared config for a named tunnel run. */
-function generateTunnelConfig(tunnelName: string, hostname: string, port: string): string {
-  const credPath = join(homedir(), ".cloudflared");
-  return `tunnel: ${tunnelName}
-credentials-file: ${credPath}/${tunnelName}.json
-
-ingress:
-  - hostname: ${hostname}
-    service: http://localhost:${port}
-  - service: http_status:404
-`;
-}
-
-/** Create a temp cloudflared config file for a named tunnel and return its path. */
-export function createTunnelConfig(tunnelName: string, hostname: string, port: string): string {
-  return writeTempFile("dbstudio-tunnel.yml", generateTunnelConfig(tunnelName, hostname, port));
-}

package/lib/utils/dialect.ts

@@ -1,20 +0,0 @@
-export type Dialect = "postgresql" | "mysql" | "sqlite";
-
-/** Detect Drizzle dialect from a database URL or SQLite-style path. */
-export function detectDialect(url: string): Dialect {
-  if (url.startsWith("postgresql://") || url.startsWith("postgres://"))
-    return "postgresql";
-  if (url.startsWith("mysql://") || url.startsWith("mysql2://")) return "mysql";
-  if (
-    url.startsWith("sqlite:") ||
-    url.startsWith("file:") ||
-    url === ":memory:" ||
-    url.endsWith(".db") ||
-    url.endsWith(".sqlite")
-  )
-    return "sqlite";
-
-  throw new Error(
-    `Could not detect dialect from URL: ${url}\nSupported: postgresql://, mysql://, sqlite:, file:`,
-  );
-}

package/main.ts

@@ -1,41 +0,0 @@
-#!/usr/bin/env bun
-
-import { HELP } from "./lib/constants/help";
-import { parseStudioOptions } from "./lib/utils/args";
-import { runStudioCommand } from "./lib/commands/studio";
-
-const args = process.argv.slice(2);
-
-if (args.length === 0 || args.includes("-h") || args.includes("--help")) {
-  console.log(HELP);
-  process.exit(0);
-}
-
-if (args.includes("-v") || args.includes("--version")) {
-  const pkg = await Bun.file(
-    new URL("../package.json", import.meta.url),
-  ).json();
-  console.log(`dbstudio v${pkg.version}`);
-  process.exit(0);
-}
-
-try {
-  const options = parseStudioOptions(args);
-  const code = await runStudioCommand(options);
-  process.exit(code);
-} catch (error) {
-  const msg = error instanceof Error ? error.message : String(error);
-
-  if (msg.startsWith("Please provide")) {
-    console.error(`❌ ${msg}`);
-    console.error("   Run dbstudio --help for usage.");
-  } else if (msg.startsWith("Could not detect")) {
-    console.error(`❌ ${msg}`);
-  } else if (msg.startsWith("--tunnel requires")) {
-    console.error(`❌ ${msg}`);
-  } else {
-    console.error(`❌ Unexpected error: ${msg}`);
-  }
-
-  process.exit(1);
-}