@supacloud/cli 0.32.0 → 0.33.0

package/README.md

@@ -440,6 +440,35 @@ Use `--data_mode full_clone` only for an explicitly approved non-sensitive or
 masked debugging dataset. Whole-database replacement is an administrator-only
 break-glass API mode and is intentionally not exposed by this project CLI.
 
+## SupaCloud Lite CLI adapter
+
+Lite can be used from its standalone `supacloud-lite` CLI and from the main
+`supacloud-cli` through the local-only `lite` module. The adapter never calls
+the Management API, never invokes the official Supabase CLI, and never treats a
+PGlite data directory as a Postgres DSN.
+
+```bash
+supacloud-cli lite migrate --project_dir .
+supacloud-cli lite status --project_dir .
+supacloud-cli lite db_diff --project_dir . --file add_accounts
+supacloud-cli lite db_pull --project_dir . --file remote_schema
+supacloud-cli lite gen_types --project_dir . --output src/database.types.ts
+supacloud-cli lite snapshot_create --project_dir . --output backups/lite.tar.gz
+supacloud-cli lite doctor --project_dir . --json
+supacloud-cli lite start --project_dir . --port 54321
+```
+
+The adapter resolves the executable in this order:
+
+1. `SUPACLOUD_LITE_CLI_BIN`
+2. `<workdir>/node_modules/@supacloud/lite/dist/launcher.cjs`
+3. `supacloud-lite` on `PATH`
+
+Install `@supacloud/lite` or provide an explicit binary before using the
+adapter. Lite actions are local-only, so Management API context and project
+refs are not required. The `supabase` module remains the official CLI adapter;
+use it for upstream Supabase CLI actions and Management-backed remote pushes.
+
 ## Official Supabase CLI adapter
 
 The `supabase` command group is a thin, allowlisted adapter around the official

package/dist/index.js

@@ -6471,6 +6471,24 @@ var ACTION_POLICY = {
     local: ["version", "migration_new", "db_diff", "db_reset", "db_pull", "db_dump", "migration_list", "gen_types"],
     write: ["push"]
   },
+  lite: {
+    local: [
+      "version",
+      "start",
+      "migrate",
+      "status",
+      "keys",
+      "gen_types",
+      "db_reset",
+      "db_diff",
+      "db_pull",
+      "snapshot_create",
+      "snapshot_restore",
+      "upgrade",
+      "inspect",
+      "doctor"
+    ]
+  },
   auth: {
     read: ["list_users", "get_user", "list_providers", "get_provider", "supported_providers", "get_settings", "get_config", "get_oauth_server"],
     write: ["generate_link", "configure_provider", "update_provider", "disable_provider", "wechat_mini", "wechat_open", "update_settings", "update_config", "migrate_oauth_server"]
@@ -12894,10 +12912,236 @@ function registerSupabaseCliTools(server, options = {}) {
   }, (request) => executeSupabaseAction(request, runtime));
 }
 
