@supacloud/cli 0.41.0 → 0.42.0

package/dist/index.js

@@ -238838,7 +238838,8 @@ var ACTION_POLICY = {
   },
   ai: { local: ["show_skill", "install_skill"] },
   app: { local: ["generate", "compile", "check", "graph", "explain"] },
-  db: { local: ["lint", "explain"], read: ["module_check"] }
+  db: { local: ["lint", "explain"], read: ["module_check"] },
+  dev: { read: ["status"], write: ["sync", "watch", "migrate"] }
 };
 function declaredMode(moduleName, action) {
   const policy = ACTION_POLICY[moduleName];
@@ -238857,6 +238858,8 @@ function executionMode(moduleName, action, args) {
     return "read";
   if (moduleName === "supabase" && action === "push" && args.dry_run === true)
     return "read";
+  if (moduleName === "dev" && action === "migrate" && args.apply !== true)
+    return "read";
   return declaredMode(moduleName, action);
 }
 function authorizeExecution(moduleName, args, authorization) {
@@ -250808,10 +250811,282 @@ function registerDeployTools(server2, http, options = {}) {
     }
   });
 }
+
+// src/shared/tools/remote-dev-tools.ts
+import { spawn as spawn4 } from "node:child_process";
+import { existsSync as existsSync11 } from "node:fs";
+import { readFile as readFile3 } from "node:fs/promises";
+import { readdir } from "node:fs/promises";
+import { createHash as createHash5 } from "node:crypto";
+import { join as join10, resolve as resolve11 } from "node:path";
+var SAFE_TOKEN = /^[A-Za-z0-9._:@/+,-]+$/;
+var SAFE_REMOTE_ROOT = /^\/(?:[A-Za-z0-9._-]+\/)*[A-Za-z0-9._-]+\/?$/;
+var remoteDevToolSchema = {
+  action: withDescription(stringEnum(["sync", "watch", "status", "migrate"]), "Remote development action"),
+  target: optional(stringEnum(["db", "functions", "frontend", "project"]), "Sync target (default: project)"),
+  project_dir: optional(Type.String(), "Local project directory (default: current directory)"),
+  remote_root: optional(Type.String(), "Remote development root"),
+  remote_host: optional(Type.String(), "Remote test server host"),
+  remote_user: optional(Type.String(), "SSH user"),
+  remote_port: optional(Type.Number(), "SSH port"),
+  remote_key: optional(Type.String(), "SSH private key path"),
+  function: optional(Type.String(), "Function slug"),
+  delete: optional(Type.Boolean(), "Delete remote files absent locally"),
+  reload: optional(Type.Boolean(), "Reload the affected target after sync (default: true)"),
+  interval_ms: optional(Type.Number(), "Watch debounce interval in milliseconds (default: 300)"),
+  json: optional(Type.Boolean(), "Emit machine-readable JSON"),
+  apply: optional(Type.Boolean(), "Apply generated migrations to the selected test database"),
+  drizzle_config: optional(Type.String(), "Drizzle config path"),
+  migrations_dir: optional(Type.String(), "Migration directory"),
+  drizzle_bin: optional(Type.String(), "drizzle-kit executable")
+};
+function runProcess(executable, args, cwd) {
+  return new Promise((resolveResult, reject) => {
+    const child = spawn4(executable, args, { cwd, shell: false, stdio: ["ignore", "pipe", "pipe"] });
+    let stdout = "";
+    let stderr = "";
+    child.stdout?.setEncoding("utf8");
+    child.stderr?.setEncoding("utf8");
+    child.stdout?.on("data", (chunk) => {
+      stdout += String(chunk);
+    });
+    child.stderr?.on("data", (chunk) => {
+      stderr += String(chunk);
+    });
+    child.once("error", reject);
+    child.once("close", (exitCode) => resolveResult({ exitCode: exitCode ?? 1, stdout, stderr }));
+  });
+}
+function resolveDrizzleCommand(root, configured) {
+  if (configured?.trim())
+    return configured.trim();
+  const local = join10(root, "node_modules", ".bin", "drizzle-kit");
+  return existsSync11(local) ? local : "drizzle-kit";
+}
+function toolFailed(value) {
+  return value?.isError === true || value?.content?.some((chunk) => typeof chunk?.text === "string" && chunk.text.trimStart().startsWith("❌"));
+}
+async function migrateDatabase(args, options) {
+  const root = resolve11(String(args.project_dir || options.cwd || process.cwd()));
+  const projectConfig = await readProjectConfig(root);
+  const config = projectConfig.dev || {};
+  const database = config.database || {};
+  const execute = options.execute || ((command, commandArgs, cwd) => runProcess(command, commandArgs, cwd));
+  const drizzleConfig = resolve11(root, String(args.drizzle_config || database.drizzleConfig || "drizzle.config.ts"));
+  const migrationsDir = String(args.migrations_dir || database.migrationsDir || "supabase/migrations");
+  if (!existsSync11(drizzleConfig))
+    throw new Error(`Drizzle config not found: ${drizzleConfig}`);
+  const generated = await execute(resolveDrizzleCommand(root, typeof args.drizzle_bin === "string" ? args.drizzle_bin : database.drizzleBin), ["generate", "--config", drizzleConfig], root);
+  if (generated.exitCode !== 0)
+    throw new Error(`Drizzle migration generation failed: ${generated.stderr.trim() || `exit ${generated.exitCode}`}`);
+  if (!options.runDatabase)
+    throw new Error("dev migrate requires Management API context");
+  const dryRun = await options.runDatabase({ action: "push_migrations", dir: migrationsDir, dry_run: true, strict: database.strict !== false });
+  if (toolFailed(dryRun))
+    throw new Error("SupaCloud migration dry-run failed");
+  if (args.apply !== true)
+    return { ok: true, mode: "dev", action: "migrate", generated: true, applied: false, migrations_dir: migrationsDir, dry_run: dryRun };
+  const applied = await options.runDatabase({ action: "push_migrations", dir: migrationsDir, strict: database.strict !== false });
+  if (toolFailed(applied))
+    throw new Error("SupaCloud migration apply failed");
+  return { ok: true, mode: "dev", action: "migrate", generated: true, applied: true, migrations_dir: migrationsDir, result: applied };
+}
+async function readProjectConfig(root) {
+  const file = join10(root, "supacloud.json");
+  if (!existsSync11(file))
+    return {};
+  try {
+    const parsed = JSON.parse(await readFile3(file, "utf8"));
+    return parsed && typeof parsed === "object" ? parsed : {};
+  } catch (error) {
+    throw new Error(`Invalid supacloud.json: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+async function readDevConfig(root) {
+  const config = await readProjectConfig(root);
+  return config.dev || {};
+}
+async function sourceFingerprint(root) {
+  const files = [];
+  const visit = async (directory) => {
+    const entries = await readdir(directory, { withFileTypes: true });
+    for (const entry of entries.sort((a, b) => a.name.localeCompare(b.name))) {
+      const path = join10(directory, entry.name);
+      if (entry.isDirectory() && ![".git", "node_modules", "dist", "generated", ".supacloud"].includes(entry.name))
+        await visit(path);
+      else if (entry.isFile())
+        files.push(path);
+    }
+  };
+  await visit(root);
+  const hash2 = createHash5("sha256");
+  for (const file of files) {
+    hash2.update(file.slice(root.length).replace(/\\/g, "/"));
+    hash2.update(await readFile3(file));
+  }
+  return hash2.digest("hex");
+}
+function safeToken(value, label) {
+  if (!value || !SAFE_TOKEN.test(value))
+    throw new Error(`Invalid ${label}`);
+  return value;
+}
+function remoteRoot(value) {
+  const normalized = value.trim().replace(/\\/g, "/");
+  if (!SAFE_REMOTE_ROOT.test(normalized) || normalized.includes(".."))
+    throw new Error("Invalid remote_root");
+  return normalized.replace(/\/$/, "");
+}
+function targetDirectory(root, target, functionSlug, config = {}) {
+  if (target === "db")
+    return join10(root, "supabase", "migrations");
+  if (target === "functions") {
+    const targets = config.targets && typeof config.targets === "object" ? config.targets : {};
+    const match = Object.values(targets).find((entry) => entry?.type === "edge_function" && (!functionSlug || String(entry.slug || "") === functionSlug));
+    const base = match?.root ? resolve11(root, String(match.root)) : join10(root, "supabase", "functions");
+    return match?.root ? base : functionSlug ? join10(base, safeToken(functionSlug, "function")) : base;
+  }
+  if (target === "frontend") {
+    const targets = config.targets && typeof config.targets === "object" ? config.targets : {};
+    const match = Object.values(targets).find((entry) => entry?.type === "frontend");
+    return match?.root ? resolve11(root, String(match.root)) : join10(root, "apps", "web");
+  }
+  return root;
+}
+function remoteTargetRoot(root, target, functionSlug) {
+  if (target === "db")
+    return `${root}/database/migrations`;
+  if (target === "functions")
+    return `${root}/functions/${functionSlug ? safeToken(functionSlug, "function") : ""}`.replace(/\/$/, "");
+  if (target === "frontend")
+    return `${root}/frontend`;
+  return `${root}/project`;
+}
+function connectionArgs(options, config, args) {
+  const host = String(args.remote_host || config.host || options.host || "").trim();
+  const user = String(args.remote_user || config.user || options.sshUser || "").trim();
+  const port = Number(args.remote_port || config.port || options.sshPort || 22);
+  const key = String(args.remote_key || config.key || options.sshKey || "").trim();
+  if (!host)
+    throw new Error("Remote dev requires SUPACLOUD_HOST or --remote_host");
+  safeToken(host, "remote_host");
+  safeToken(user, "remote_user");
+  if (!Number.isInteger(port) || port < 1 || port > 65535)
+    throw new Error("Invalid remote_port");
+  if (!key || key.includes("\x00") || key.includes(`
+`))
+    throw new Error("Invalid remote_key");
+  return { host, user, port, key };
+}
+function targetConfigPath(target) {
+  return target === "project" ? "project" : target;
+}
+function reloadCommand(config, target, projectRef2, functionSlug) {
+  const command = config.reloadCommand?.trim() || "supacloud-dev-agent reload";
+  if (!/^[A-Za-z0-9._/-]+(?: [A-Za-z0-9._:/=-]+)*$/.test(command))
+    throw new Error("Invalid reloadCommand in supacloud.json");
+  return [...command.split(" "), "--project-ref", safeToken(projectRef2 || "test", "project_ref"), "--target", targetConfigPath(target), ...functionSlug ? ["--function", safeToken(functionSlug, "function")] : []];
+}
+function sshArgs(connection, remoteCommand) {
+  return ["-p", String(connection.port), "-i", resolve11(connection.key), "-o", "BatchMode=yes", "-o", "StrictHostKeyChecking=yes", `${connection.user}@${connection.host}`, ...remoteCommand];
+}
+function rsyncArgs(connection, source, destination, excludes, deleteRemote) {
+  const args = ["-az", "--checksum", "--partial", "--protect-args", "-e", `ssh -p ${connection.port} -i ${resolve11(connection.key)} -o BatchMode=yes -o StrictHostKeyChecking=yes`];
+  if (deleteRemote)
+    args.push("--delete-delay");
+  for (const exclude of excludes) {
+    if (!/^\/?[A-Za-z0-9._*/-]+$/.test(exclude))
+      throw new Error("Invalid dev exclude pattern");
+    args.push("--exclude", exclude);
+  }
+  args.push(`${source.replace(/\/$/, "")}/`, `${connection.user}@${connection.host}:${destination.replace(/\/$/, "")}/`);
+  return args;
+}
+async function syncOnce(args, options) {
+  const root = resolve11(String(args.project_dir || options.cwd || process.cwd()));
+  const projectConfig = await readProjectConfig(root);
+  const config = projectConfig.dev || {};
+  const target = String(args.target || "project");
+  const source = targetDirectory(root, target, typeof args.function === "string" ? args.function : undefined, projectConfig);
+  if (!existsSync11(source))
+    throw new Error(`Dev source directory not found: ${source}`);
+  let compiled = false;
+  if (config.compile === true && target !== "db") {
+    const compileRoot = resolve11(root, config.compileRoot || ".");
+    const compileOutDir = resolve11(root, config.compileOutDir || "generated");
+    const compilation = await compileProject({
+      rootDir: compileRoot,
+      outDir: compileOutDir,
+      strict: config.compileStrict !== false
+    });
+    const errors = compilation.diagnostics.filter((diagnostic) => diagnostic.severity === "error");
+    if (errors.length > 0) {
+      throw new Error(`DI compile failed: ${errors.map((diagnostic) => `${diagnostic.code} ${diagnostic.message}`).join("; ")}`);
+    }
+    compiled = true;
+  }
+  const remoteBase = remoteRoot(String(args.remote_root || config.remoteRoot || `/var/lib/supacloud/dev/${options.projectRef || "project"}`));
+  const slug = typeof args.function === "string" ? args.function : undefined;
+  const destination = remoteTargetRoot(remoteBase, target, slug);
+  const connection = connectionArgs(options, config, args);
+  const execute = options.execute || ((command, commandArgs, cwd) => runProcess(command, commandArgs, cwd));
+  const mkdir3 = await execute("ssh", sshArgs(connection, ["mkdir", "-p", destination]), root);
+  if (mkdir3.exitCode !== 0)
+    throw new Error(`Remote dev prepare failed: ${mkdir3.stderr.trim() || `exit ${mkdir3.exitCode}`}`);
+  const excludes = Array.isArray(config.excludes) ? config.excludes : ["node_modules", ".git", ".env*", "dist", ".supacloud"];
+  const sync = await execute("rsync", rsyncArgs(connection, source, destination, excludes, args.delete === true), root);
+  if (sync.exitCode !== 0)
+    throw new Error(`Remote dev sync failed: ${sync.stderr.trim() || `exit ${sync.exitCode}`}`);
+  const shouldReload = args.reload !== false;
+  let reload = null;
+  if (shouldReload) {
+    reload = await execute("ssh", sshArgs(connection, reloadCommand(config, target, options.projectRef, slug)), root);
+    if (reload.exitCode !== 0)
+      throw new Error(`Remote dev reload failed: ${reload.stderr.trim() || `exit ${reload.exitCode}`}`);
+  }
+  return { ok: true, mode: "dev", action: "sync", environment: options.environment || null, target, source, destination, host: connection.host, compiled, reloaded: shouldReload };
+}
+function registerRemoteDevTools(server2, options = {}) {
+  server2.tool("dev", "Remote test-server development sync. It never targets production and never syncs secrets.", remoteDevToolSchema, async (args) => {
+    if (["production", "prod"].includes((options.environment || "").toLowerCase()))
+      throw new Error("Remote dev mode is forbidden for production environments");
+    if (args.action === "status") {
+      const root = resolve11(String(args.project_dir || options.cwd || process.cwd()));
+      const config = await readDevConfig(root);
+      const connection = connectionArgs(options, config, args);
+      const execute = options.execute || ((command, commandArgs, cwd) => runProcess(command, commandArgs, cwd));
+      const status = await execute("ssh", sshArgs(connection, ["supacloud-dev-agent", "status", "--project-ref", safeToken(options.projectRef || "test", "project_ref")]), root);
+      return { content: [{ type: "text", text: JSON.stringify({ ok: status.exitCode === 0, mode: "dev", action: "status", host: connection.host, output: status.stdout.trim(), error: status.stderr.trim() }, null, 2) }], isError: status.exitCode !== 0 };
+    }
+    if (args.action === "sync") {
+      return { content: [{ type: "text", text: JSON.stringify(await syncOnce(args, options), null, 2) }] };
+    }
+    if (args.action === "migrate") {
+      return { content: [{ type: "text", text: JSON.stringify(await migrateDatabase(args, options), null, 2) }] };
+    }
+    if (args.action === "watch") {
+      const root = resolve11(String(args.project_dir || options.cwd || process.cwd()));
+      const interval = Math.max(100, Math.min(1e4, Number(args.interval_ms || 300)));
+      let fingerprint = "";
+      let lastSync = null;
+      for (;; ) {
+        const nextFingerprint = await sourceFingerprint(root);
+        if (nextFingerprint !== fingerprint) {
+          lastSync = await syncOnce(args, options);
+          fingerprint = nextFingerprint;
+          process.stdout.write(`${JSON.stringify({ ...lastSync, watching: true })}
+`);
+        }
+        await new Promise((resolveDelay) => setTimeout(resolveDelay, interval));
+      }
+    }
+    throw new Error("Unsupported remote dev action");
+  });
+}
 // package.json
 var package_default = {
   name: "@supacloud/cli",
-  version: "0.41.0",
+  version: "0.42.0",
   description: "Project-scoped CLI for SupaCloud users",
   type: "module",
   main: "./dist/index.js",
@@ -251062,6 +251337,11 @@ EXAMPLES
   ${preferredCommand} deploy
   ${preferredCommand} deploy --target web
   ${preferredCommand} deploy --target api
+  ${preferredCommand} dev sync --env test --target functions --function api
+  ${preferredCommand} dev status --env test
+  ${preferredCommand} dev watch --env test --target project
+  ${preferredCommand} dev sync --env test --target db
+  ${preferredCommand} dev migrate --env test
   ${preferredCommand} project get
   ${preferredCommand} project logs --log_type database
   ${preferredCommand} project task_stats
@@ -251228,6 +251508,15 @@ function createCliTools(context, confirmProduction) {
     Object.assign(tools, captureTools((server2) => registerDatabaseTools(server2, undefined, {
       localOnly: true
     })));
+    Object.assign(tools, captureTools((server2) => registerRemoteDevTools(server2, {
+      cwd: process.cwd(),
+      host: process.env.SUPACLOUD_DEV_HOST || context.host,
+      sshUser: context.sshUser,
+      sshPort: context.sshPort,
+      sshKey: context.sshKey,
+      projectRef: context.projectRef || undefined,
+      environment: context.environment
+    })));
     tools.setup_help = {
       schema: {},
       callback: async () => ({
@@ -251280,6 +251569,16 @@ function createCliTools(context, confirmProduction) {
   }));
   pushMigrations = databaseTools.database?.callback;
   assign(databaseTools);
+  assign(captureTools((server2) => registerRemoteDevTools(server2, {
+    cwd: process.cwd(),
+    host: process.env.SUPACLOUD_DEV_HOST || context.host,
+    sshUser: context.sshUser,
+    sshPort: context.sshPort,
+    sshKey: context.sshKey,
+    projectRef: context.projectRef || undefined,
+    environment: context.environment,
+    runDatabase: databaseTools.database?.callback
+  })));
   assign(captureTools((server2) => registerAuthTools(server2, http)));
   assign(captureTools((server2) => registerOAuthClientTools(server2, http)));
   assign(captureTools((server2) => registerStorageTools(server2, http)));

package/package.json

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