@supacloud/cli 0.1.0 → 0.3.0

package/README.md

@@ -14,9 +14,29 @@ npx @supacloud/cli status
 npx @supacloud/cli project get
 npx @supacloud/cli project logs --log_type database
 npx @supacloud/cli database query --sql "select now()"
+npx @supacloud/cli database query --ref abc123 --file ./queries/vector-search.sql
+npx @supacloud/cli database push_migrations --ref abc123 --dir supabase/migrations --dry_run
 npx @supacloud/cli frontend list --ref abc123
 ```
 
+Use `database query --file` for complex SQL, pgvector queries, and single-request transaction blocks.
+
+```sql
+CREATE EXTENSION IF NOT EXISTS vector;
+
+CREATE TABLE documents (
+  id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
+  content text NOT NULL,
+  embedding vector(1536)
+);
+
+CREATE INDEX documents_embedding_hnsw_idx
+ON documents
+USING hnsw (embedding vector_cosine_ops);
+```
+
+Transaction boundary: SupaCloud supports transaction blocks inside one SQL request and transactional migrations. It does not expose long-lived HTTP transaction sessions; use a direct Postgres DSN for application-side long transactions.
+
 Project commands owned by this CLI:
 
 - `project get`

package/dist/index.js

@@ -1,5 +1,4 @@
 #!/usr/bin/env node
-import { createRequire } from "node:module";
 var __defProp = Object.defineProperty;
 var __returnValue = (v) => v;
 function __exportSetter(name, newValue) {
@@ -14,7 +13,6 @@ var __export = (target, all) => {
       set: __exportSetter.bind(all, name)
     });
 };
-var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 // node_modules/zod/v3/external.js
 var exports_external = {};
@@ -4347,20 +4345,57 @@ class HttpTransport {
 }
 
 // src/shared/tools/database-tools.ts
-function normalizeSqlResponse(result) {
-  if (!result.ok)
-    return result;
-  const data = result.data;
-  if (Array.isArray(data?.result) && !Array.isArray(data.rows)) {
-    return {
-      ...result,
-      data: {
-        rows: data.result,
-        rowCount: data.result.length
-      }
-    };
-  }
-  return result;
+import { existsSync as existsSync2, readdirSync, readFileSync as readFileSync2, statSync } from "node:fs";
+import { basename, join } from "node:path";
+function migrationVersionFromFilename(file, fallbackIndex = 0) {
+  const match = basename(file).match(/^(\d{8,20})[_-]/);
+  if (match)
+    return Number(match[1]);
+  return Date.now() * 1000 + fallbackIndex;
+}
+function appliedMigrationKeys(data) {
+  const rows = Array.isArray(data) ? data : data?.rows || [];
+  const keys = new Set;
+  for (const row of rows) {
+    if (!row || typeof row !== "object")
+      continue;
+    const migration = row;
+    if (migration.version != null)
+      keys.add(String(migration.version));
+    if (migration.name != null)
+      keys.add(String(migration.name));
+  }
+  return keys;
+}
+function sqlReferencesVector(sql) {
+  return /\bvector\s*\(\s*\d+\s*\)/i.test(sql) || /::\s*vector\b/i.test(sql) || /\bvector_(cosine|l2|ip)_ops\b/i.test(sql) || /<=>|<#>|<->/.test(sql);
+}
+function sqlCreatesVectorExtension(sql) {
+  return /\bCREATE\s+EXTENSION\s+(?:IF\s+NOT\s+EXISTS\s+)?["']?vector["']?/i.test(sql);
+}
+function extensionRows(data) {
+  if (Array.isArray(data))
+    return data;
+  const shaped = data;
+  const rows = shaped?.rows || [];
+  return Array.isArray(rows) ? rows : [];
+}
+function vectorWarningsForPendingMigrations(migrations, vectorEnabled) {
+  const warnings = [];
+  const vectorUsers = migrations.filter(({ sql }) => sqlReferencesVector(sql));
+  const vectorCreators = migrations.filter(({ sql }) => sqlCreatesVectorExtension(sql));
+  if (!vectorUsers.length && !vectorCreators.length)
+    return warnings;
+  if (vectorEnabled === false && vectorUsers.length && !vectorCreators.length) {
+    warnings.push(`vector extension is not enabled, but pending migrations use vector types/operators: ${vectorUsers.map(({ file }) => file).join(", ")}`);
+  }
+  if (vectorEnabled === false && vectorCreators.length) {
+    warnings.push(`pending migrations will enable pgvector: ${vectorCreators.map(({ file }) => file).join(", ")}`);
+  }
+  if (vectorEnabled === null) {
+    warnings.push("could not verify whether vector extension is enabled");
+  }
+  return warnings;
 }
 function registerDatabaseTools(server, http, config = {}) {
   const { readOnly = false, projectRef } = config;
@@ -4382,7 +4417,7 @@ function registerDatabaseTools(server, http, config = {}) {
     "project_url",
     "generate_types"
   ];
-  const writeActions = ["apply_migration", "create_table_rls"];
+  const writeActions = ["apply_migration", "push_migrations", "create_table_rls"];
   const allActions = readOnly ? actions : [...actions, ...writeActions];
   server.tool("database", `Database operations: query, schema, RLS, migrations, stats.
 Actions: ${allActions.join(", ")}${readOnly ? " (read-only mode)" : ""}`, {
@@ -4390,6 +4425,8 @@ Actions: ${allActions.join(", ")}${readOnly ? " (read-only mode)" : ""}`, {
     ref: projectRef ? exports_external.string().optional() : exports_external.string().optional().describe("Project ref"),
     sql: exports_external.string().optional().describe("[query/apply_migration] SQL statement"),
     file: exports_external.string().optional().describe("[query/apply_migration] Read SQL from local file path (avoids shell escaping issues with $$ and multi-statement DDL)"),
+    dir: exports_external.string().optional().describe("[push_migrations] Directory containing .sql migration files (default: supabase/migrations)"),
+    dry_run: exports_external.boolean().optional().describe("[push_migrations] List pending migration files without applying them"),
     schema: exports_external.string().optional().describe("[*] Schema name (default: public)"),
     table: exports_external.string().optional().describe("[describe_columns/indexes/constraints/rls_*] Table name"),
     schemas: exports_external.array(exports_external.string()).optional().describe("[list_tables/generate_types] Schemas array"),
@@ -4404,12 +4441,12 @@ Actions: ${allActions.join(", ")}${readOnly ? " (read-only mode)" : ""}`, {
     const schemas = args.schemas || ["public"];
     if (args.file && !args.sql) {
       try {
-        args.sql = __require("fs").readFileSync(args.file, "utf-8");
+        args.sql = readFileSync2(args.file, "utf-8");
       } catch (e) {
         return { content: [{ type: "text", text: `❌ Failed to read file ${args.file}: ${e.message}` }] };
       }
     }
-    const execSql = async (sql) => normalizeSqlResponse(await http.post(`/v1/projects/${ref}/database/sql`, { sql }));
+    const execSql = async (sql) => http.post(`/v1/projects/${ref}/database/sql`, { sql });
     let text;
     switch (action) {
       case "query": {
@@ -4532,6 +4569,85 @@ Actions: ${allActions.join(", ")}${readOnly ? " (read-only mode)" : ""}`, {
         text = r.ok ? `✅ Migration '${args.name}' applied` : `❌ Failed (${r.status}): ${JSON.stringify(r.data)}`;
         break;
       }
+      case "push_migrations": {
+        const dir = args.dir || "supabase/migrations";
+        if (!existsSync2(dir) || !statSync(dir).isDirectory()) {
+          throw new Error(`Migration directory not found: ${dir}`);
+        }
+        const files = readdirSync(dir).filter((file) => file.endsWith(".sql")).sort();
+        if (!files.length) {
+          text = `No .sql migration files found in ${dir}`;
+          break;
+        }
+        const migrationFiles = files.map((file, i) => ({
+          file,
+          name: basename(file, ".sql"),
+          version: migrationVersionFromFilename(file, i)
+        }));
+        if (args.dry_run) {
+          const r = await http.get(`/v1/projects/${ref}/database/migrations`);
+          if (!r.ok) {
+            text = `❌ Failed to load applied migrations (${r.status}): ${JSON.stringify(r.data)}`;
+            break;
+          }
+          const appliedKeys = appliedMigrationKeys(r.data);
+          const pending = migrationFiles.filter(({ name, version }) => !appliedKeys.has(name) && !appliedKeys.has(String(version)));
+          const alreadyApplied = migrationFiles.filter(({ name, version }) => appliedKeys.has(name) || appliedKeys.has(String(version)));
+          const pendingWithSql = pending.map((migration) => ({
+            ...migration,
+            sql: readFileSync2(join(dir, migration.file), "utf-8")
+          }));
+          let vectorEnabled = null;
+          if (pendingWithSql.some(({ sql }) => sqlReferencesVector(sql) || sqlCreatesVectorExtension(sql))) {
+            const extResult = await execSql("SELECT extname AS name FROM pg_extension WHERE extname = 'vector';");
+            vectorEnabled = extResult.ok ? extensionRows(extResult.data).some((row) => row.name === "vector" || row.extname === "vector") : null;
+          }
+          const warnings = vectorWarningsForPendingMigrations(pendingWithSql, vectorEnabled);
+          text = [
+            `Migration dry run for ${dir}`,
+            `Total: ${migrationFiles.length}`,
+            "",
+            "Pending:",
+            ...pending.length ? pending.map(({ file, version }) => `  - ${file} (${version})`) : ["  - none"],
+            "",
+            "Already applied:",
+            ...alreadyApplied.length ? alreadyApplied.map(({ file, version }) => `  - ${file} (${version})`) : ["  - none"],
+            ...warnings.length ? ["", "Warnings:", ...warnings.map((warning) => `  - ${warning}`)] : []
+          ].join(`
+`);
+          break;
+        }
+        const applied = [];
+        const skipped = [];
+        for (const { file, name, version } of migrationFiles) {
+          const sql = readFileSync2(join(dir, file), "utf-8");
+          const r = await http.post(`/v1/projects/${ref}/database/migrations`, { name, sql, version });
+          if (r.ok) {
+            applied.push(file);
+          } else if (r.status === 409) {
+            skipped.push(file);
+          } else {
+            text = [
+              `❌ Failed to apply ${file} (${r.status})`,
+              JSON.stringify(r.data, null, 2),
+              "",
+              `Applied before failure: ${applied.length}`,
+              `Skipped before failure: ${skipped.length}`
+            ].join(`
+`);
+            return { content: [{ type: "text", text }] };
+          }
+        }
+        text = [
+          `✅ Migration push completed for ${dir}`,
+          `Applied: ${applied.length}`,
+          `Skipped: ${skipped.length}`,
+          ...applied.length ? ["", "Applied files:", ...applied.map((file) => `  - ${file}`)] : [],
+          ...skipped.length ? ["", "Skipped files:", ...skipped.map((file) => `  - ${file}`)] : []
+        ].join(`
+`);
+        break;
+      }
       case "create_table_rls": {
         if (!args.table || !args.columns)
           throw new Error("'table' and 'columns' required");
@@ -5028,69 +5144,125 @@ Actions: status, list_buckets, list_files, upload_base64, delete_file`, {
 }
 
 // src/shared/tools/advanced-tools.ts
+import { existsSync as existsSync3, mkdtempSync, readFileSync as readFileSync3, rmSync, statSync as statSync2, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { basename as basename2, join as join2, resolve as resolve2 } from "node:path";
+import { promisify } from "node:util";
+import { execFile } from "node:child_process";
+var execFileAsync = promisify(execFile);
+async function runBunBuild(args) {
+  try {
+    return await execFileAsync("bun", ["build", ...args], { maxBuffer: 10 * 1024 * 1024 });
+  } catch (error) {
+    const e = error;
+    if (e.code === "ENOENT") {
+      throw new Error("Bun is required for local edge function bundling. Install Bun or use deploy_bundle with explicit files.");
+    }
+    throw error;
+  }
+}
+async function bundleEdgeFunctionPath(pathArg) {
+  const entrypoint = resolveEntrypoint(pathArg);
+  const tmpDir = mkdtempSync(join2(tmpdir(), "supacloud-edge-"));
+  const outfile = join2(tmpDir, `${basename2(entrypoint).replace(/\.[^.]+$/, "") || "index"}.js`);
+  try {
+    const { stderr } = await runBunBuild([entrypoint, "--target", "bun", "--outfile", outfile]);
+    if (!existsSync3(outfile))
+      throw new Error(`Bundle failed: ${stderr}`);
+    return readFileSync3(outfile, "utf-8");
+  } finally {
+    rmSync(tmpDir, { recursive: true, force: true });
+  }
+}
+function resolveEntrypoint(pathArg) {
+  const resolved = resolve2(pathArg);
+  const stat = statSync2(resolved);
+  if (!stat.isDirectory())
+    return resolved;
+  const entrypoint = join2(resolved, "index.ts");
+  if (!existsSync3(entrypoint)) {
+    throw new Error(`Directory provided but no index.ts found at ${entrypoint}`);
+  }
+  return entrypoint;
+}
+var backgroundRoutesSchema = exports_external.preprocess((value) => {
+  if (typeof value !== "string")
+    return value;
+  const trimmed = value.trim();
+  if (!trimmed)
+    return [];
+  if (!trimmed.startsWith("["))
+    return trimmed.split(",").map((route) => route.trim()).filter(Boolean);
+  try {
+    return JSON.parse(trimmed);
+  } catch {
+    return [trimmed];
+  }
+}, exports_external.array(exports_external.string()).optional().superRefine((routes, ctx) => {
+  if (!routes)
+    return;
+  for (const route of routes) {
+    if (route.trim().startsWith("[")) {
+      ctx.addIssue({
+        code: exports_external.ZodIssueCode.custom,
+        message: "Invalid background_routes JSON array. Use a valid JSON array or comma-separated routes like /queue/*,/render/*."
+      });
+      return;
+    }
+  }
+}));
 function registerAdvancedTools(server, http) {
   server.tool("edge_functions", `Edge Function management (Deno/Bun serverless). Server auto-bundles dependencies.
-Actions: list, deploy, deploy_bundle, source, delete, check`, {
-    action: exports_external.enum(["list", "deploy", "deploy_bundle", "source", "delete", "check"]).describe("Action"),
+Actions: list, deploy, deploy_bundle, config, source, delete, check`, {
+    action: exports_external.enum(["list", "deploy", "deploy_bundle", "config", "source", "delete", "check"]).describe("Action"),
     ref: exports_external.string().describe("Project ref"),
-    slug: exports_external.string().optional().describe("[deploy/deploy_bundle/source/delete/check] Function name"),
+    slug: exports_external.string().optional().describe("[deploy/deploy_bundle/config/source/delete/check] Function name"),
     code: exports_external.string().optional().describe("[deploy/check] Function source code (TypeScript)"),
     path: exports_external.string().optional().describe("[deploy/check] Local file path to read code from (alternative to code)"),
     files: exports_external.record(exports_external.string()).optional().describe("[deploy_bundle] File map: { 'index.ts': '...', '_shared/x.ts': '...' }"),
     entrypoint: exports_external.string().optional().describe("[deploy_bundle] Entrypoint file (default: index.ts)"),
-    minify: exports_external.boolean().optional().describe("[deploy/deploy_bundle] Minify bundle")
+    minify: exports_external.boolean().optional().describe("[deploy/deploy_bundle] Minify bundle"),
+    verify_jwt: exports_external.boolean().optional().describe("[deploy/deploy_bundle/config] Set JWT verification for this function"),
+    background_routes: backgroundRoutesSchema.describe("[deploy/deploy_bundle/config] Background route paths; pass comma-separated or JSON array in CLI")
   }, async (args) => {
-    const { action, ref, slug, path: pathArg, files, entrypoint, minify } = args;
+    const { action, ref, slug, path: pathArg, files, entrypoint, minify, verify_jwt, background_routes } = args;
     let code = args.code;
     const need = (f, v) => {
       if (!v)
         throw new Error(`'${f}' required for '${action}'`);
     };
     let text;
+    const functionConfig = () => ({
+      ...typeof verify_jwt === "boolean" ? { verify_jwt } : {},
+      ...Array.isArray(background_routes) ? { background_routes } : {}
+    });
+    const hasFunctionConfig = () => Object.keys(functionConfig()).length > 0;
+    const updateFunctionConfig = async () => {
+      need("slug", slug);
+      if (!hasFunctionConfig()) {
+        throw new Error("'verify_jwt' or 'background_routes' required for 'config'");
+      }
+      const cr = await http.patch(`/v1/projects/${ref}/functions/${slug}/config`, functionConfig());
+      return cr.ok ? `✅ Function ${slug} config updated
+${JSON.stringify(cr.data, null, 2)}` : `❌ Config update failed (${cr.status}): ${JSON.stringify(cr.data)}`;
+    };
     const checkSyntax = async (sourceCode) => {
-      const fs = __require("fs");
-      const os = __require("os");
-      const { promisify } = __require("util");
-      const execAsync = promisify(__require("child_process").exec);
-      const tmpFile = `${os.tmpdir()}/supacloud_edge_${Date.now()}.ts`;
-      fs.writeFileSync(tmpFile, sourceCode);
+      const tmpDir = mkdtempSync(join2(tmpdir(), "supacloud-edge-check-"));
+      const tmpFile = join2(tmpDir, "index.ts");
+      writeFileSync(tmpFile, sourceCode);
       try {
-        await execAsync(`bun build ${tmpFile} --external='*'`);
+        await runBunBuild([tmpFile, "--external", "*"]);
         return { ok: true };
       } catch (e) {
-        return { ok: false, err: e.stdout + `
-` + (e.stderr || e.message) };
+        return { ok: false, err: `${e.stdout || ""}
+${e.stderr || e.message}` };
       } finally {
-        try {
-          fs.unlinkSync(tmpFile);
-        } catch (e) {}
+        rmSync(tmpDir, { recursive: true, force: true });
       }
     };
     if (pathArg && !code) {
       try {
-        const fs = __require("fs");
-        const os = __require("os");
-        const { promisify } = __require("util");
-        const execAsync = promisify(__require("child_process").exec);
-        const stat = fs.statSync(pathArg);
-        let entrypoint2 = pathArg;
-        if (stat.isDirectory()) {
-          entrypoint2 = `${pathArg}/index.ts`;
-          if (!fs.existsSync(entrypoint2)) {
-            throw new Error(`Directory provided but no index.ts found at ${entrypoint2}`);
-          }
-        }
-        const tmpOut = `${os.tmpdir()}/supacloud_bundled_${Date.now()}.js`;
-        try {
-          const { stderr } = await execAsync(`bun build ${entrypoint2} --target bun --outfile ${tmpOut}`);
-          if (!fs.existsSync(tmpOut))
-            throw new Error(`Bundle failed: ${stderr}`);
-          code = fs.readFileSync(tmpOut, "utf-8");
-        } finally {
-          try {
-            fs.unlinkSync(tmpOut);
-          } catch (e) {}
-        }
+        code = await bundleEdgeFunctionPath(pathArg);
       } catch (e) {
         throw new Error(`Failed to bundle/read path ${pathArg}: ${e.message}`);
       }
@@ -5119,13 +5291,26 @@ ${deployCheck.err}`;
           break;
         }
         const dr = await http.post(`/v1/projects/${ref}/functions/${slug}`, { code, minify });
-        text = dr.ok ? `✅ Function ${slug} deployed` : `❌ Failed (${dr.status}): ${JSON.stringify(dr.data)}`;
+        if (!dr.ok) {
+          text = `❌ Failed (${dr.status}): ${JSON.stringify(dr.data)}`;
+          break;
+        }
+        text = hasFunctionConfig() ? `✅ Function ${slug} deployed
+${await updateFunctionConfig()}` : `✅ Function ${slug} deployed`;
         break;
       case "deploy_bundle":
         need("slug", slug);
         need("files", files);
         const br = await http.post(`/v1/projects/${ref}/functions/${slug}/bundle`, { files, entrypoint, minify });
-        text = br.ok ? `✅ Function ${slug} bundle deployed (${Object.keys(files).length} files)` : `❌ Failed (${br.status}): ${JSON.stringify(br.data)}`;
+        if (!br.ok) {
+          text = `❌ Failed (${br.status}): ${JSON.stringify(br.data)}`;
+          break;
+        }
+        text = hasFunctionConfig() ? `✅ Function ${slug} bundle deployed (${Object.keys(files).length} files)
+${await updateFunctionConfig()}` : `✅ Function ${slug} bundle deployed (${Object.keys(files).length} files)`;
+        break;
+      case "config":
+        text = await updateFunctionConfig();
         break;
       case "source":
         need("slug", slug);
@@ -5230,7 +5415,8 @@ ${JSON.stringify(r.data, null, 2)}` : `❌ Failed (${r.status})`;
 }
 
 // src/shared/tools/frontend-tools.ts
-import { basename } from "node:path";
+import { existsSync as existsSync4, readFileSync as readFileSync4 } from "node:fs";
+import { basename as basename3 } from "node:path";
 function registerFrontendTools(server, http) {
   server.tool("frontend", `Frontend hosting (static sites & SSR). Supports: static, react, vue, svelte, sveltekit, nextjs, nuxt, astro.
 Actions: list, get, create, update, delete, deploy_git, deploy_upload, redeploy, build_logs, add_domain, remove_domain, set_env, list_frameworks, list_records`, {
@@ -5324,14 +5510,12 @@ Actions: list, get, create, update, delete, deploy_git, deploy_upload, redeploy,
         need("ref", ref);
         need("id", id);
         need("zip_path", zip_path);
-        const file = Bun.file(zip_path);
-        if (!await file.exists()) {
+        if (!existsSync4(zip_path)) {
           throw new Error(`Zip file not found: ${zip_path}`);
         }
+        const zipBuffer = readFileSync4(zip_path);
         const form = new FormData;
-        form.append("file", new File([await file.arrayBuffer()], basename(zip_path), {
-          type: "application/zip"
-        }));
+        form.append("file", new Blob([zipBuffer], { type: "application/zip" }), basename3(zip_path));
         text = ok(await http.postMultipart(`/v1/projects/${ref}/frontend/deployments/${id}/deploy/upload`, form));
         break;
       case "redeploy":
@@ -5462,6 +5646,15 @@ function registerUserProjectCliTools(server, http, options = {}) {
 // src/index.ts
 var projectActionSchema = exports_external.enum(["get", "health", "logs", "api_keys", "settings", "tasks"]);
 var genericActionSchema = exports_external.string();
+function unwrapMcpSchema(schema) {
+  if (schema && typeof schema === "object" && !Array.isArray(schema) && "args" in schema) {
+    const argsSchema = schema.args;
+    if (argsSchema && typeof argsSchema === "object" && !Array.isArray(argsSchema)) {
+      return argsSchema;
+    }
+  }
+  return schema;
+}
 function captureTools(register) {
   const tools = {};
   const server = {
@@ -5469,7 +5662,7 @@ function captureTools(register) {
       if (typeof schemaOrCallback === "function") {
         tools[name] = { schema: {}, callback: schemaOrCallback };
       } else {
-        tools[name] = { schema: schemaOrCallback, callback };
+        tools[name] = { schema: unwrapMcpSchema(schemaOrCallback), callback };
       }
     }
   };
@@ -5506,7 +5699,10 @@ EXAMPLES
   supacloud project logs --log_type database
   supacloud frontend list --ref abc123
   supacloud database query --sql "select now()"
+  supacloud database query --ref abc123 --file ./queries/vector-search.sql
+  supacloud database push_migrations --ref abc123 --dir supabase/migrations --dry_run
   supacloud edge_functions deploy --ref abc123 --slug hello --path ./supabase/functions/hello
+  supacloud edge_functions config --ref abc123 --slug hello --verify_jwt false --background_routes "/queue/*,/render/*"
 
 SEPARATE ADMIN CLI
 
@@ -5615,10 +5811,11 @@ function createCliTools() {
   assign(captureTools((server) => registerUserProjectCliTools(server, http, {
     projectRef: context.projectRef || undefined
   })));
-  assign(captureTools((server) => registerDatabaseTools(server, http, {
+  const databaseTools = captureTools((server) => registerDatabaseTools(server, http, {
     projectRef: context.projectRef || undefined,
     readOnly: context.readOnly
-  })));
+  }));
+  assign(databaseTools);
   assign(captureTools((server) => registerAuthTools(server, http)));
   assign(captureTools((server) => registerStorageTools(server, http)));
   assign(captureTools((server) => registerAdvancedTools(server, http)));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@supacloud/cli",
-  "version": "0.1.0",
+  "version": "0.3.0",
   "description": "Project-scoped CLI for SupaCloud users",
   "type": "module",
   "main": "./dist/index.js",