+// src/shared/tools/lite-cli-tools.ts
+import { spawn as spawn2 } from "node:child_process";
+import { existsSync as existsSync6, statSync as statSync4 } from "node:fs";
+import { join as join4, resolve as resolve4 } from "node:path";
+function requireWorkdir(workdir, fallback) {
+  const resolved = resolve4(workdir || fallback);
+  if (!existsSync6(resolved) || !statSync4(resolved).isDirectory()) {
+    throw new Error(`Lite workdir not found: ${resolved}`);
+  }
+  return resolved;
+}
+function optionalFlag(args, flag, value) {
+  if (value !== undefined)
+    args.push(flag, String(value));
+}
+function booleanFlag(args, flag, value) {
+  if (value === true)
+    args.push(flag);
+}
+function buildLiteArgs(request) {
+  const args = [];
+  if (request.action === "version")
+    return ["--version"];
+  switch (request.action) {
+    case "start":
+    case "migrate":
+    case "status":
+    case "keys":
+    case "upgrade":
+    case "inspect":
+    case "doctor":
+      args.push(request.action);
+      break;
+    case "gen_types":
+      args.push("gen", "types");
+      break;
+    case "db_reset":
+      args.push("db", "reset");
+      break;
+    case "db_diff":
+      args.push("db", "diff");
+      break;
+    case "db_pull":
+      args.push("db", "pull");
+      if (request.file)
+        args.push(request.file);
+      break;
+    case "snapshot_create":
+      args.push("snapshot", "create");
+      break;
+    case "snapshot_restore":
+      if (!request.snapshot_file)
+        throw new Error("snapshot_restore requires --snapshot_file");
+      args.push("snapshot", "restore", request.snapshot_file);
+      break;
+    default:
+      throw new Error(`Unsupported Lite CLI action: ${String(request.action)}`);
+  }
+  optionalFlag(args, "--project-dir", request.project_dir);
+  optionalFlag(args, "--state-dir", request.state_dir);
+  optionalFlag(args, "--data-dir", request.data_dir);
+  optionalFlag(args, "--storage-dir", request.storage_dir);
+  optionalFlag(args, "--storage-backend", request.storage_backend);
+  optionalFlag(args, "--s3-prefix", request.s3_prefix);
+  optionalFlag(args, "--engine", request.engine);
+  optionalFlag(args, "--host", request.host);
+  optionalFlag(args, "--port", request.port);
+  optionalFlag(args, "--api-url", request.api_url);
+  optionalFlag(args, "--site-url", request.site_url);
+  optionalFlag(args, "--replication-profile", request.replication_profile);
+  optionalFlag(args, "--replication-host", request.replication_host);
+  optionalFlag(args, "--replication-port", request.replication_port);
+  optionalFlag(args, "--replication-allow-cidrs", request.replication_allow_cidrs);
+  optionalFlag(args, "--powersync-tables", request.powersync_tables);
+  optionalFlag(args, "--replication-tls-cert", request.replication_tls_cert);
+  optionalFlag(args, "--replication-tls-key", request.replication_tls_key);
+  optionalFlag(args, "--output", request.output);
+  optionalFlag(args, "--file", request.action === "db_diff" ? request.file : undefined);
+  booleanFlag(args, "--service-role", request.service_role);
+  booleanFlag(args, "--force", request.force);
+  booleanFlag(args, "--memory", request.memory);
+  booleanFlag(args, "--json", request.json);
+  return args;
+}
+function resolveLiteCommand(workdir, environment = process.env) {
+  const explicitBinary = environment.SUPACLOUD_LITE_CLI_BIN?.trim();
+  if (explicitBinary) {
+    if (explicitBinary.includes("\x00"))
+      throw new Error("Invalid SUPACLOUD_LITE_CLI_BIN");
+    return [explicitBinary];
+  }
+  const localPackageEntry = join4(resolve4(workdir), "node_modules", "@supacloud", "lite", "dist", "launcher.cjs");
+  if (existsSync6(localPackageEntry))
+    return [process.execPath, localPackageEntry];
+  return ["supacloud-lite"];
+}
+function spawnLiteCommand(command, workdir, environment, inheritOutput) {
+  const [executable, ...commandArguments] = command;
+  return new Promise((resolveExecution, rejectExecution) => {
+    const child = spawn2(executable, commandArguments, {
+      cwd: workdir,
+      env: { ...environment, NO_COLOR: "1" },
+      shell: false,
+      stdio: inheritOutput ? ["inherit", "inherit", "inherit"] : ["ignore", "pipe", "pipe"],
+      windowsHide: true
+    });
+    const forwardSignal = (signal) => child.kill(signal);
+    process.once("SIGINT", forwardSignal);
+    process.once("SIGTERM", forwardSignal);
+    const cleanup = () => {
+      process.off("SIGINT", forwardSignal);
+      process.off("SIGTERM", forwardSignal);
+    };
+    if (inheritOutput) {
+      child.once("error", (error) => {
+        cleanup();
+        rejectExecution(error);
+      });
+      child.once("close", (exitCode) => {
+        cleanup();
+        resolveExecution({ exitCode: exitCode ?? 1, stdout: "", stderr: "" });
+      });
+      return;
+    }
+    if (!child.stdout || !child.stderr) {
+      cleanup();
+      rejectExecution(new Error("Lite CLI child process did not expose piped output"));
+      return;
+    }
+    let standardOutput = "";
+    let standardError = "";
+    child.stdout.setEncoding("utf8");
+    child.stderr.setEncoding("utf8");
+    child.stdout.on("data", (chunk) => {
+      standardOutput += chunk;
+    });
+    child.stderr.on("data", (chunk) => {
+      standardError += chunk;
+    });
+    child.once("error", (error) => {
+      cleanup();
+      rejectExecution(error);
+    });
+    child.once("close", (exitCode) => {
+      cleanup();
+      resolveExecution({ exitCode: exitCode ?? 1, stdout: standardOutput, stderr: standardError });
+    });
+  });
+}
+async function executeLiteCli(request, environment, fallbackWorkdir) {
+  const workdir = requireWorkdir(request.workdir, fallbackWorkdir);
+  const command = [...resolveLiteCommand(workdir, environment), ...buildLiteArgs({ ...request, workdir })];
+  try {
+    return await spawnLiteCommand(command, workdir, environment, request.action === "start");
+  } catch (error) {
+    const failureMessage = error instanceof Error ? error.message : String(error);
+    throw new Error([
+      "SupaCloud Lite CLI could not be started.",
+      "Install @supacloud/lite, put supacloud-lite on PATH, or set SUPACLOUD_LITE_CLI_BIN.",
+      failureMessage
+    ].join(" "));
+  }
+}
+function formatExecutionText2(action, execution) {
+  const combinedOutput = [execution.stdout.trim(), execution.stderr.trim()].filter(Boolean).join(`
+`);
+  const heading = execution.exitCode === 0 ? `✅ SupaCloud Lite ${action} completed` : `❌ SupaCloud Lite ${action} failed (exit ${execution.exitCode})`;
+  return combinedOutput ? `${heading}
+${combinedOutput}` : heading;
+}
+function registerLiteCliTools(server, options = {}) {
+  const environment = options.environment || process.env;
+  const fallbackWorkdir = options.currentWorkingDirectory || process.cwd();
+  const execute = options.executeLiteCli || ((request) => executeLiteCli(request, environment, fallbackWorkdir));
+  server.tool("lite", "Controlled adapter for the local SupaCloud Lite CLI. Lite actions are local-only and never use the Management API or official Supabase CLI.", {
+    action: withDescription(stringEnum([
+      "version",
+      "start",
+      "migrate",
+      "status",
+      "keys",
+      "gen_types",
+      "db_reset",
+      "db_diff",
+      "db_pull",
+      "snapshot_create",
+      "snapshot_restore",
+      "upgrade",
+      "inspect",
+      "doctor"
+    ]), "Lite CLI action"),
+    workdir: optional(Type.String(), "[*] Process working directory (default: current directory)"),
+    project_dir: optional(Type.String(), "[*] Project containing supabase/"),
+    state_dir: optional(Type.String(), "[*] Lite state root"),
+    data_dir: optional(Type.String(), "[*] PGlite/native data directory"),
+    storage_dir: optional(Type.String(), "[*] Object storage directory"),
+    storage_backend: optional(stringEnum(["fs", "memory", "s3"]), "[*] Storage backend"),
+    s3_prefix: optional(Type.String(), "[*] S3 object key prefix"),
+    engine: optional(stringEnum(["pglite", "native"]), "[*] Database engine"),
+    host: optional(Type.String(), "[start] Listen host"),
+    port: optional(Type.Number(), "[start] Listen port"),
+    api_url: optional(Type.String(), "[start] Public API URL"),
+    site_url: optional(Type.String(), "[start] Auth site URL"),
+    replication_profile: optional(stringEnum(["powersync"]), "[start/doctor] Replication profile"),
+    replication_host: optional(Type.String(), "[start] Replication listener host"),
+    replication_port: optional(Type.Number(), "[start] Replication listener port"),
+    replication_allow_cidrs: optional(Type.String(), "[start] Replication client CIDRs"),
+    powersync_tables: optional(Type.String(), "[start] PowerSync publication tables"),
+    replication_tls_cert: optional(Type.String(), "[start] Replication TLS certificate"),
+    replication_tls_key: optional(Type.String(), "[start] Replication TLS private key"),
+    output: optional(Type.String(), "[gen_types/snapshot_create/upgrade] Output path"),
+    file: optional(Type.String(), "[db_diff/db_pull] Migration suffix or name"),
+    snapshot_file: optional(Type.String(), "[snapshot_restore] Snapshot archive"),
+    service_role: optional(Type.Boolean(), "[keys] Also print the service_role key"),
+    force: optional(Type.Boolean(), "[snapshot_restore] Replace non-empty restore targets"),
+    memory: optional(Type.Boolean(), "[*] Use an in-memory PGlite database"),
+    json: optional(Type.Boolean(), "[doctor] Emit machine-readable output")
+  }, async (request) => {
+    const execution = await execute(request);
+    return {
+      isError: execution.exitCode !== 0,
+      content: [{ type: "text", text: formatExecutionText2(request.action, execution) }]
+    };
+  });
+}
+
 // src/shared/tools/ai-tools.ts
 import {
   cpSync,
-  existsSync as existsSync6,
+  existsSync as existsSync7,
   lstatSync as lstatSync2,
   mkdirSync as mkdirSync2,
   mkdtempSync as mkdtempSync2,
@@ -12907,13 +13151,13 @@ import {
   rmSync as rmSync2
 } from "node:fs";
 import { homedir as homedir2 } from "node:os";
-import { dirname as dirname2, join as join4, relative as relative2, resolve as resolve4, sep as sep2 } from "node:path";
+import { dirname as dirname2, join as join5, relative as relative2, resolve as resolve5, sep as sep2 } from "node:path";
 import { fileURLToPath } from "node:url";
 var SKILL_NAME = "supacloud-cli";
 function regularFiles(rootDirectory, currentDirectory = rootDirectory) {
   const files = [];
   for (const directoryEntry of readdirSync3(currentDirectory, { withFileTypes: true })) {
-    const entryPath = join4(currentDirectory, directoryEntry.name);
+    const entryPath = join5(currentDirectory, directoryEntry.name);
     if (directoryEntry.isSymbolicLink())
       throw new Error(`Skill directories cannot contain symlinks: ${entryPath}`);
     if (directoryEntry.isDirectory())
@@ -12924,13 +13168,13 @@ function regularFiles(rootDirectory, currentDirectory = rootDirectory) {
   return files.sort();
 }
 function directoriesMatch(sourceDirectory, destinationDirectory) {
-  if (!existsSync6(destinationDirectory) || !lstatSync2(destinationDirectory).isDirectory())
+  if (!existsSync7(destinationDirectory) || !lstatSync2(destinationDirectory).isDirectory())
     return false;
   const sourceFiles = regularFiles(sourceDirectory);
   const destinationFiles = regularFiles(destinationDirectory);
   if (sourceFiles.join("\x00") !== destinationFiles.join("\x00"))
     return false;
-  return sourceFiles.every((file) => readFileSync5(join4(sourceDirectory, file)).equals(readFileSync5(join4(destinationDirectory, file))));
+  return sourceFiles.every((file) => readFileSync5(join5(sourceDirectory, file)).equals(readFileSync5(join5(destinationDirectory, file))));
 }
 function backupTimestamp(now) {
   return now.toISOString().replace(/[-:.]/g, "");
@@ -12939,7 +13183,7 @@ function availableBackupDirectory(destinationDirectory, now) {
   const baseDirectory = `${destinationDirectory}.backup-${backupTimestamp(now)}`;
   let candidate = baseDirectory;
   let suffix = 2;
-  while (existsSync6(candidate)) {
+  while (existsSync7(candidate)) {
     candidate = `${baseDirectory}-${suffix}`;
     suffix += 1;
   }
@@ -12947,8 +13191,8 @@ function availableBackupDirectory(destinationDirectory, now) {
 }
 function stagedSkill(sourceDirectory, targetRoot) {
   mkdirSync2(targetRoot, { recursive: true });
-  const stagingRoot = mkdtempSync2(join4(targetRoot, ".supacloud-cli-install-"));
-  const stagingSkill = join4(stagingRoot, SKILL_NAME);
+  const stagingRoot = mkdtempSync2(join5(targetRoot, ".supacloud-cli-install-"));
+  const stagingSkill = join5(stagingRoot, SKILL_NAME);
   try {
     cpSync(sourceDirectory, stagingSkill, { recursive: true, errorOnExist: true });
   } catch (error) {
@@ -12980,13 +13224,13 @@ function replaceSkill(sourceDirectory, targetRoot, destinationDirectory, backupD
   }
 }
 function skillSummary(request, action, files, backupDirectory) {
-  const sourceDirectory = resolve4(request.sourceDirectory);
-  const targetRoot = resolve4(request.targetRoot);
+  const sourceDirectory = resolve5(request.sourceDirectory);
+  const targetRoot = resolve5(request.targetRoot);
   return {
     name: SKILL_NAME,
     sourceDirectory,
     targetRoot,
-    destinationDirectory: join4(targetRoot, SKILL_NAME),
+    destinationDirectory: join5(targetRoot, SKILL_NAME),
     action,
     mode: request.mode,
     changed: action !== "none",
@@ -12995,14 +13239,14 @@ function skillSummary(request, action, files, backupDirectory) {
   };
 }
 function installSkill(request) {
-  const sourceDirectory = resolve4(request.sourceDirectory);
-  const targetRoot = resolve4(request.targetRoot);
-  const destinationDirectory = join4(targetRoot, SKILL_NAME);
-  if (!existsSync6(join4(sourceDirectory, "SKILL.md"))) {
+  const sourceDirectory = resolve5(request.sourceDirectory);
+  const targetRoot = resolve5(request.targetRoot);
+  const destinationDirectory = join5(targetRoot, SKILL_NAME);
+  if (!existsSync7(join5(sourceDirectory, "SKILL.md"))) {
     throw new Error(`Bundled SupaCloud CLI skill not found: ${sourceDirectory}`);
   }
   const files = regularFiles(sourceDirectory);
-  if (!existsSync6(destinationDirectory))
+  if (!existsSync7(destinationDirectory))
     return installNewSkill(request, files);
   if (directoriesMatch(sourceDirectory, destinationDirectory)) {
     return skillSummary(request, "none", files, null);
@@ -13013,17 +13257,17 @@ function installSkill(request) {
   return installReplacementSkill(request, files);
 }
 function installNewSkill(request, files) {
-  const sourceDirectory = resolve4(request.sourceDirectory);
-  const targetRoot = resolve4(request.targetRoot);
+  const sourceDirectory = resolve5(request.sourceDirectory);
+  const targetRoot = resolve5(request.targetRoot);
   if (request.mode === "write") {
-    createSkill(sourceDirectory, targetRoot, join4(targetRoot, SKILL_NAME));
+    createSkill(sourceDirectory, targetRoot, join5(targetRoot, SKILL_NAME));
   }
   return skillSummary(request, "create", files, null);
 }
 function installReplacementSkill(request, files) {
-  const sourceDirectory = resolve4(request.sourceDirectory);
-  const targetRoot = resolve4(request.targetRoot);
-  const destinationDirectory = join4(targetRoot, SKILL_NAME);
+  const sourceDirectory = resolve5(request.sourceDirectory);
+  const targetRoot = resolve5(request.targetRoot);
+  const destinationDirectory = join5(targetRoot, SKILL_NAME);
   const backupDirectory = availableBackupDirectory(destinationDirectory, request.now);
   if (request.mode === "write") {
     replaceSkill(sourceDirectory, targetRoot, destinationDirectory, backupDirectory);
@@ -13032,15 +13276,15 @@ function installReplacementSkill(request, files) {
 }
 function resolveDefaultCodexSkillRoot(environment = process.env, homeDirectory = homedir2()) {
   const codexHome = environment.CODEX_HOME?.trim();
-  return join4(resolve4(codexHome || join4(homeDirectory, ".codex")), "skills");
+  return join5(resolve5(codexHome || join5(homeDirectory, ".codex")), "skills");
 }
 function resolveBundledSkillDirectory(moduleUrl = import.meta.url) {
   const moduleDirectory = dirname2(fileURLToPath(moduleUrl));
   const candidates = [
-    resolve4(moduleDirectory, "../../../skills", SKILL_NAME),
-    resolve4(moduleDirectory, "../skills", SKILL_NAME)
+    resolve5(moduleDirectory, "../../../skills", SKILL_NAME),
+    resolve5(moduleDirectory, "../skills", SKILL_NAME)
   ];
-  const skillDirectory = candidates.find((candidate) => existsSync6(join4(candidate, "SKILL.md")));
+  const skillDirectory = candidates.find((candidate) => existsSync7(join5(candidate, "SKILL.md")));
   if (!skillDirectory)
     throw new Error("Bundled SupaCloud CLI skill is missing from this installation");
   return skillDirectory;
@@ -13062,7 +13306,7 @@ function registerAiTools(server) {
         name: SKILL_NAME,
         sourceDirectory,
         defaultTargetRoot,
-        defaultDestination: join4(defaultTargetRoot, SKILL_NAME)
+        defaultDestination: join5(defaultTargetRoot, SKILL_NAME)
       });
     }
     return textResponse(installSkill({
@@ -13077,8 +13321,8 @@ function registerAiTools(server) {
 
 // src/shared/tools/scheduled-function-tools.ts
 import { randomUUID } from "node:crypto";
-import { readFileSync as readFileSync6, statSync as statSync4 } from "node:fs";
-import { resolve as resolve5 } from "node:path";
+import { readFileSync as readFileSync6, statSync as statSync5 } from "node:fs";
+import { resolve as resolve6 } from "node:path";
 import { isDeepStrictEqual } from "node:util";
 var HEADER_NAME_PATTERN = /^[!#$%&'*+.^_`|~0-9A-Za-z-]{1,128}$/;
 var ENVIRONMENT_NAME_PATTERN2 = /^[A-Za-z_][A-Za-z0-9_]{0,255}$/;
@@ -13162,8 +13406,8 @@ function validScheduledFunctionCron(expression) {
 function readScheduleBodyFile(bodyPathInput) {
   if (!bodyPathInput.trim())
     throw new Error("'body_file' must be a path");
-  const bodyPath = resolve5(bodyPathInput);
-  const bodyStat = statSync4(bodyPath);
+  const bodyPath = resolve6(bodyPathInput);
+  const bodyStat = statSync5(bodyPath);
   if (!bodyStat.isFile() || bodyStat.size > MAX_BODY_FILE_BYTES) {
     throw new Error("Scheduled Function body file must be a regular file no larger than 1 MiB");
   }
@@ -14121,7 +14365,7 @@ function registerReleaseTools(server, http, options = {}) {
 // package.json
 var package_default = {
   name: "@supacloud/cli",
-  version: "0.32.0",
+  version: "0.33.0",
   description: "Project-scoped CLI for SupaCloud users",
   type: "module",
   main: "./dist/index.js",
@@ -14386,6 +14630,9 @@ EXAMPLES
   ${preferredCommand} supabase db_diff --schema public --name add_accounts
   ${preferredCommand} supabase push --ref abc123 --dir supabase/migrations --dry_run
   ${preferredCommand} supabase db_dump --db_url "postgresql://..." --file backups/schema.sql
+  ${preferredCommand} lite migrate --project_dir .
+  ${preferredCommand} lite start --project_dir . --port 54321
+  ${preferredCommand} lite doctor --project_dir . --json
   ${preferredCommand} branch create --name feature-auth --data_mode schema_only
   ${preferredCommand} branch promotion_plan --branch_ref preview123
   ${preferredCommand} branch promote --branch_ref preview123 --plan_checksum <sha256>
@@ -14438,6 +14685,7 @@ function createCliTools(context, confirmProduction) {
     projectRef: context.projectRef || undefined,
     readOnly: context.readOnly
   })));
+  Object.assign(tools, captureTools((server) => registerLiteCliTools(server)));
   Object.assign(tools, captureTools((server) => registerAiTools(server)));
   const registerContextAwareHelp = () => {
     tools.project = {
@@ -14599,7 +14847,7 @@ async function main() {
     return;
   }
   const cliTools = createCliTools(context, globalOptions.confirmProduction);
-  if (args.length === 1 && !["ai", "supabase"].includes(args[0]) && cliTools[args[0]]) {
+  if (args.length === 1 && !["ai", "supabase", "lite"].includes(args[0]) && cliTools[args[0]]) {
     const result = await cliTools[args[0]].callback({});
     if (result?.content && Array.isArray(result.content)) {
       for (const chunk of result.content) {

package/package.json

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