@softr/cli 0.1.3 → 0.1.6-se21219.17

package/dist/cli.mjs

@@ -1745,7 +1745,7 @@ var require_table = __commonJS({
     var debug = require_debug();
     var utils = require_utils();
     var tableLayout = require_layout_manager();
-    var Table7 = class extends Array {
+    var Table9 = class extends Array {
       constructor(opts) {
         super();
         const options = utils.mergeOptions(opts);
@@ -1820,7 +1820,7 @@ var require_table = __commonJS({
         return str[0].length;
       }
     };
-    Table7.reset = () => debug.reset();
+    Table9.reset = () => debug.reset();
     function doDraw(row, lineNum, result) {
       let line = [];
       row.forEach(function(cell) {
@@ -1829,7 +1829,7 @@ var require_table = __commonJS({
       let str = line.join("");
       if (str.length) result.push(str);
     }
-    module.exports = Table7;
+    module.exports = Table9;
   }
 });
 
@@ -2598,14 +2598,14 @@ var Option = class {
    * @param {string} flags
    * @param {string} [description]
    */
-  constructor(flags, description) {
-    this.flags = flags;
+  constructor(flags2, description) {
+    this.flags = flags2;
     this.description = description || "";
-    this.required = flags.includes("<");
-    this.optional = flags.includes("[");
-    this.variadic = /\w\.\.\.[>\]]$/.test(flags);
+    this.required = flags2.includes("<");
+    this.optional = flags2.includes("[");
+    this.variadic = /\w\.\.\.[>\]]$/.test(flags2);
     this.mandatory = false;
-    const optionFlags = splitOptionFlags(flags);
+    const optionFlags = splitOptionFlags(flags2);
     this.short = optionFlags.shortFlag;
     this.long = optionFlags.longFlag;
     this.negate = false;
@@ -2661,8 +2661,8 @@ var Option = class {
    * @param {(string | string[])} names
    * @return {Option}
    */
-  conflicts(names) {
-    this.conflictsWith = this.conflictsWith.concat(names);
+  conflicts(names2) {
+    this.conflictsWith = this.conflictsWith.concat(names2);
     return this;
   }
   /**
@@ -2856,12 +2856,12 @@ function camelcase(str) {
     return str2 + word[0].toUpperCase() + word.slice(1);
   });
 }
-function splitOptionFlags(flags) {
+function splitOptionFlags(flags2) {
   let shortFlag;
   let longFlag;
   const shortFlagExp = /^-[^-]$/;
   const longFlagExp = /^--[^-]/;
-  const flagParts = flags.split(/[ |,]+/).concat("guard");
+  const flagParts = flags2.split(/[ |,]+/).concat("guard");
   if (shortFlagExp.test(flagParts[0])) shortFlag = flagParts.shift();
   if (longFlagExp.test(flagParts[0])) longFlag = flagParts.shift();
   if (!shortFlag && shortFlagExp.test(flagParts[0]))
@@ -2872,7 +2872,7 @@ function splitOptionFlags(flags) {
   }
   if (flagParts[0].startsWith("-")) {
     const unsupportedFlag = flagParts[0];
-    const baseError = `option creation failed due to '${unsupportedFlag}' in option flags '${flags}'`;
+    const baseError = `option creation failed due to '${unsupportedFlag}' in option flags '${flags2}'`;
     if (/^-[^-][^-]/.test(unsupportedFlag))
       throw new Error(
         `${baseError}
@@ -2891,7 +2891,7 @@ function splitOptionFlags(flags) {
   }
   if (shortFlag === void 0 && longFlag === void 0)
     throw new Error(
-      `option creation failed due to no flags found in '${flags}'.`
+      `option creation failed due to no flags found in '${flags2}'.`
     );
   return { shortFlag, longFlag };
 }
@@ -3268,8 +3268,8 @@ var Command = class _Command extends EventEmitter {
    * @param {string} names
    * @return {Command} `this` command for chaining
    */
-  arguments(names) {
-    names.trim().split(/ +/).forEach((detail) => {
+  arguments(names2) {
+    names2.trim().split(/ +/).forEach((detail) => {
       this.argument(detail);
     });
     return this;
@@ -3454,8 +3454,8 @@ Expecting one of '${allowedValues.join("', '")}'`);
    * @param {string} [description]
    * @return {Option} new option
    */
-  createOption(flags, description) {
-    return new Option(flags, description);
+  createOption(flags2, description) {
+    return new Option(flags2, description);
   }
   /**
    * Wrap parseArgs to catch 'commander.invalidArgument'.
@@ -3570,13 +3570,13 @@ Expecting one of '${allowedValues.join("', '")}'`);
    * @return {Command} `this` command for chaining
    * @private
    */
-  _optionEx(config, flags, description, fn, defaultValue) {
-    if (typeof flags === "object" && flags instanceof Option) {
+  _optionEx(config, flags2, description, fn, defaultValue) {
+    if (typeof flags2 === "object" && flags2 instanceof Option) {
       throw new Error(
         "To add an Option object use addOption() instead of option() or requiredOption()"
       );
     }
-    const option = this.createOption(flags, description);
+    const option = this.createOption(flags2, description);
     option.makeOptionMandatory(!!config.mandatory);
     if (typeof fn === "function") {
       option.default(defaultValue).argParser(fn);
@@ -3613,8 +3613,8 @@ Expecting one of '${allowedValues.join("', '")}'`);
    * @param {*} [defaultValue]
    * @return {Command} `this` command for chaining
    */
-  option(flags, description, parseArg, defaultValue) {
-    return this._optionEx({}, flags, description, parseArg, defaultValue);
+  option(flags2, description, parseArg, defaultValue) {
+    return this._optionEx({}, flags2, description, parseArg, defaultValue);
   }
   /**
    * Add a required option which must have a value after parsing. This usually means
@@ -3628,10 +3628,10 @@ Expecting one of '${allowedValues.join("', '")}'`);
    * @param {*} [defaultValue]
    * @return {Command} `this` command for chaining
    */
-  requiredOption(flags, description, parseArg, defaultValue) {
+  requiredOption(flags2, description, parseArg, defaultValue) {
     return this._optionEx(
       { mandatory: true },
-      flags,
+      flags2,
       description,
       parseArg,
       defaultValue
@@ -3798,18 +3798,18 @@ Expecting one of '${allowedValues.join("', '")}'`);
    *
    * @private
    */
-  _prepareUserArgs(argv, parseOptions) {
+  _prepareUserArgs(argv, parseOptions2) {
     if (argv !== void 0 && !Array.isArray(argv)) {
       throw new Error("first parameter to parse must be array or undefined");
     }
-    parseOptions = parseOptions || {};
-    if (argv === void 0 && parseOptions.from === void 0) {
+    parseOptions2 = parseOptions2 || {};
+    if (argv === void 0 && parseOptions2.from === void 0) {
       if (process2.versions?.electron) {
-        parseOptions.from = "electron";
+        parseOptions2.from = "electron";
       }
       const execArgv = process2.execArgv ?? [];
       if (execArgv.includes("-e") || execArgv.includes("--eval") || execArgv.includes("-p") || execArgv.includes("--print")) {
-        parseOptions.from = "eval";
+        parseOptions2.from = "eval";
       }
     }
     if (argv === void 0) {
@@ -3817,7 +3817,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
     }
     this.rawArgs = argv.slice();
     let userArgs;
-    switch (parseOptions.from) {
+    switch (parseOptions2.from) {
       case void 0:
       case "node":
         this._scriptPath = argv[1];
@@ -3839,7 +3839,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
         break;
       default:
         throw new Error(
-          `unexpected parse option { from: '${parseOptions.from}' }`
+          `unexpected parse option { from: '${parseOptions2.from}' }`
         );
     }
     if (!this._name && this._scriptPath)
@@ -3869,9 +3869,9 @@ Expecting one of '${allowedValues.join("', '")}'`);
    * @param {string} [parseOptions.from] - where the args are from: 'node', 'user', 'electron'
    * @return {Command} `this` command for chaining
    */
-  parse(argv, parseOptions) {
+  parse(argv, parseOptions2) {
     this._prepareForParse();
-    const userArgs = this._prepareUserArgs(argv, parseOptions);
+    const userArgs = this._prepareUserArgs(argv, parseOptions2);
     this._parseCommand([], userArgs);
     return this;
   }
@@ -3895,9 +3895,9 @@ Expecting one of '${allowedValues.join("', '")}'`);
    * @param {string} parseOptions.from - where the args are from: 'node', 'user', 'electron'
    * @return {Promise}
    */
-  async parseAsync(argv, parseOptions) {
+  async parseAsync(argv, parseOptions2) {
     this._prepareForParse();
-    const userArgs = this._prepareUserArgs(argv, parseOptions);
+    const userArgs = this._prepareUserArgs(argv, parseOptions2);
     await this._parseCommand([], userArgs);
     return this;
   }
@@ -4748,12 +4748,12 @@ Expecting one of '${allowedValues.join("', '")}'`);
    * @param {string} [description]
    * @return {(this | string | undefined)} `this` command for chaining, or version string if no arguments
    */
-  version(str, flags, description) {
+  version(str, flags2, description) {
     if (str === void 0) return this._version;
     this._version = str;
-    flags = flags || "-V, --version";
+    flags2 = flags2 || "-V, --version";
     description = description || "output the version number";
-    const versionOption = this.createOption(flags, description);
+    const versionOption = this.createOption(flags2, description);
     this._versionOptionName = versionOption.attributeName();
     this._registerOption(versionOption);
     this.on("option:" + versionOption.name(), () => {
@@ -4951,9 +4951,9 @@ Expecting one of '${allowedValues.join("', '")}'`);
    * @param {string} [path]
    * @return {(string|null|Command)}
    */
-  executableDir(path13) {
-    if (path13 === void 0) return this._executableDir;
-    this._executableDir = path13;
+  executableDir(path16) {
+    if (path16 === void 0) return this._executableDir;
+    this._executableDir = path16;
     return this;
   }
   /**
@@ -5055,9 +5055,9 @@ Expecting one of '${allowedValues.join("', '")}'`);
    * @param {string} [description]
    * @return {Command} `this` command for chaining
    */
-  helpOption(flags, description) {
-    if (typeof flags === "boolean") {
-      if (flags) {
+  helpOption(flags2, description) {
+    if (typeof flags2 === "boolean") {
+      if (flags2) {
         if (this._helpOption === null) this._helpOption = void 0;
         if (this._defaultOptionGroup) {
           this._initOptionGroup(this._getHelpOption());
@@ -5068,10 +5068,10 @@ Expecting one of '${allowedValues.join("', '")}'`);
       return this;
     }
     this._helpOption = this.createOption(
-      flags ?? "-h, --help",
+      flags2 ?? "-h, --help",
       description ?? "display help for command"
     );
-    if (flags || description) this._initOptionGroup(this._helpOption);
+    if (flags2 || description) this._initOptionGroup(this._helpOption);
     return this;
   }
   /**
@@ -5209,7 +5209,7 @@ function useColor() {
 var program = new Command();
 
 // src/commands/add.ts
-import path9 from "node:path";
+import path6 from "node:path";
 
 // src/errors.ts
 var CliError = class extends Error {
@@ -5310,12 +5310,12 @@ function executionOrder(config) {
   collect(config.actions, []);
   const outgoing = new Map(appearance.map((id) => [id, []]));
   const indegree = new Map(appearance.map((id) => [id, 0]));
-  for (const path13 of pathSets.flat()) {
-    const to = path13.toActionId;
-    if (!to || !nodes.has(path13.fromActionId) || !nodes.has(to) || outgoing.get(path13.fromActionId).includes(to)) {
+  for (const path16 of pathSets.flat()) {
+    const to = path16.toActionId;
+    if (!to || !nodes.has(path16.fromActionId) || !nodes.has(to) || outgoing.get(path16.fromActionId).includes(to)) {
       continue;
     }
-    outgoing.get(path13.fromActionId).push(to);
+    outgoing.get(path16.fromActionId).push(to);
     indegree.set(to, indegree.get(to) + 1);
   }
   const queue = [...nodes.values()].filter((node) => node.kind === "trigger").map((node) => node.id);
@@ -6098,7 +6098,10 @@ var SoftrApiError = class extends Error {
   body;
   hint;
 };
-function hintFor(status, client) {
+function hintFor(status, client, service) {
+  if (service === "tables") {
+    return tablesHintFor(status, client);
+  }
   if (status === 401 || status === 403) {
     return client.kind === "proxy" ? "The target refused the request: no access to this workflow, or its credential is gone." : "The token was not accepted: revoked, from another environment, missing access to this workflow, or its statements do not grant this action. Run: softr login";
   }
@@ -6107,40 +6110,65 @@ function hintFor(status, client) {
   }
   return void 0;
 }
-function authHeaders(client) {
-  return client.kind === "proxy" ? {} : { Authorization: `Bearer ${client.token}` };
+function tablesHintFor(status, client) {
+  if (status === 401 || status === 403) {
+    return client.kind === "proxy" ? "The target refused the request: no access to this database, or its credential is gone." : "The token was not accepted: revoked, from another environment, or its statements do not grant this databases action (databases.records:read, databases.records:write, databases.schema:write). Run: softr login";
+  }
+  if (status === 429) {
+    return "Too many requests for this token. Wait a moment and try again.";
+  }
+  return void 0;
+}
+function authHeaders(client, service) {
+  if (client.kind === "proxy") {
+    return {};
+  }
+  return service === "tables" ? { "Softr-Api-Key": client.token } : { Authorization: `Bearer ${client.token}` };
 }
-async function send(client, service, method, path13, body) {
+var BASE_URLS = {
+  workflows: (target) => target.apiUrl,
+  studio: (target) => target.studioApiUrl,
+  tables: (target) => target.tablesApiUrl
+};
+async function send(client, service, method, path16, body) {
   const init = {
     method,
-    headers: { ...authHeaders(client), Accept: "application/json" }
+    headers: { ...authHeaders(client, service), Accept: "application/json" }
   };
-  if (body !== void 0) {
+  if (body instanceof FormData) {
+    init.body = body;
+  } else if (body !== void 0) {
     init.headers = { ...init.headers, "Content-Type": "application/json" };
     init.body = JSON.stringify(body);
   }
-  const baseUrl = service === "workflows" ? client.target.apiUrl : client.target.studioApiUrl;
-  const response = await fetch(`${baseUrl}${path13}`, init);
+  const response = await fetch(`${BASE_URLS[service](client.target)}${path16}`, init);
   if (response.ok) {
     return response;
   }
   const text = await response.text();
   throw new SoftrApiError(
-    `${method} ${path13} failed with status ${response.status}${text ? `: ${text}` : ""}`,
+    `${method} ${path16} failed with status ${response.status}${text ? `: ${text}` : ""}`,
     response.status,
     text,
-    hintFor(response.status, client)
+    hintFor(response.status, client, service)
   );
 }
-async function apiRequest(client, method, path13, body) {
-  const response = await send(client, "workflows", method, path13, body);
+async function apiRequest(client, method, path16, body) {
+  const response = await send(client, "workflows", method, path16, body);
+  return await response.json();
+}
+async function apiRequestVoid(client, method, path16, body) {
+  await send(client, "workflows", method, path16, body);
+}
+async function tablesRequest(client, method, path16, body) {
+  const response = await send(client, "tables", method, path16, body);
   return await response.json();
 }
-async function apiRequestVoid(client, method, path13, body) {
-  await send(client, "workflows", method, path13, body);
+async function tablesRequestVoid(client, method, path16, body) {
+  await send(client, "tables", method, path16, body);
 }
-async function studioRequest(client, method, path13, body) {
-  const response = await send(client, "studio", method, path13, body);
+async function studioRequest(client, method, path16, body) {
+  const response = await send(client, "studio", method, path16, body);
   return await response.json();
 }
 
@@ -6151,6 +6179,9 @@ function globalOptions(command) {
 function emit(options, human, data2) {
   process.stdout.write(options.json ? JSON.stringify(data2, null, 2) + "\n" : human + "\n");
 }
+function plainTable(head, colWidths) {
+  return { head, colWidths, wordWrap: true, style: { head: [], border: [], "padding-left": 1, "padding-right": 1 } };
+}
 function reportError(error) {
   if (error instanceof CliError || error instanceof SoftrApiError) {
     process.stderr.write(`Error: ${error.message}
@@ -6963,12 +6994,12 @@ function parseTree(text, errors = [], options = ParseOptions.DEFAULT) {
   }
   return result;
 }
-function findNodeAtLocation(root, path13) {
+function findNodeAtLocation(root, path16) {
   if (!root) {
     return void 0;
   }
   let node = root;
-  for (let segment of path13) {
+  for (let segment of path16) {
     if (typeof segment === "string") {
       if (node.type !== "object" || !Array.isArray(node.children)) {
         return void 0;
@@ -7322,14 +7353,14 @@ function getNodeType(value) {
 
 // node_modules/jsonc-parser/lib/esm/impl/edit.js
 function setProperty(text, originalPath, value, options) {
-  const path13 = originalPath.slice();
+  const path16 = originalPath.slice();
   const errors = [];
   const root = parseTree(text, errors);
   let parent = void 0;
   let lastSegment = void 0;
-  while (path13.length > 0) {
-    lastSegment = path13.pop();
-    parent = findNodeAtLocation(root, path13);
+  while (path16.length > 0) {
+    lastSegment = path16.pop();
+    parent = findNodeAtLocation(root, path16);
     if (parent === void 0 && value !== void 0) {
       if (typeof lastSegment === "string") {
         value = { [lastSegment]: value };
@@ -7552,8 +7583,8 @@ function printParseErrorCode(code) {
   }
   return "<unknown ParseErrorCode>";
 }
-function modify(text, path13, value, options) {
-  return setProperty(text, path13, value, options);
+function modify(text, path16, value, options) {
+  return setProperty(text, path16, value, options);
 }
 function applyEdits(text, edits) {
   let sortedEdits = edits.slice(0).sort((a, b) => {
@@ -7583,14 +7614,36 @@ var CONFIG_FILE_NAME = "softr-workflows.jsonc";
 function configPath(dir) {
   return path2.join(dir, CONFIG_FILE_NAME);
 }
-async function configExists(dir) {
+async function fileExists(file) {
   try {
-    await access(configPath(dir));
+    await access(file);
     return true;
   } catch {
     return false;
   }
 }
+async function configExists(dir) {
+  return fileExists(configPath(dir));
+}
+function parseJsoncFile(file, text) {
+  const errors = [];
+  const value = parse2(text, errors, { allowTrailingComma: true });
+  if (errors.length) {
+    const first = errors[0];
+    const line = text.slice(0, first.offset).split("\n").length;
+    throw new CliError(`${file}:${line}: ${printParseErrorCode(first.error)}`);
+  }
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    throw new CliError(`${file}: the top level must be a JSON object.`);
+  }
+  return value;
+}
+async function listSubdirsWith(cwd, holds) {
+  const entries = await readdir(cwd, { withFileTypes: true });
+  const dirs = entries.filter((entry) => entry.isDirectory()).map((entry) => path2.join(cwd, entry.name));
+  const flags2 = await Promise.all(dirs.map((dir) => holds(dir)));
+  return dirs.filter((_, index) => flags2[index]);
+}
 async function readConfig(dir) {
   const file = configPath(dir);
   let text;
@@ -7605,17 +7658,7 @@ async function readConfig(dir) {
     }
     throw error;
   }
-  const errors = [];
-  const value = parse2(text, errors, { allowTrailingComma: true });
-  if (errors.length) {
-    const first = errors[0];
-    const line = text.slice(0, first.offset).split("\n").length;
-    throw new CliError(`${file}:${line}: ${printParseErrorCode(first.error)}`);
-  }
-  if (value === null || typeof value !== "object" || Array.isArray(value)) {
-    throw new CliError(`${file}: the top level must be a JSON object.`);
-  }
-  return value;
+  return parseJsoncFile(file, text);
 }
 async function writeConfig(dir, config) {
   const file = configPath(dir);
@@ -7635,10 +7678,7 @@ async function findWorkflowDir(cwd, explicitDir) {
   throw new CliError(`No ${CONFIG_FILE_NAME} in ${cwd}.`, hint);
 }
 async function listWorkflowDirs(cwd) {
-  const entries = await readdir(cwd, { withFileTypes: true });
-  const dirs = entries.filter((entry) => entry.isDirectory()).map((entry) => path2.join(cwd, entry.name));
-  const flags = await Promise.all(dirs.map((dir) => configExists(dir)));
-  return dirs.filter((_, index) => flags[index]);
+  return listSubdirsWith(cwd, configExists);
 }
 
 // src/project/config-edit.ts
@@ -8249,12 +8289,12 @@ prototypeAccessors.inAsync.get = function() {
 prototypeAccessors.canAwait.get = function() {
   for (var i2 = this.scopeStack.length - 1; i2 >= 0; i2--) {
     var ref2 = this.scopeStack[i2];
-    var flags = ref2.flags;
-    if (flags & (SCOPE_CLASS_STATIC_BLOCK | SCOPE_CLASS_FIELD_INIT)) {
+    var flags2 = ref2.flags;
+    if (flags2 & (SCOPE_CLASS_STATIC_BLOCK | SCOPE_CLASS_FIELD_INIT)) {
       return false;
     }
-    if (flags & SCOPE_FUNCTION) {
-      return (flags & SCOPE_ASYNC) > 0;
+    if (flags2 & SCOPE_FUNCTION) {
+      return (flags2 & SCOPE_ASYNC) > 0;
     }
   }
   return this.inModule && this.options.ecmaVersion >= 13 || this.options.allowAwaitOutsideFunction;
@@ -8270,8 +8310,8 @@ prototypeAccessors.allowReturn.get = function() {
 };
 prototypeAccessors.allowSuper.get = function() {
   var ref2 = this.currentThisScope();
-  var flags = ref2.flags;
-  return (flags & SCOPE_SUPER) > 0 || this.options.allowSuperOutsideMethod;
+  var flags2 = ref2.flags;
+  return (flags2 & SCOPE_SUPER) > 0 || this.options.allowSuperOutsideMethod;
 };
 prototypeAccessors.allowDirectSuper.get = function() {
   return (this.currentThisScope().flags & SCOPE_DIRECT_SUPER) > 0;
@@ -8282,8 +8322,8 @@ prototypeAccessors.treatFunctionsAsVar.get = function() {
 prototypeAccessors.allowNewDotTarget.get = function() {
   for (var i2 = this.scopeStack.length - 1; i2 >= 0; i2--) {
     var ref2 = this.scopeStack[i2];
-    var flags = ref2.flags;
-    if (flags & (SCOPE_CLASS_STATIC_BLOCK | SCOPE_CLASS_FIELD_INIT) || flags & SCOPE_FUNCTION && !(flags & SCOPE_ARROW)) {
+    var flags2 = ref2.flags;
+    if (flags2 & (SCOPE_CLASS_STATIC_BLOCK | SCOPE_CLASS_FIELD_INIT) || flags2 & SCOPE_FUNCTION && !(flags2 & SCOPE_ARROW)) {
       return true;
     }
   }
@@ -8291,11 +8331,11 @@ prototypeAccessors.allowNewDotTarget.get = function() {
 };
 prototypeAccessors.allowUsing.get = function() {
   var ref2 = this.currentScope();
-  var flags = ref2.flags;
-  if (flags & SCOPE_SWITCH) {
+  var flags2 = ref2.flags;
+  if (flags2 & SCOPE_SWITCH) {
     return false;
   }
-  if (!this.inModule && flags & SCOPE_TOP) {
+  if (!this.inModule && flags2 & SCOPE_TOP) {
     return false;
   }
   return true;
@@ -11076,14 +11116,14 @@ pp$4.curPosition = function() {
   }
 };
 var pp$3 = Parser.prototype;
-var Scope = function Scope2(flags) {
-  this.flags = flags;
+var Scope = function Scope2(flags2) {
+  this.flags = flags2;
   this.var = [];
   this.lexical = [];
   this.functions = [];
 };
-pp$3.enterScope = function(flags) {
-  this.scopeStack.push(new Scope(flags));
+pp$3.enterScope = function(flags2) {
+  this.scopeStack.push(new Scope(flags2));
 };
 pp$3.exitScope = function() {
   this.scopeStack.pop();
@@ -11299,12 +11339,12 @@ var RegExpValidationState = function RegExpValidationState2(parser) {
   this.backReferenceNames = [];
   this.branchID = null;
 };
-RegExpValidationState.prototype.reset = function reset(start, pattern, flags) {
-  var unicodeSets = flags.indexOf("v") !== -1;
-  var unicode = flags.indexOf("u") !== -1;
+RegExpValidationState.prototype.reset = function reset(start, pattern, flags2) {
+  var unicodeSets = flags2.indexOf("v") !== -1;
+  var unicode = flags2.indexOf("u") !== -1;
   this.start = start | 0;
   this.source = pattern + "";
-  this.flags = flags;
+  this.flags = flags2;
   if (unicodeSets && this.parser.options.ecmaVersion >= 15) {
     this.switchU = true;
     this.switchV = true;
@@ -11381,15 +11421,15 @@ RegExpValidationState.prototype.eatChars = function eatChars(chs, forceU) {
 };
 pp$1.validateRegExpFlags = function(state) {
   var validFlags = state.validFlags;
-  var flags = state.flags;
+  var flags2 = state.flags;
   var u = false;
   var v = false;
-  for (var i2 = 0; i2 < flags.length; i2++) {
-    var flag = flags.charAt(i2);
+  for (var i2 = 0; i2 < flags2.length; i2++) {
+    var flag = flags2.charAt(i2);
     if (validFlags.indexOf(flag) === -1) {
       this.raise(state.start, "Invalid regular expression flag");
     }
-    if (flags.indexOf(flag, i2 + 1) > -1) {
+    if (flags2.indexOf(flag, i2 + 1) > -1) {
       this.raise(state.start, "Duplicate regular expression flag");
     }
     if (flag === "u") {
@@ -13001,20 +13041,20 @@ pp.readRegexp = function() {
   var pattern = this.input.slice(start, this.pos);
   ++this.pos;
   var flagsStart = this.pos;
-  var flags = this.readWord1();
+  var flags2 = this.readWord1();
   if (this.containsEsc) {
     this.unexpected(flagsStart);
   }
   var state = this.regexpState || (this.regexpState = new RegExpValidationState(this));
-  state.reset(start, pattern, flags);
+  state.reset(start, pattern, flags2);
   this.validateRegExpFlags(state);
   this.validateRegExpPattern(state);
   var value = null;
   try {
-    value = new RegExp(pattern, flags);
+    value = new RegExp(pattern, flags2);
   } catch (e) {
   }
-  return this.finishToken(types$1.regexp, { pattern, flags, value });
+  return this.finishToken(types$1.regexp, { pattern, flags: flags2, value });
 };
 pp.readInt = function(radix, len, maybeLegacyOctalNumericLiteral) {
   var allowSeparators = this.options.ecmaVersion >= 12 && len === void 0;
@@ -13555,8 +13595,8 @@ function typeOfField(field) {
   return field.allowMultipleEntries ? arrayOf(base) : base;
 }
 var SEGMENT = /^(?:\.?\[\s*'((?:[^'\\]|\\.)*)'\s*\]|\.?\[\s*"((?:[^"\\]|\\.)*)"\s*\]|\.?\[\s*(\d+)\s*\]|\.?\[\s*\*\s*\]|\.([^.[\]]+))/;
-function parsePath(path13) {
-  let rest = path13.trim();
+function parsePath(path16) {
+  let rest = path16.trim();
   if (rest.startsWith("$")) {
     rest = rest.slice(1);
   }
@@ -14056,10 +14096,10 @@ function describePlaceholder(placeholder, raw, config, outputs, depth) {
 function untested(nodeId) {
   return `node "${nodeId}" has no test output yet (run: softr workflows test ${nodeId})`;
 }
-function describeOutputRef(nodeId, path13, source, outputs) {
-  const segments = parsePath(path13);
+function describeOutputRef(nodeId, path16, source, outputs) {
+  const segments = parsePath(path16);
   if (!segments) {
-    return { type: UNKNOWN, source, verified: false, note: `unsupported path "${path13}"` };
+    return { type: UNKNOWN, source, verified: false, note: `unsupported path "${path16}"` };
   }
   const row = outputs[nodeId];
   if (!row) {
@@ -14384,65 +14424,264 @@ ${notes.join("\n")}` : ""}`,
   });
 }
 
-// src/commands/pull.ts
-import path8 from "node:path";
+// src/project/slug.ts
+function slug(title, fallback = "workflow") {
+  return title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || fallback;
+}
 
-// src/api/workflows.ts
-function getWorkflow(client, workflowId) {
-  return apiRequest(client, "GET", `/v1/workflows/${workflowId}`);
+// src/commands/add.ts
+function uniqueId(base, taken) {
+  if (!taken.has(base)) {
+    return base;
+  }
+  for (let n = 2; ; n++) {
+    if (!taken.has(`${base}-${n}`)) {
+      return `${base}-${n}`;
+    }
+  }
 }
-function updateWorkflow(client, workflowId, body) {
-  return apiRequest(client, "PUT", `/v1/workflows/${workflowId}`, body);
+function defaultAfter(config, loopId) {
+  const order = executionOrder(config);
+  const container = loopId ? order.filter((node) => node.loopId === loopId) : order.filter((node) => node.loopId === void 0 && node.reachable);
+  if (!container.length) {
+    if (loopId) {
+      return loopId;
+    }
+    const trigger = config.triggers?.[0];
+    if (!trigger) {
+      throw new CliError("The workflow has no trigger to attach the first action to.");
+    }
+    return trigger.id;
+  }
+  const paths = loopId ? [...allActions(config.actions)].find((node) => node.id === loopId)?.inputs?.paths ?? [] : config.paths ?? [];
+  const withOutgoing = new Set(paths.map((p) => p.fromActionId));
+  const leaves = container.filter((node) => !withOutgoing.has(node.id));
+  if (leaves.length === 1 && leaves[0]) {
+    return leaves[0].id;
+  }
+  throw new CliError(
+    leaves.length ? `Several nodes have no successor: ${leaves.map((node) => node.id).join(", ")}.` : "Every node already has a successor.",
+    "Pass --after <nodeId> to say where the new node goes."
+  );
 }
-function getWorkflowOutputs(client, workflowId) {
-  return apiRequest(client, "GET", `/v1/workflows/${workflowId}/outputs`);
+function registerAdd(program3) {
+  program3.command("add").description("Add an action after an existing node, or a trigger; custom code gets its own file under actions/").argument("<type>", 'node type from "spec", e.g. CUSTOM_CODE or WEBHOOK').option("--id <id>", "node id, readable and unique (default: derived from the type)").option("--title <title>", "node title shown in the studio (default: the type label)").option("--after <nodeId>", "actions: the node the new one follows (default: the only node without a successor)").option("--to <nodeId>", "triggers: an action the new trigger leads to").option("--in-loop <loopId>", "put the node inside this loop body").option("--lang <language>", "for CUSTOM_CODE: JAVASCRIPT or PYTHON (default JAVASCRIPT)").option("--dir <path>", "workflow directory (default: the current directory)").action(async (type, opts, command) => {
+    const options = globalOptions(command);
+    const dir = await findWorkflowDir(process.cwd(), opts.dir);
+    const config = await readConfig(dir);
+    const entry = findCatalogEntry(type);
+    const nodes = [...config.triggers ?? [], ...allActions(config.actions)];
+    const taken = new Set(nodes.map((node2) => node2.id));
+    const id = opts.id ?? uniqueId(entry.kind === "trigger" ? "trigger" : slug(entry.label), taken);
+    if (taken.has(id)) {
+      throw new CliError(`Node id "${id}" is already used.`);
+    }
+    if (id.includes(":::") || /[\s/?#]/.test(id)) {
+      throw new CliError(`Node id "${id}" must not contain ":::", spaces, "/", "?" or "#".`);
+    }
+    const title = opts.title ?? entry.label;
+    const { inputs, codeFile } = await newNodeInputs(entry, id, title, opts.lang, dir);
+    const node = { id, title, type: entry.type, version: entry.version, inputs };
+    if (entry.kind === "trigger") {
+      if (opts.after || opts.inLoop) {
+        throw new CliError(
+          "Triggers start the workflow: use --to <actionId> to connect one, not --after or --in-loop."
+        );
+      }
+      if (opts.to && !taken.has(opts.to)) {
+        throw new CliError(`No node "${opts.to}" to connect to.`, `Known nodes: ${[...taken].join(", ")}`);
+      }
+      await editConfig(dir, [
+        { path: ["triggers", -1], value: node },
+        ...opts.to ? [{ path: ["paths", -1], value: { fromActionId: id, toActionId: opts.to } }] : []
+      ]);
+      const notes = [
+        (config.triggers?.length ?? 0) >= 1 ? "The service accepts one trigger per published workflow for now; multi-trigger support is coming." : "",
+        opts.to ? "" : `Connect it with a path to the first action (or pass --to next time).`,
+        `Then: softr workflows push, softr workflows test ${id}.`
+      ].filter(Boolean);
+      emitWithVersionNote(
+        options,
+        config,
+        `Added ${entry.type} trigger "${id}"${opts.to ? ` leading to "${opts.to}"` : ""}.
+${notes.join("\n")}`,
+        {
+          id,
+          kind: "trigger",
+          type: entry.type,
+          to: opts.to ?? null
+        }
+      );
+      return;
+    }
+    if (opts.inLoop) {
+      const loop = [...allActions(config.actions)].find((candidate) => candidate.id === opts.inLoop);
+      if (!loop || loop.type !== LOOP_TYPE) {
+        throw new CliError(`"${opts.inLoop}" is not a loop in this workflow.`);
+      }
+    }
+    const after = opts.after ?? defaultAfter(config, opts.inLoop);
+    if (!taken.has(after)) {
+      throw new CliError(`No node "${after}" to attach to.`, `Known nodes: ${[...taken].join(", ")}`);
+    }
+    const loopIndex = opts.inLoop ? (config.actions ?? []).findIndex((action) => action.id === opts.inLoop) : -1;
+    const base = opts.inLoop && loopIndex >= 0 ? ["actions", loopIndex, "inputs"] : [];
+    await editConfig(dir, [
+      { path: [...base, "actions", -1], value: node },
+      { path: [...base, "paths", -1], value: { fromActionId: after, toActionId: id } }
+    ]);
+    const next = [
+      codeFile ? `Write the function in ${path6.relative(process.cwd(), codeFile)} and map its inputs under inputs.inputData in softr-workflows.jsonc.` : "",
+      entry.type === "BRANCH" || entry.type === "FILTER" ? `Add the condition(s) on the path(s) leaving it in softr-workflows.jsonc (see "spec ${entry.type}").` : "",
+      `Then: softr workflows push, softr workflows test ${id}.`
+    ].filter(Boolean);
+    emitWithVersionNote(
+      options,
+      config,
+      `Added ${entry.type} "${id}" after "${after}"${opts.inLoop ? ` inside loop "${opts.inLoop}"` : ""}.
+${next.join("\n")}`,
+      {
+        id,
+        kind: "action",
+        type: entry.type,
+        after,
+        loopId: opts.inLoop ?? null,
+        codeFile: codeFile ? path6.relative(process.cwd(), codeFile) : null
+      }
+    );
+  });
 }
-function listWorkflows(client, workspaceId, { applicationId } = {}) {
-  const query = new URLSearchParams({ workspaceId, ...applicationId ? { applicationId } : {}, limit: "500" });
-  return apiRequest(client, "GET", `/v1/workflows?${query}`);
+
+// src/commands/db/databases.ts
+var import_cli_table3 = __toESM(require_cli_table3(), 1);
+import path11 from "node:path";
+
+// src/api/tables.ts
+var DATABASES = "/api/v1/databases";
+async function listDatabases(client) {
+  return (await tablesRequest(client, "GET", DATABASES)).data;
 }
-function pinWorkflow(client, workflowId, applicationId) {
-  return apiRequestVoid(client, "POST", `/v1/workflows/${workflowId}/pinned-applications/${applicationId}`);
+async function getDatabase(client, databaseId) {
+  return (await tablesRequest(client, "GET", `${DATABASES}/${encodeURIComponent(databaseId)}`)).data;
 }
-function unpinWorkflow(client, workflowId, applicationId) {
-  return apiRequestVoid(client, "DELETE", `/v1/workflows/${workflowId}/pinned-applications/${applicationId}`);
+async function createDatabase(client, database) {
+  return (await tablesRequest(client, "POST", DATABASES, database)).data;
 }
-function testAction(client, workflowId, hierarchyPath2, mode) {
-  return apiRequest(client, "POST", `/v1/workflows/${workflowId}/outputs/${mode}/actions/${hierarchyPath2}`, {});
+async function updateDatabase(client, databaseId, changes) {
+  return (await tablesRequest(client, "PUT", `${DATABASES}/${encodeURIComponent(databaseId)}`, changes)).data;
 }
-function testTrigger(client, workflowId, triggerId) {
-  return apiRequest(client, "POST", `/v1/workflows/${workflowId}/outputs/triggers/${triggerId}/test`, {});
+async function deleteDatabase(client, databaseId, force) {
+  await tablesRequestVoid(
+    client,
+    "DELETE",
+    `${DATABASES}/${encodeURIComponent(databaseId)}${force ? "?force=true" : ""}`
+  );
 }
-function saveTriggerSample(client, workflowId, triggerId, sample) {
-  return apiRequestVoid(client, "POST", `/v1/workflows/${workflowId}/sample-output/triggers/${triggerId}`, sample);
+async function listTables(client, databaseId) {
+  return (await tablesRequest(client, "GET", `${DATABASES}/${encodeURIComponent(databaseId)}/tables`)).data;
 }
-function createWorkflow(client, body) {
-  return apiRequest(client, "POST", "/v1/workflows", body);
+function tablePath(databaseId, tableId) {
+  const tables = `${DATABASES}/${encodeURIComponent(databaseId)}/tables`;
+  return tableId ? `${tables}/${encodeURIComponent(tableId)}` : tables;
 }
-function enableWorkflow(client, workflowId) {
-  return apiRequestVoid(client, "PUT", `/v1/workflows/${workflowId}/enabled`);
+async function createTable(client, databaseId, table) {
+  return (await tablesRequest(client, "POST", tablePath(databaseId), table)).data;
 }
-function disableWorkflow(client, workflowId) {
-  return apiRequestVoid(client, "DELETE", `/v1/workflows/${workflowId}/enabled`);
+async function updateTable(client, databaseId, tableId, table) {
+  return (await tablesRequest(client, "PUT", tablePath(databaseId, tableId), table)).data;
 }
-async function getEnabledVersion(client, workflowId) {
-  try {
-    return await apiRequest(client, "GET", `/v1/workflows/${workflowId}/enabled`);
-  } catch (error) {
-    if (error instanceof SoftrApiError && error.status === 404) {
-      return null;
-    }
-    throw error;
-  }
+async function deleteTable(client, databaseId, tableId, force) {
+  await tablesRequestVoid(client, "DELETE", `${tablePath(databaseId, tableId)}${force ? "?force=true" : ""}`);
 }
-function getWorkflowReadiness(client, workflowId) {
-  return apiRequest(client, "GET", `/v1/workflows/${workflowId}/readiness`);
+async function addField(client, databaseId, tableId, field) {
+  return (await tablesRequest(client, "POST", `${tablePath(databaseId, tableId)}/fields`, field)).data;
+}
+async function updateField(client, databaseId, tableId, fieldId, field) {
+  return (await tablesRequest(
+    client,
+    "PUT",
+    `${tablePath(databaseId, tableId)}/fields/${encodeURIComponent(fieldId)}`,
+    field
+  )).data;
+}
+async function deleteField(client, databaseId, tableId, fieldId) {
+  await tablesRequestVoid(client, "DELETE", `${tablePath(databaseId, tableId)}/fields/${encodeURIComponent(fieldId)}`);
+}
+async function listViews(client, databaseId, tableId) {
+  return (await tablesRequest(client, "GET", `${tablePath(databaseId, tableId)}/views`)).data;
+}
+function recordsPath(databaseId, tableId, recordId) {
+  const records = `${tablePath(databaseId, tableId)}/records`;
+  return recordId ? `${records}/${encodeURIComponent(recordId)}` : records;
+}
+function names(fieldNames) {
+  return fieldNames ? "fieldNames=true" : "fieldNames=false";
+}
+async function listRecords(client, databaseId, tableId, query) {
+  const params = new URLSearchParams({ offset: String(query.offset), limit: String(query.limit) });
+  if (query.viewId) {
+    params.set("viewId", query.viewId);
+  }
+  const response = await tablesRequest(
+    client,
+    "GET",
+    `${recordsPath(databaseId, tableId)}?${params.toString()}&${names(query.fieldNames)}`
+  );
+  return { records: response.data, metadata: response.metadata };
+}
+async function searchRecords(client, databaseId, tableId, search, fieldNames) {
+  const response = await tablesRequest(
+    client,
+    "POST",
+    `${recordsPath(databaseId, tableId)}/search?${names(fieldNames)}`,
+    search
+  );
+  return { records: response.data, metadata: response.metadata };
+}
+async function getRecord(client, databaseId, tableId, recordId, fieldNames) {
+  return (await tablesRequest(
+    client,
+    "GET",
+    `${recordsPath(databaseId, tableId, recordId)}?${names(fieldNames)}`
+  )).data;
+}
+async function createRecord(client, databaseId, tableId, fields, fieldNames) {
+  return (await tablesRequest(
+    client,
+    "POST",
+    `${recordsPath(databaseId, tableId)}?${names(fieldNames)}`,
+    {
+      fields
+    }
+  )).data;
+}
+async function updateRecord(client, databaseId, tableId, recordId, fields, fieldNames) {
+  return (await tablesRequest(
+    client,
+    "PATCH",
+    `${recordsPath(databaseId, tableId, recordId)}?${names(fieldNames)}`,
+    { fields }
+  )).data;
+}
+async function deleteRecord(client, databaseId, tableId, recordId) {
+  await tablesRequestVoid(client, "DELETE", recordsPath(databaseId, tableId, recordId));
+}
+async function uploadAttachment(client, databaseId, tableId, recordId, fieldId, file) {
+  const form = new FormData();
+  form.set("file", new Blob([file.content]), file.name);
+  form.set("fileName", file.name);
+  return (await tablesRequest(
+    client,
+    "PUT",
+    `${recordsPath(databaseId, tableId, recordId)}/fields/${encodeURIComponent(fieldId)}/upload-attachment`,
+    form
+  )).data;
 }
 
 // src/config/credentials.ts
 import { chmod, mkdir as mkdir4, readFile as readFile5, writeFile as writeFile5 } from "node:fs/promises";
 import { homedir } from "node:os";
-import path6 from "node:path";
+import path7 from "node:path";
 
 // src/api/oauth.ts
 import { createHash as createHash2, randomBytes } from "node:crypto";
@@ -14475,8 +14714,8 @@ function refreshFailureHint(status) {
   return status === 401 ? "The OAuth grant is gone (revoked or older than 30 days). Run: softr login" : "The studio could not renew the login right now; try again in a moment.";
 }
 async function tokenRequest(target, form) {
-  const path13 = "/v1/oauth/token";
-  const response = await fetch(`${target.studioApiUrl}${path13}`, {
+  const path16 = "/v1/oauth/token";
+  const response = await fetch(`${target.studioApiUrl}${path16}`, {
     method: "POST",
     headers: { "Content-Type": "application/x-www-form-urlencoded", Accept: "application/json" },
     body: new URLSearchParams({ ...form, client_id: oauthClientId() }).toString()
@@ -14484,7 +14723,7 @@ async function tokenRequest(target, form) {
   if (!response.ok) {
     const text = await response.text();
     throw new SoftrApiError(
-      `POST ${path13} failed with status ${response.status}${text ? `: ${text}` : ""}`,
+      `POST ${path16} failed with status ${response.status}${text ? `: ${text}` : ""}`,
       response.status,
       text,
       form["grant_type"] === "refresh_token" ? refreshFailureHint(response.status) : void 0
@@ -14513,9 +14752,11 @@ function refreshTokens(target, refreshToken) {
 var API_URL_ENV_VAR = "SOFTR_WORKFLOWS_API_URL";
 var STUDIO_API_URL_ENV_VAR = "SOFTR_STUDIO_API_URL";
 var STUDIO_URL_ENV_VAR = "SOFTR_STUDIO_URL";
+var TABLES_API_URL_ENV_VAR = "SOFTR_TABLES_API_URL";
 var DEFAULT_API_URL = "https://workflows-api.softr.io";
 var DEFAULT_STUDIO_API_URL = "https://studio-api.softr.io";
 var DEFAULT_STUDIO_URL = "https://studio.softr.io";
+var DEFAULT_TABLES_API_URL = "https://tables-api.softr.io";
 function normalizeUrl(value, source) {
   let url;
   try {
@@ -14533,7 +14774,8 @@ function resolveTarget(remembered) {
   return {
     apiUrl: pick(API_URL_ENV_VAR, remembered?.apiUrl, DEFAULT_API_URL),
     studioApiUrl: pick(STUDIO_API_URL_ENV_VAR, remembered?.studioApiUrl, DEFAULT_STUDIO_API_URL),
-    studioUrl: pick(STUDIO_URL_ENV_VAR, remembered?.studioUrl, DEFAULT_STUDIO_URL)
+    studioUrl: pick(STUDIO_URL_ENV_VAR, remembered?.studioUrl, DEFAULT_STUDIO_URL),
+    tablesApiUrl: pick(TABLES_API_URL_ENV_VAR, remembered?.tablesApiUrl, DEFAULT_TABLES_API_URL)
   };
 }
 function targetHost(target) {
@@ -14563,7 +14805,7 @@ function isProxyAuth() {
 }
 var REFRESH_MARGIN_MS = 5 * 60 * 1e3;
 function credentialsPath() {
-  return path6.join(homedir(), ".softr", "credentials.json");
+  return path7.join(homedir(), ".softr", "credentials.json");
 }
 async function readCredentials() {
   try {
@@ -14577,7 +14819,7 @@ async function readCredentials() {
 }
 async function writeCredentials(credentials) {
   const file = credentialsPath();
-  await mkdir4(path6.dirname(file), { recursive: true, mode: 448 });
+  await mkdir4(path7.dirname(file), { recursive: true, mode: 448 });
   await writeFile5(file, JSON.stringify(credentials, null, 2) + "\n", { mode: 384 });
   await chmod(file, 384);
   return file;
@@ -14650,51 +14892,64 @@ async function authenticatedClient(target) {
   return { target, token: stored.token, kind };
 }
 
-// src/commands/list.ts
-var import_cli_table3 = __toESM(require_cli_table3(), 1);
+// src/project/db-dir.ts
+import { mkdir as mkdir5, readdir as readdir2, readFile as readFile6, rm, writeFile as writeFile6 } from "node:fs/promises";
+import path8 from "node:path";
 
-// src/api/studio.ts
-async function resolveTokenOwner(client) {
+// src/project/lookup.ts
+function byIdOrName(items, reference, kind, describe2 = (item) => item.id) {
+  const byId = items.find((item) => item.id === reference);
+  if (byId) {
+    return byId;
+  }
+  const byName = items.filter((item) => item.name === reference);
+  if (byName.length > 1) {
+    throw new CliError(
+      `Several ${kind}s are named "${reference}".`,
+      `Pass the id of one: ${byName.map(describe2).join(", ")}`
+    );
+  }
+  return byName[0];
+}
+
+// src/project/db-dir.ts
+var DB_CONFIG_FILE_NAME = "softr-db.jsonc";
+var DB_CACHE_DIR_NAME = ".softr-db";
+var DATABASE_ID_ENV_VAR = "SOFTR_DATABASE_ID";
+function configFile(dir) {
+  return path8.join(dir, DB_CONFIG_FILE_NAME);
+}
+function cacheFile(dir) {
+  return path8.join(dir, DB_CACHE_DIR_NAME, "schema.json");
+}
+async function dbConfigExists(dir) {
+  return fileExists(configFile(dir));
+}
+async function readDbConfig(dir) {
+  const file = configFile(dir);
+  let text;
   try {
-    return await studioRequest(client, "POST", "/v1/users/me/token", { token: client.token });
+    text = await readFile6(file, "utf8");
   } catch (error) {
-    if (error instanceof SoftrApiError && error.status === 404) {
-      throw new CliError(
-        "The studio does not know this token: revoked, expired, or from another environment.",
-        'Create a new personal API token in the studio, or run "softr login" for the browser login.'
-      );
+    if (error.code === "ENOENT") {
+      return void 0;
     }
     throw error;
   }
+  const value = parseJsoncFile(file, text);
+  if (typeof value["databaseId"] !== "string" || !value["databaseId"]) {
+    throw new CliError(`${file}: "databaseId" must be a non-empty string.`);
+  }
+  return { databaseId: value["databaseId"] };
 }
-function grantsWorkflows(statements) {
-  return (statements ?? []).some(
-    (statement) => statement.actions.some((action) => action === "*" || action.startsWith("workflows:"))
-  );
-}
-async function listWorkspaces(client) {
-  const workspaces = await studioRequest(client, "GET", "/v1/api/me/workspaces");
-  return workspaces.map((workspace) => ({
-    id: workspace.id,
-    name: workspace.name,
-    ...workspace.role ? { userRole: workspace.role } : {},
-    isDefault: workspace.isDefault
-  }));
-}
-function listWorkspaceIntegrations(client, workspaceId) {
-  return studioRequest(client, "GET", `/v1/api/me/workspaces/${workspaceId}/integrations`);
+async function writeDbConfig(dir, config) {
+  await mkdir5(dir, { recursive: true });
+  await writeFile6(configFile(dir), JSON.stringify(config, null, 2) + "\n");
+  return configFile(dir);
 }
-
-// src/project/state.ts
-import { mkdir as mkdir5, readFile as readFile6, writeFile as writeFile6 } from "node:fs/promises";
-import path7 from "node:path";
-var STATE_DIR_NAME = ".softr-workflows";
-function stateDir(dir) {
-  return path7.join(dir, STATE_DIR_NAME);
-}
-async function readState(dir) {
+async function readSchemaCache(dir) {
   try {
-    return JSON.parse(await readFile6(path7.join(stateDir(dir), "state.json"), "utf8"));
+    return JSON.parse(await readFile6(cacheFile(dir), "utf8"));
   } catch (error) {
     if (error.code === "ENOENT") {
       return void 0;
@@ -14702,14 +14957,19 @@ async function readState(dir) {
     throw error;
   }
 }
-async function writeState(dir, state) {
-  await mkdir5(stateDir(dir), { recursive: true });
-  const value = { ...state, updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
-  await writeFile6(path7.join(stateDir(dir), "state.json"), JSON.stringify(value, null, 2) + "\n");
+async function writeSchemaCache(dir, database, tables) {
+  const cache = { database, tables, refreshedAt: (/* @__PURE__ */ new Date()).toISOString() };
+  await mkdir5(path8.dirname(cacheFile(dir)), { recursive: true });
+  await writeFile6(cacheFile(dir), JSON.stringify(cache, null, 2) + "\n");
+  await pruneViewsCache(dir, new Set(tables.map((table) => table.id)));
+  return cache;
 }
-async function readStateFile(dir, name) {
+function viewsDir(dir) {
+  return path8.join(dir, DB_CACHE_DIR_NAME, "views");
+}
+async function readViewsCache(dir, tableId) {
   try {
-    return JSON.parse(await readFile6(path7.join(stateDir(dir), name), "utf8"));
+    return JSON.parse(await readFile6(path8.join(viewsDir(dir), `${tableId}.json`), "utf8"));
   } catch (error) {
     if (error.code === "ENOENT") {
       return void 0;
@@ -14717,112 +14977,261 @@ async function readStateFile(dir, name) {
     throw error;
   }
 }
-async function writeStateFile(dir, name, value) {
-  await mkdir5(stateDir(dir), { recursive: true });
-  const file = path7.join(stateDir(dir), name);
-  await writeFile6(file, JSON.stringify(value, null, 2) + "\n");
-  return file;
+async function writeViewsCache(dir, tableId, views) {
+  const value = { tableId, views, refreshedAt: (/* @__PURE__ */ new Date()).toISOString() };
+  await mkdir5(viewsDir(dir), { recursive: true });
+  await writeFile6(path8.join(viewsDir(dir), `${tableId}.json`), JSON.stringify(value, null, 2) + "\n");
 }
-
-// src/commands/list.ts
-function toRow(workflow, workspace) {
-  return {
-    id: workflow.id,
-    title: workflow.title,
-    workspaceId: workspace.id,
-    workspaceName: workspace.name,
-    live: workflow.enabledVersion ?? null,
-    version: workflow.version,
-    draft: workflow.draft,
-    updatedAt: workflow.updatedAt ?? null,
-    triggers: (workflow.triggerSummaries ?? []).map(({ id, type }) => ({ id, type }))
-  };
+async function pruneViewsCache(dir, tableIds) {
+  let names2;
+  try {
+    names2 = await readdir2(viewsDir(dir));
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return;
+    }
+    throw error;
+  }
+  await Promise.all(
+    names2.filter((name) => name.endsWith(".json") && !tableIds.has(name.slice(0, -".json".length))).map((name) => rm(path8.join(viewsDir(dir), name), { force: true }))
+  );
 }
-async function collectWorkflows(client, { workspaceId, applicationId } = {}) {
-  const workspaces = await listWorkspaces(client);
-  const selected = workspaceId ? workspaces.filter((workspace) => workspace.id === workspaceId) : workspaces;
-  if (workspaceId && !selected.length) {
+async function refreshSchemaCache(client, dir, databaseId) {
+  const [database, tables] = await Promise.all([getDatabase(client, databaseId), listTables(client, databaseId)]);
+  return writeSchemaCache(dir, database, tables);
+}
+async function removeSchemaCache(dir) {
+  await rm(path8.join(dir, DB_CACHE_DIR_NAME), { recursive: true, force: true });
+}
+async function resolveDatabase(cwd, databaseId, explicitDir) {
+  const dir = path8.resolve(cwd, explicitDir ?? ".");
+  const config = await readDbConfig(dir);
+  if (explicitDir && !config) {
+    throw new CliError(`No ${DB_CONFIG_FILE_NAME} in ${dir}.`, 'Run "softr db get <database>" to create one.');
+  }
+  const given = databaseId ?? (process.env[DATABASE_ID_ENV_VAR] || void 0);
+  if (given) {
+    return config?.databaseId === given ? { databaseId: given, dir } : { databaseId: given };
+  }
+  if (config) {
+    return { databaseId: config.databaseId, dir };
+  }
+  const candidates = await listSubdirsWith(cwd, dbConfigExists);
+  throw new CliError(
+    `Which database? There is no ${DB_CONFIG_FILE_NAME} in ${cwd}.`,
+    candidates.length ? `Databases found in: ${candidates.map((candidate) => path8.relative(cwd, candidate)).join(", ")}. Pass --dir <name> or cd into one.` : `Pass the database id, set ${DATABASE_ID_ENV_VAR}, or run "softr db get <database>".`
+  );
+}
+function belongsToAnother(dir, existingId, wantedId, hint) {
+  return new CliError(
+    `${path8.join(dir, DB_CONFIG_FILE_NAME)} belongs to database ${existingId}${wantedId ? `, not ${wantedId}` : ""}.`,
+    hint
+  );
+}
+async function databaseDirFor(cwd, explicitDir, databaseId, dirName) {
+  const here = path8.resolve(cwd, explicitDir ?? ".");
+  const inHere = await readDbConfig(here);
+  if (inHere) {
+    if (databaseId && inHere.databaseId === databaseId) {
+      return { dir: here, existing: true };
+    }
+    throw belongsToAnother(
+      here,
+      inHere.databaseId,
+      databaseId,
+      explicitDir ? "Pick another --dir." : "Run it from the parent directory (a new subdirectory is created) or pass --dir."
+    );
+  }
+  if (explicitDir) {
+    return { dir: here, existing: false };
+  }
+  const sibling2 = path8.join(cwd, dirName);
+  const inSibling = await readDbConfig(sibling2);
+  if (inSibling) {
+    if (inSibling.databaseId === databaseId) {
+      return { dir: sibling2, existing: true };
+    }
+    throw belongsToAnother(sibling2, inSibling.databaseId, databaseId, "Pass --dir <path>.");
+  }
+  return { dir: sibling2, existing: false };
+}
+async function findReachableDatabase(client, reference) {
+  const database = byIdOrName(
+    await listDatabases(client),
+    reference,
+    "database",
+    (item) => `${item.id} (workspace ${item.workspaceId})`
+  );
+  if (!database) {
     throw new CliError(
-      `You have no access to workspace ${workspaceId}.`,
-      `Known workspaces: ${workspaces.map((w) => `${w.name} (${w.id})`).join(", ")}`
+      `The token reaches no database with the id or name "${reference}".`,
+      '"softr db list" shows the ones it reaches.'
     );
   }
-  const listing = { workspaces: [], workflows: [], failures: [] };
-  for (const workspace of selected) {
-    try {
-      const page = await listWorkflows(client, workspace.id, { applicationId });
-      listing.workspaces.push({ id: workspace.id, name: workspace.name });
-      listing.workflows.push(...page.items.map((workflow) => toRow(workflow, workspace)));
-    } catch (error) {
-      if (!(error instanceof SoftrApiError) || selected.length === 1) {
-        throw error;
-      }
-      listing.failures.push({
-        workspaceId: workspace.id,
-        workspaceName: workspace.name,
-        status: error.status,
-        message: error.body
-      });
+  return database;
+}
+async function bindDatabaseDir(client, cwd, reference, explicitDir) {
+  const here = path8.resolve(cwd, explicitDir ?? ".");
+  const config = await readDbConfig(here);
+  if (!reference || reference === config?.databaseId) {
+    if (!config) {
+      const candidates = await listSubdirsWith(cwd, dbConfigExists);
+      throw new CliError(
+        `Which database? There is no ${DB_CONFIG_FILE_NAME} in ${here}.`,
+        candidates.length ? `Databases found in: ${candidates.map((candidate) => path8.relative(cwd, candidate)).join(", ")}. Pass --dir <name> or cd into one.` : 'Pass its id or name: softr db get <database>. "softr db list" shows the ones the token reaches.'
+      );
     }
+    return { databaseId: config.databaseId, dir: here, wrote: false };
   }
-  return listing;
+  const database = await findReachableDatabase(client, reference);
+  const { dir, existing } = await databaseDirFor(cwd, explicitDir, database.id, slug(database.name, "database"));
+  if (!existing) {
+    await writeDbConfig(dir, { databaseId: database.id });
+  }
+  return { databaseId: database.id, dir, wrote: !existing };
 }
-var TITLE_WIDTH = 34;
-function workflowTable(rows) {
-  const table = new import_cli_table3.default({
-    head: ["ID", "Title", "Triggers", "Status", "Version", "Draft"],
-    // Only the free-text title wraps; the other columns size to their content, so trigger types are never cut off.
-    colWidths: [null, TITLE_WIDTH, null, null, null, null],
-    wordWrap: true,
-    style: { head: [], border: [], "padding-left": 1, "padding-right": 1 }
-  });
-  for (const row of rows) {
-    table.push([
-      row.id,
-      row.title,
-      row.triggers.map((trigger) => trigger.type).join("\n") || "-",
-      row.live === null ? "not enabled" : `live v${row.live}`,
-      row.version,
-      row.draft
-    ]);
+
+// src/commands/db/help.ts
+var DATABASE_ID_HELP = `the database id (default: $SOFTR_DATABASE_ID, else the one in ${DB_CONFIG_FILE_NAME})`;
+var DATABASE_DIR_HELP = `database directory, the one holding ${DB_CONFIG_FILE_NAME} (default: the current directory)`;
+
+// src/api/studio.ts
+async function resolveTokenOwner(client) {
+  try {
+    return await studioRequest(client, "POST", "/v1/users/me/token", { token: client.token });
+  } catch (error) {
+    if (error instanceof SoftrApiError && error.status === 404) {
+      throw new CliError(
+        "The studio does not know this token: revoked, expired, or from another environment.",
+        'Create a new personal API token in the studio, or run "softr login" for the browser login.'
+      );
+    }
+    throw error;
   }
-  return table.toString();
 }
-function renderWorkflows({ workspaces, workflows: workflows2, failures }) {
-  const blocks = [];
-  for (const workspace of workspaces) {
-    const rows = workflows2.filter((row) => row.workspaceId === workspace.id);
-    const heading = `Workspace: ${workspace.name} (${workspace.id})`;
-    blocks.push(rows.length ? `${heading}
-${workflowTable(rows)}` : `${heading}
-  (no workflows)`);
+var WORKFLOWS_READ_SCOPE = "workflows:read";
+var DATABASES_SCHEMA_WRITE_SCOPE = "databases.schema:write";
+function grantsActionOf(statements, prefix) {
+  return (statements ?? []).some(
+    (statement) => statement.actions.some((action) => action === "*" || action.startsWith(prefix))
+  );
+}
+function grantsWorkflows(statements) {
+  return grantsActionOf(statements, "workflows:");
+}
+function grantsDatabases(statements) {
+  return grantsActionOf(statements, "databases.");
+}
+async function listWorkspacesWith(client, scope) {
+  const reachable = await listWorkspaces(client);
+  return { reachable, granted: reachable.filter((workspace) => !workspace.scopes || workspace.scopes.includes(scope)) };
+}
+async function listWorkspaces(client) {
+  const workspaces = await studioRequest(client, "GET", "/v1/api/me/workspaces");
+  return workspaces.map((workspace) => ({
+    id: workspace.id,
+    name: workspace.name,
+    ...workspace.role ? { userRole: workspace.role } : {},
+    isDefault: workspace.isDefault,
+    ...workspace.scopes ? { scopes: workspace.scopes } : {}
+  }));
+}
+function listWorkspaceIntegrations(client, workspaceId) {
+  return studioRequest(client, "GET", `/v1/api/me/workspaces/${workspaceId}/integrations`);
+}
+
+// src/commands/init.ts
+import path10 from "node:path";
+
+// src/api/workflows.ts
+function getWorkflow(client, workflowId) {
+  return apiRequest(client, "GET", `/v1/workflows/${workflowId}`);
+}
+function updateWorkflow(client, workflowId, body) {
+  return apiRequest(client, "PUT", `/v1/workflows/${workflowId}`, body);
+}
+function getWorkflowOutputs(client, workflowId) {
+  return apiRequest(client, "GET", `/v1/workflows/${workflowId}/outputs`);
+}
+function listWorkflows(client, workspaceId, { applicationId } = {}) {
+  const query = new URLSearchParams({ workspaceId, ...applicationId ? { applicationId } : {}, limit: "500" });
+  return apiRequest(client, "GET", `/v1/workflows?${query}`);
+}
+function pinWorkflow(client, workflowId, applicationId) {
+  return apiRequestVoid(client, "POST", `/v1/workflows/${workflowId}/pinned-applications/${applicationId}`);
+}
+function unpinWorkflow(client, workflowId, applicationId) {
+  return apiRequestVoid(client, "DELETE", `/v1/workflows/${workflowId}/pinned-applications/${applicationId}`);
+}
+function testAction(client, workflowId, hierarchyPath2, mode) {
+  return apiRequest(client, "POST", `/v1/workflows/${workflowId}/outputs/${mode}/actions/${hierarchyPath2}`, {});
+}
+function testTrigger(client, workflowId, triggerId) {
+  return apiRequest(client, "POST", `/v1/workflows/${workflowId}/outputs/triggers/${triggerId}/test`, {});
+}
+function saveTriggerSample(client, workflowId, triggerId, sample) {
+  return apiRequestVoid(client, "POST", `/v1/workflows/${workflowId}/sample-output/triggers/${triggerId}`, sample);
+}
+function createWorkflow(client, body) {
+  return apiRequest(client, "POST", "/v1/workflows", body);
+}
+function enableWorkflow(client, workflowId) {
+  return apiRequestVoid(client, "PUT", `/v1/workflows/${workflowId}/enabled`);
+}
+function disableWorkflow(client, workflowId) {
+  return apiRequestVoid(client, "DELETE", `/v1/workflows/${workflowId}/enabled`);
+}
+async function getEnabledVersion(client, workflowId) {
+  try {
+    return await apiRequest(client, "GET", `/v1/workflows/${workflowId}/enabled`);
+  } catch (error) {
+    if (error instanceof SoftrApiError && error.status === 404) {
+      return null;
+    }
+    throw error;
   }
-  if (failures.length) {
-    blocks.push(
-      [
-        `Listing failed for ${failures.length} workspace${failures.length === 1 ? "" : "s"} (skipped):`,
-        ...failures.map(
-          (failure) => `  ${failure.workspaceName} (${failure.workspaceId}): status ${failure.status}${failure.message ? `: ${failure.message}` : ""}`
-        )
-      ].join("\n")
-    );
+}
+function getWorkflowReadiness(client, workflowId) {
+  return apiRequest(client, "GET", `/v1/workflows/${workflowId}/readiness`);
+}
+
+// src/project/state.ts
+import { mkdir as mkdir6, readFile as readFile7, writeFile as writeFile7 } from "node:fs/promises";
+import path9 from "node:path";
+var STATE_DIR_NAME = ".softr-workflows";
+function stateDir(dir) {
+  return path9.join(dir, STATE_DIR_NAME);
+}
+async function readState(dir) {
+  try {
+    return JSON.parse(await readFile7(path9.join(stateDir(dir), "state.json"), "utf8"));
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return void 0;
+    }
+    throw error;
   }
-  return blocks.join("\n\n");
 }
-async function emitWorkflowList(options, client, { workspaceId, applicationId, human } = {}) {
-  const listing = await collectWorkflows(client, { workspaceId, applicationId });
-  emit(options, [human, renderWorkflows(listing)].filter(Boolean).join("\n\n"), { ...listing });
+async function writeState(dir, state) {
+  await mkdir6(stateDir(dir), { recursive: true });
+  const value = { ...state, updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
+  await writeFile7(path9.join(stateDir(dir), "state.json"), JSON.stringify(value, null, 2) + "\n");
 }
-function registerList(program3) {
-  program3.command("list").description("List the workflows you can access, grouped by workspace").option("--workspace <id>", "only this workspace (default: $SOFTR_WORKSPACE_ID when set)").option("--app <id>", "only the workflows linked to this application").action(async (opts, command) => {
-    const options = globalOptions(command);
-    const target = resolveTarget(await readState(process.cwd()));
-    const client = await authenticatedClient(target);
-    await emitWorkflowList(options, client, {
-      workspaceId: opts.workspace ?? process.env["SOFTR_WORKSPACE_ID"],
-      applicationId: opts.app
-    });
-  });
+async function readStateFile(dir, name) {
+  try {
+    return JSON.parse(await readFile7(path9.join(stateDir(dir), name), "utf8"));
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return void 0;
+    }
+    throw error;
+  }
+}
+async function writeStateFile(dir, name, value) {
+  await mkdir6(stateDir(dir), { recursive: true });
+  const file = path9.join(stateDir(dir), name);
+  await writeFile7(file, JSON.stringify(value, null, 2) + "\n");
+  return file;
 }
 
 // src/catalog/schema.ts
@@ -15056,302 +15465,855 @@ function registerSchema(program3) {
   });
 }
 
-// src/commands/pull.ts
-function slug(title) {
-  return title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "workflow";
-}
-async function targetDir(cwd, explicitDir, workflowId, title) {
-  if (explicitDir) {
-    return path8.resolve(cwd, explicitDir);
+// src/commands/init.ts
+var TRIGGER_ID = "trigger";
+function requireGrantedWorkspace({ reachable, granted }, requested, scope) {
+  if (granted.some((workspace) => workspace.id === requested)) {
+    return;
   }
-  if (await configExists(cwd)) {
-    const existing = await readConfig(cwd);
-    if (existing.id && existing.id !== workflowId) {
-      throw new CliError(
-        `${CONFIG_FILE_NAME} here belongs to workflow ${existing.id}, not ${workflowId}.`,
-        "Run pull from the parent directory (a new subdirectory is created) or pass --dir."
-      );
-    }
-    return cwd;
+  if (reachable.some((workspace) => workspace.id === requested)) {
+    throw new CliError(
+      `The token does not grant ${scope} on workspace ${requested}.`,
+      `Check the token's grants with "softr whoami", or run "softr login" again.`
+    );
   }
-  return path8.join(cwd, slug(title));
+  throw new CliError(
+    `You have no access to workspace ${requested}.`,
+    `Known workspaces: ${granted.map((w) => `${w.name} (${w.id})`).join(", ")}`
+  );
 }
-function registerPull(program3) {
-  program3.command("pull").description("Download a workflow into softr-workflows.jsonc and one code file per custom code node").argument("[workflowId]", "the workflow id (last segment of its studio URL); omit to list what you can pull").option("--dir <path>", "target directory (default: this directory if it holds the workflow, else ./<title-slug>)").option("--force", "overwrite an existing softr-workflows.jsonc and its code files").action(async (workflowId, opts, command) => {
-    const options = globalOptions(command);
-    const cwd = process.cwd();
-    const remembered = await readState(opts.dir ? path8.resolve(cwd, opts.dir) : cwd);
-    const target = resolveTarget(remembered);
-    const client = await authenticatedClient(target);
-    if (!workflowId) {
-      await emitWorkflowList(options, client, {
-        human: "Pick a workflow and run: softr workflows pull <workflowId>"
+async function resolveWorkspace(client, requested, scope = WORKFLOWS_READ_SCOPE) {
+  const listing = await listWorkspacesWith(client, scope);
+  const workspaces = listing.granted;
+  if (requested) {
+    requireGrantedWorkspace(listing, requested, scope);
+    return requested;
+  }
+  if (workspaces.length === 1 && workspaces[0]) {
+    return workspaces[0].id;
+  }
+  if (!workspaces.length) {
+    throw new CliError(
+      `The token grants ${scope} on no workspace.`,
+      `Check the token's grants with "softr whoami", or run "softr login" again.`
+    );
+  }
+  const preferred = workspaces.find((workspace) => workspace.isDefault);
+  if (preferred) {
+    return preferred.id;
+  }
+  throw new CliError(
+    "Pass --workspace <id>: you have access to several workspaces.",
+    `Choose one of: ${workspaces.map((w) => `${w.name} (${w.id})`).join(", ")}`
+  );
+}
+function registerInit(program3) {
+  program3.command("init").description("Create a new workflow with one trigger, on the server and as a local directory").argument("<title>", "the workflow title").option(
+    "--workspace <id>",
+    "workspace to create it in (default: $SOFTR_WORKSPACE_ID, else your only or default workspace)"
+  ).option("--pin-to-app <id>", "application to pin the workflow to (default: $SOFTR_PINNED_APP_ID when set)").option("--trigger <TYPE>", 'trigger type from "spec" (default WEBHOOK)', "WEBHOOK").option("--dir <path>", "directory to create (default: ./<title-slug>)").action(
+    async (title, opts, command) => {
+      const options = globalOptions(command);
+      const cwd = process.cwd();
+      const dir = path10.resolve(cwd, opts.dir ?? slug(title));
+      if (await configExists(dir)) {
+        throw new CliError(`${path10.join(dir, CONFIG_FILE_NAME)} already exists.`, "Pick another --dir or title.");
+      }
+      const trigger = findCatalogEntry(opts.trigger, "trigger");
+      const target = resolveTarget();
+      const client = await authenticatedClient(target);
+      const workspaceId = await resolveWorkspace(client, opts.workspace ?? process.env["SOFTR_WORKSPACE_ID"]);
+      const pinToApplicationId = opts.pinToApp ?? process.env["SOFTR_PINNED_APP_ID"];
+      const created = await createWorkflow(client, {
+        workspaceId,
+        applicationId: null,
+        ...pinToApplicationId ? { pinToApplicationId } : {},
+        title,
+        thumbnail: null,
+        triggers: [{ id: TRIGGER_ID, type: trigger.type, version: trigger.version, inputs: trigger.template }],
+        actions: [],
+        paths: [],
+        // Like the studio: the author's time zone, so schedules and waits mean what they read.
+        configuration: { timeZone: Intl.DateTimeFormat().resolvedOptions().timeZone || "UTC" }
       });
-      return;
+      const workflow = await getWorkflow(client, created.id);
+      const config = { $schema: SCHEMA_POINTER, ...toLocalConfig(workflow) };
+      const configFile2 = await writeConfig(dir, config);
+      await writeSchemaFile(dir);
+      const syncedHash = definitionHash((await packWorkflow(config, dir)).packed);
+      await writeState(dir, {
+        ...target,
+        workflowId: created.id,
+        version: workflow.version,
+        draft: workflow.draft,
+        syncedHash
+      });
+      const studioUrl = `${target.studioUrl}/workflow/${created.id}`;
+      emit(
+        options,
+        `Created "${title}" (${created.id}) with a ${trigger.type} trigger "${TRIGGER_ID}" in workspace ${workspaceId}${pinToApplicationId ? `, linked to application ${pinToApplicationId}` : ""}.
+  ${path10.relative(cwd, configFile2)}
+${studioUrl}
+Next: softr workflows add <TYPE> --dir ${path10.relative(cwd, dir) || "."} (see "spec" for the types), then push and test.`,
+        {
+          workflowId: created.id,
+          workspaceId,
+          pinnedToApplicationId: pinToApplicationId ?? null,
+          title,
+          triggerId: TRIGGER_ID,
+          triggerType: trigger.type,
+          dir,
+          studioUrl
+        }
+      );
     }
-    const workflow = await getWorkflow(client, workflowId);
-    const dir = await targetDir(cwd, opts.dir, workflowId, workflow.title);
-    if (await configExists(dir) && !opts.force) {
-      throw new CliError(
-        `${path8.join(dir, CONFIG_FILE_NAME)} already exists.`,
-        "Pass --force to overwrite it and its code files."
+  );
+}
+
+// src/commands/db/databases.ts
+function renderDatabases(databases) {
+  if (!databases.length) {
+    return "The token reaches no database. Create one with: softr db create <name>";
+  }
+  const table = new import_cli_table3.default(plainTable(["ID", "Name", "Workspace", "Tables"], [38, 34, 38, 8]));
+  for (const database of databases) {
+    table.push([database.id, database.name, database.workspaceId, String(database.tablesCount)]);
+  }
+  return table.toString();
+}
+function renderDatabase(database, tables) {
+  return [
+    `${database.name} (${database.id})`,
+    ...database.description ? [`  ${database.description}`] : [],
+    `  Workspace: ${database.workspaceId}`,
+    `  Created:   ${database.createdAt}`,
+    `  Updated:   ${database.updatedAt}`,
+    `  Tables:    ${tables.length}`,
+    ...tables.map((table) => `    ${table.name} (${table.id}), ${table.fields.length} fields`)
+  ].join("\n");
+}
+function relativeDir(cwd, dir) {
+  return path11.relative(cwd, dir) || ".";
+}
+function registerDatabases(db2) {
+  db2.command("list").description("List the databases the token reaches, across all workspaces").action(async (_opts, command) => {
+    const options = globalOptions(command);
+    const client = await authenticatedClient(resolveTarget());
+    const databases = await listDatabases(client);
+    emit(options, renderDatabases(databases), { databases });
+  });
+  db2.command("get").description(
+    `Show a database with its tables and keep its directory: ${DB_CONFIG_FILE_NAME} and the schema cache in ${DB_CACHE_DIR_NAME}/`
+  ).argument(
+    "[database]",
+    `the database id or exact name (default: $SOFTR_DATABASE_ID, else the one in ${DB_CONFIG_FILE_NAME})`
+  ).option(
+    "--dir <path>",
+    "database directory (default: this directory if it holds a database, else a new ./<name-slug> for the one given)"
+  ).action(async (argument, opts, command) => {
+    const options = globalOptions(command);
+    const cwd = process.cwd();
+    const reference = argument ?? (process.env[DATABASE_ID_ENV_VAR] || void 0);
+    const client = await authenticatedClient(resolveTarget());
+    const { databaseId, dir, wrote } = await bindDatabaseDir(client, cwd, reference, opts.dir);
+    const { database, tables } = await refreshSchemaCache(client, dir, databaseId);
+    const note = wrote ? `
+Wrote ${path11.join(relativeDir(cwd, dir), DB_CONFIG_FILE_NAME)}.` : "";
+    emit(options, renderDatabase(database, tables) + note, { database, tables, dir });
+  });
+  db2.command("create").description(`Create an empty database and a directory for it with ${DB_CONFIG_FILE_NAME}`).argument("<name>", "the database name").option("--description <text>", "what the database holds").option(
+    "--workspace <id>",
+    "workspace to create it in (default: $SOFTR_WORKSPACE_ID, else your only or default workspace)"
+  ).option("--dir <path>", "directory to create (default: ./<name-slug>)").action(
+    async (name, opts, command) => {
+      const options = globalOptions(command);
+      const cwd = process.cwd();
+      const { dir } = await databaseDirFor(cwd, opts.dir, void 0, slug(name, "database"));
+      const client = await authenticatedClient(resolveTarget());
+      const workspaceId = await resolveWorkspace(
+        client,
+        opts.workspace ?? process.env["SOFTR_WORKSPACE_ID"],
+        DATABASES_SCHEMA_WRITE_SCOPE
+      );
+      const database = await createDatabase(client, { workspaceId, name, description: opts.description });
+      await writeDbConfig(dir, { databaseId: database.id });
+      await refreshSchemaCache(client, dir, database.id);
+      emit(
+        options,
+        `Created database ${database.name} (${database.id}) in workspace ${workspaceId}.
+  ${path11.join(relativeDir(cwd, dir), DB_CONFIG_FILE_NAME)}`,
+        { database, dir }
       );
     }
-    let rows = [];
-    let outputsNote = "";
-    let outputsFile;
-    try {
-      rows = await getWorkflowOutputs(client, workflowId);
-    } catch (error) {
-      outputsNote = `
-Sample outputs not available, inputData types are unknown: ${error.message}`;
+  );
+  db2.command("update").description("Change a database's name or description").argument("[databaseId]", DATABASE_ID_HELP).option("--name <name>", "the new name").option("--description <text>", "the new description").option("--dir <path>", DATABASE_DIR_HELP).action(
+    async (databaseId, opts, command) => {
+      if (!opts.name && !opts.description) {
+        throw new CliError("Nothing to change: pass --name, --description or both.");
+      }
+      const options = globalOptions(command);
+      const target = await resolveDatabase(process.cwd(), databaseId, opts.dir);
+      const client = await authenticatedClient(resolveTarget());
+      const database = await updateDatabase(client, target.databaseId, {
+        name: opts.name,
+        description: opts.description
+      });
+      if (target.dir) {
+        const cache = await readSchemaCache(target.dir);
+        await (cache ? writeSchemaCache(target.dir, database, cache.tables) : refreshSchemaCache(client, target.dir, database.id));
+      }
+      emit(options, `Updated database ${database.name} (${database.id}).`, { database });
     }
-    const config = { $schema: SCHEMA_POINTER, ...toLocalConfig(workflow) };
-    const codeFiles = await externalizeCode(config, dir, indexOutputs(rows));
-    await writeSchemaFile(dir);
-    const configFile = await writeConfig(dir, config);
-    const syncedHash = definitionHash((await packWorkflow(config, dir)).packed);
-    await writeState(dir, { ...target, workflowId, version: workflow.version, draft: workflow.draft, syncedHash });
-    if (!outputsNote) {
-      outputsFile = await writeStateFile(dir, "outputs.json", rows);
+  );
+  db2.command("delete").description("Delete a database; one that still has tables needs --force").argument("[databaseId]", DATABASE_ID_HELP).option("--force", "also delete its tables and all their records").option("--dir <path>", DATABASE_DIR_HELP).action(async (databaseId, opts, command) => {
+    const options = globalOptions(command);
+    const target = await resolveDatabase(process.cwd(), databaseId, opts.dir);
+    const client = await authenticatedClient(resolveTarget());
+    await deleteDatabase(client, target.databaseId, opts.force === true);
+    if (target.dir) {
+      await removeSchemaCache(target.dir);
     }
-    const files = [configFile, ...codeFiles].map((file) => path8.relative(cwd, file));
-    emitWithVersionNote(
+    emit(
       options,
-      config,
-      `Pulled "${workflow.title}" (version ${workflow.version}, draft ${workflow.draft}, ${workflow.enabled ? "enabled" : "not enabled"}).
-` + files.map((file) => `  ${file}`).join("\n") + outputsNote,
-      {
-        workflowId,
-        apiUrl: target.apiUrl,
-        title: workflow.title,
-        version: workflow.version,
-        draft: workflow.draft,
-        enabled: workflow.enabled ?? false,
-        dir,
-        files,
-        outputsFile: outputsFile ?? null
-      }
+      `Deleted database ${target.databaseId}.` + (target.dir ? `
+${path11.join(relativeDir(process.cwd(), target.dir), DB_CONFIG_FILE_NAME)} still names the deleted database; delete the directory.` : ""),
+      { deleted: target.databaseId }
     );
   });
 }
 
-// src/commands/add.ts
-function uniqueId(base, taken) {
-  if (!taken.has(base)) {
-    return base;
+// src/commands/db/records.ts
+import { readFile as readFile9 } from "node:fs/promises";
+import path12 from "node:path";
+
+// src/commands/db/json-input.ts
+import { readFile as readFile8 } from "node:fs/promises";
+async function readJsonArgument(value, option, hint) {
+  let text = value;
+  if (value === "-") {
+    const chunks = [];
+    for await (const chunk of process.stdin) {
+      chunks.push(chunk);
+    }
+    text = Buffer.concat(chunks).toString("utf8");
+  } else if (value.startsWith("@")) {
+    text = await readFile8(value.slice(1), "utf8");
   }
-  for (let n = 2; ; n++) {
-    if (!taken.has(`${base}-${n}`)) {
-      return `${base}-${n}`;
-    }
+  try {
+    return JSON.parse(text);
+  } catch {
+    throw new CliError(`${option} is not valid JSON.`, hint ?? "Pass inline JSON, @<file> or - for stdin.");
   }
 }
-function defaultAfter(config, loopId) {
-  const order = executionOrder(config);
-  const container = loopId ? order.filter((node) => node.loopId === loopId) : order.filter((node) => node.loopId === void 0 && node.reachable);
-  if (!container.length) {
-    if (loopId) {
-      return loopId;
-    }
-    const trigger = config.triggers?.[0];
-    if (!trigger) {
-      throw new CliError("The workflow has no trigger to attach the first action to.");
+
+// src/commands/db/schema.ts
+var import_cli_table32 = __toESM(require_cli_table3(), 1);
+var FIELD_REFERENCE_URL = "https://docs.softr.io/softr-api/softr-database-api/table-fields/add-table-field";
+var TABLE_ARGUMENT = "the table id or exact name";
+var FIELD_ARGUMENT = "the field id or exact name";
+function withDatabaseOptions(command) {
+  return command.option("--database <id>", DATABASE_ID_HELP).option("--dir <path>", DATABASE_DIR_HELP);
+}
+async function schemaContext(opts) {
+  const target = await resolveDatabase(process.cwd(), opts.database, opts.dir);
+  const client = await authenticatedClient(resolveTarget());
+  const cache = target.dir ? await readSchemaCache(target.dir) : void 0;
+  return { client, databaseId: target.databaseId, dir: target.dir, cache };
+}
+async function currentTables(context, fresh) {
+  if (!context.dir) {
+    return listTables(context.client, context.databaseId);
+  }
+  if (!fresh && context.cache) {
+    return context.cache.tables;
+  }
+  context.cache = await refreshSchemaCache(context.client, context.dir, context.databaseId);
+  return context.cache.tables;
+}
+async function findTable(context, reference, fresh = false) {
+  const table = byIdOrName(await currentTables(context, fresh), reference, "table") ?? (context.dir && !fresh ? byIdOrName(await currentTables(context, true), reference, "table") : void 0);
+  if (!table) {
+    throw new CliError(
+      `Database ${context.databaseId} has no table with the id or name "${reference}".`,
+      '"softr db tables list" shows its tables.'
+    );
+  }
+  return table;
+}
+async function findFields(context, table, references, fresh = false) {
+  const resolve = (current3) => {
+    const fields2 = /* @__PURE__ */ new Map();
+    for (const reference of references) {
+      const field = byIdOrName(current3.fields, reference, "field");
+      if (field) {
+        fields2.set(reference, field);
+      }
     }
-    return trigger.id;
+    return fields2;
+  };
+  let current2 = table;
+  let fields = resolve(current2);
+  if (fields.size < new Set(references).size && context.dir && !fresh) {
+    current2 = await findTable(context, table.id, true);
+    fields = resolve(current2);
+  }
+  const missing = references.filter((reference) => !fields.has(reference));
+  if (missing.length) {
+    throw new CliError(
+      `Table ${current2.name} has no field with the id or name ${missing.map((name) => `"${name}"`).join(", ")}.`,
+      `"softr db tables get ${current2.id}" shows its fields.`
+    );
   }
-  const paths = loopId ? [...allActions(config.actions)].find((node) => node.id === loopId)?.inputs?.paths ?? [] : config.paths ?? [];
-  const withOutgoing = new Set(paths.map((p) => p.fromActionId));
-  const leaves = container.filter((node) => !withOutgoing.has(node.id));
-  if (leaves.length === 1 && leaves[0]) {
-    return leaves[0].id;
+  return { table: current2, fields };
+}
+async function findField(context, tableReference, reference, fresh = false) {
+  const found = await findFields(context, await findTable(context, tableReference, fresh), [reference], fresh);
+  return { table: found.table, field: found.fields.get(reference) };
+}
+async function afterSchemaWrite(context) {
+  if (context.dir) {
+    context.cache = await refreshSchemaCache(context.client, context.dir, context.databaseId);
   }
-  throw new CliError(
-    leaves.length ? `Several nodes have no successor: ${leaves.map((node) => node.id).join(", ")}.` : "Every node already has a successor.",
-    "Pass --after <nodeId> to say where the new node goes."
-  );
 }
-function registerAdd(program3) {
-  program3.command("add").description("Add an action after an existing node, or a trigger; custom code gets its own file under actions/").argument("<type>", 'node type from "spec", e.g. CUSTOM_CODE or WEBHOOK').option("--id <id>", "node id, readable and unique (default: derived from the type)").option("--title <title>", "node title shown in the studio (default: the type label)").option("--after <nodeId>", "actions: the node the new one follows (default: the only node without a successor)").option("--to <nodeId>", "triggers: an action the new trigger leads to").option("--in-loop <loopId>", "put the node inside this loop body").option("--lang <language>", "for CUSTOM_CODE: JAVASCRIPT or PYTHON (default JAVASCRIPT)").option("--dir <path>", "workflow directory (default: the current directory)").action(async (type, opts, command) => {
-    const options = globalOptions(command);
-    const dir = await findWorkflowDir(process.cwd(), opts.dir);
-    const config = await readConfig(dir);
-    const entry = findCatalogEntry(type);
-    const nodes = [...config.triggers ?? [], ...allActions(config.actions)];
-    const taken = new Set(nodes.map((node2) => node2.id));
-    const id = opts.id ?? uniqueId(entry.kind === "trigger" ? "trigger" : slug(entry.label), taken);
-    if (taken.has(id)) {
-      throw new CliError(`Node id "${id}" is already used.`);
-    }
-    if (id.includes(":::") || /[\s/?#]/.test(id)) {
-      throw new CliError(`Node id "${id}" must not contain ":::", spaces, "/", "?" or "#".`);
+function parseOptions(value) {
+  return value === void 0 ? Promise.resolve(void 0) : readJsonArgument(value, "--options", `The options of each field type: ${FIELD_REFERENCE_URL}`);
+}
+function parseFieldSpec(spec) {
+  const colon = spec.lastIndexOf(":");
+  const name = colon > 0 ? spec.slice(0, colon).trim() : "";
+  const type = colon > 0 ? spec.slice(colon + 1).trim().toUpperCase() : "";
+  if (!name || !type) {
+    throw new CliError(`--field "${spec}" must be <name>:<TYPE>, for example "Due date:DATE".`);
+  }
+  return { name, type };
+}
+function renderTables(tables) {
+  if (!tables.length) {
+    return "The database has no tables. Create one with: softr db tables create <name>";
+  }
+  const table = new import_cli_table32.default(plainTable(["ID", "Name", "Fields", "Primary field"], [18, 34, 8, 30]));
+  for (const item of tables) {
+    const primary = item.fields.find((field) => field.id === item.primaryFieldId);
+    table.push([item.id, item.name, String(item.fields.length), primary?.name ?? item.primaryFieldId]);
+  }
+  return table.toString();
+}
+function flags(field, primaryFieldId) {
+  return [
+    field.id === primaryFieldId ? "primary" : "",
+    field.required ? "required" : "",
+    field.readonly ? "read-only" : "",
+    field.allowMultipleEntries ? "multiple" : ""
+  ].filter(Boolean).join(", ");
+}
+function renderTable(item) {
+  const fields = new import_cli_table32.default(plainTable(["ID", "Name", "Type", ""], [18, 30, 18, 30]));
+  for (const field of item.fields) {
+    fields.push([field.id, field.name, field.type, flags(field, item.primaryFieldId)]);
+  }
+  return [
+    `${item.name} (${item.id})`,
+    ...item.description ? [`  ${item.description}`] : [],
+    `  Default view: ${item.defaultViewId}`,
+    fields.toString()
+  ].join("\n");
+}
+function renderField(table, field) {
+  return [
+    `${field.name} (${field.id}) in ${table.name}`,
+    ...field.description ? [`  ${field.description}`] : [],
+    `  Type:    ${field.type}`,
+    ...flags(field, table.primaryFieldId) ? [`  Flags:   ${flags(field, table.primaryFieldId)}`] : [],
+    `  Options: ${JSON.stringify(field.options ?? null)}`
+  ].join("\n");
+}
+function renderViews(views) {
+  const table = new import_cli_table32.default(plainTable(["ID", "Name"], [18, 50]));
+  for (const view of views) {
+    table.push([view.id, view.name]);
+  }
+  return table.toString();
+}
+function registerTables(db2) {
+  const tables = db2.command("tables").description("The tables of a database, with their fields");
+  withDatabaseOptions(tables.command("list").description("List the tables of the database")).action(
+    async (opts, command) => {
+      const options = globalOptions(command);
+      const context = await schemaContext(opts);
+      const items = await currentTables(context, true);
+      emit(options, renderTables(items), { databaseId: context.databaseId, tables: items });
     }
-    const title = opts.title ?? entry.label;
-    const { inputs, codeFile } = await newNodeInputs(entry, id, title, opts.lang, dir);
-    const node = { id, title, type: entry.type, version: entry.version, inputs };
-    if (entry.kind === "trigger") {
-      if (opts.after || opts.inLoop) {
+  );
+  withDatabaseOptions(
+    tables.command("get").description("Show a table with its fields").argument("<table>", TABLE_ARGUMENT)
+  ).action(async (reference, opts, command) => {
+    const options = globalOptions(command);
+    const context = await schemaContext(opts);
+    const table = await findTable(context, reference, true);
+    emit(options, renderTable(table), { table });
+  });
+  withDatabaseOptions(
+    tables.command("create").description(
+      "Create a table with at least one field; the first one names a record unless --primary-field says otherwise"
+    ).argument("<name>", "the table name").option("--description <text>", "what the table holds").option(
+      "--field <name:TYPE>",
+      `a field to create with it, repeatable (types and their options: ${FIELD_REFERENCE_URL}); add fields with options through "softr db fields add"`,
+      (value, previous) => [...previous, value],
+      []
+    ).option("--primary-field <name>", "the field that names a record (default: the first field)")
+  ).action(
+    async (name, opts, command) => {
+      const options = globalOptions(command);
+      if (!opts.field.length) {
         throw new CliError(
-          "Triggers start the workflow: use --to <actionId> to connect one, not --after or --in-loop."
+          'A table needs at least one field: pass --field <name>:<TYPE>, for example --field "Name:SINGLE_LINE_TEXT".',
+          "Repeat --field for more; the first one names a record unless --primary-field names another."
         );
       }
-      if (opts.to && !taken.has(opts.to)) {
-        throw new CliError(`No node "${opts.to}" to connect to.`, `Known nodes: ${[...taken].join(", ")}`);
+      const fields = opts.field.map(parseFieldSpec);
+      if (opts.primaryField && !fields.some((field) => field.name === opts.primaryField)) {
+        throw new CliError(`--primary-field "${opts.primaryField}" is not one of the --field names.`);
       }
-      await editConfig(dir, [
-        { path: ["triggers", -1], value: node },
-        ...opts.to ? [{ path: ["paths", -1], value: { fromActionId: id, toActionId: opts.to } }] : []
-      ]);
-      const notes = [
-        (config.triggers?.length ?? 0) >= 1 ? "The service accepts one trigger per published workflow for now; multi-trigger support is coming." : "",
-        opts.to ? "" : `Connect it with a path to the first action (or pass --to next time).`,
-        `Then: softr workflows push, softr workflows test ${id}.`
-      ].filter(Boolean);
-      emitWithVersionNote(
-        options,
-        config,
-        `Added ${entry.type} trigger "${id}"${opts.to ? ` leading to "${opts.to}"` : ""}.
-${notes.join("\n")}`,
-        {
-          id,
-          kind: "trigger",
-          type: entry.type,
-          to: opts.to ?? null
-        }
-      );
-      return;
+      const context = await schemaContext(opts);
+      const table = await createTable(context.client, context.databaseId, {
+        name,
+        description: opts.description,
+        primaryFieldName: opts.primaryField ?? fields[0].name,
+        fields
+      });
+      await afterSchemaWrite(context);
+      emit(options, `Created table ${table.name} (${table.id}) with ${table.fields.length} fields.`, { table });
     }
-    if (opts.inLoop) {
-      const loop = [...allActions(config.actions)].find((candidate) => candidate.id === opts.inLoop);
-      if (!loop || loop.type !== LOOP_TYPE) {
-        throw new CliError(`"${opts.inLoop}" is not a loop in this workflow.`);
+  );
+  withDatabaseOptions(
+    tables.command("update").description("Change a table's name or description").argument("<table>", TABLE_ARGUMENT).option("--name <name>", "the new name").option("--description <text>", "the new description")
+  ).action(
+    async (reference, opts, command) => {
+      if (!opts.name && opts.description === void 0) {
+        throw new CliError("Nothing to change: pass --name, --description or both.");
       }
+      const options = globalOptions(command);
+      const context = await schemaContext(opts);
+      const current2 = await findTable(context, reference, true);
+      const table = await updateTable(context.client, context.databaseId, current2.id, {
+        name: opts.name ?? current2.name,
+        description: opts.description ?? current2.description
+      });
+      await afterSchemaWrite(context);
+      emit(options, `Updated table ${table.name} (${table.id}).`, { table });
     }
-    const after = opts.after ?? defaultAfter(config, opts.inLoop);
-    if (!taken.has(after)) {
-      throw new CliError(`No node "${after}" to attach to.`, `Known nodes: ${[...taken].join(", ")}`);
+  );
+  withDatabaseOptions(
+    tables.command("delete").description("Delete a table; one that still has records needs --force").argument("<table>", TABLE_ARGUMENT).option("--force", "also delete all its records")
+  ).action(async (reference, opts, command) => {
+    const options = globalOptions(command);
+    const context = await schemaContext(opts);
+    const table = await findTable(context, reference, true);
+    await deleteTable(context.client, context.databaseId, table.id, opts.force === true);
+    await afterSchemaWrite(context);
+    emit(options, `Deleted table ${table.name} (${table.id}).`, { deleted: table.id });
+  });
+}
+function registerFields(db2) {
+  const fields = db2.command("fields").description("The fields of a table");
+  withDatabaseOptions(
+    fields.command("get").description("Show a field with its options").argument("<table>", TABLE_ARGUMENT).argument("<field>", FIELD_ARGUMENT)
+  ).action(async (tableReference, reference, opts, command) => {
+    const options = globalOptions(command);
+    const context = await schemaContext(opts);
+    const { table, field } = await findField(context, tableReference, reference, true);
+    emit(options, renderField(table, field), { tableId: table.id, field });
+  });
+  withDatabaseOptions(
+    fields.command("add").description("Add a field to a table").argument("<table>", TABLE_ARGUMENT).argument("<name>", "the field name").requiredOption("--type <TYPE>", "the field type, for example SINGLE_LINE_TEXT, NUMBER, SELECT, LINKED_RECORD").option("--options <json>", `the type's options as JSON, @<file> or - for stdin (${FIELD_REFERENCE_URL})`).option("--description <text>", "what the field holds").option("--multiple", "allow several values (SELECT, LINKED_RECORD, USER, ATTACHMENT)")
+  ).action(
+    async (tableReference, name, opts, command) => {
+      const options = globalOptions(command);
+      const fieldOptions = await parseOptions(opts.options);
+      const context = await schemaContext(opts);
+      const table = await findTable(context, tableReference);
+      const field = await addField(context.client, context.databaseId, table.id, {
+        name,
+        type: opts.type.toUpperCase(),
+        description: opts.description,
+        ...fieldOptions === void 0 ? {} : { options: fieldOptions },
+        allowMultipleEntries: opts.multiple === true
+      });
+      await afterSchemaWrite(context);
+      emit(options, `Added field ${field.name} (${field.id}, ${field.type}) to ${table.name}.`, {
+        tableId: table.id,
+        field
+      });
     }
-    const loopIndex = opts.inLoop ? (config.actions ?? []).findIndex((action) => action.id === opts.inLoop) : -1;
-    const base = opts.inLoop && loopIndex >= 0 ? ["actions", loopIndex, "inputs"] : [];
-    await editConfig(dir, [
-      { path: [...base, "actions", -1], value: node },
-      { path: [...base, "paths", -1], value: { fromActionId: after, toActionId: id } }
-    ]);
-    const next = [
-      codeFile ? `Write the function in ${path9.relative(process.cwd(), codeFile)} and map its inputs under inputs.inputData in softr-workflows.jsonc.` : "",
-      entry.type === "BRANCH" || entry.type === "FILTER" ? `Add the condition(s) on the path(s) leaving it in softr-workflows.jsonc (see "spec ${entry.type}").` : "",
-      `Then: softr workflows push, softr workflows test ${id}.`
-    ].filter(Boolean);
-    emitWithVersionNote(
-      options,
-      config,
-      `Added ${entry.type} "${id}" after "${after}"${opts.inLoop ? ` inside loop "${opts.inLoop}"` : ""}.
-${next.join("\n")}`,
-      {
-        id,
-        kind: "action",
-        type: entry.type,
-        after,
-        loopId: opts.inLoop ?? null,
-        codeFile: codeFile ? path9.relative(process.cwd(), codeFile) : null
+  );
+  withDatabaseOptions(
+    fields.command("update").description("Change a field: what is not passed stays as it is").argument("<table>", TABLE_ARGUMENT).argument("<field>", FIELD_ARGUMENT).option("--name <name>", "the new name").option("--type <TYPE>", "the new type").option(
+      "--options <json>",
+      `the new options as JSON, @<file> or - for stdin, replacing the current ones (${FIELD_REFERENCE_URL})`
+    ).option("--description <text>", "the new description").option("--multiple", "allow several values").option("--no-multiple", "allow one value only")
+  ).action(
+    async (tableReference, reference, opts, command) => {
+      const fieldOptions = await parseOptions(opts.options);
+      if (!opts.name && !opts.type && fieldOptions === void 0 && opts.description === void 0 && opts.multiple === void 0) {
+        throw new CliError("Nothing to change: pass --name, --type, --options, --description or --[no-]multiple.");
       }
-    );
+      const options = globalOptions(command);
+      const context = await schemaContext(opts);
+      const { table, field: current2 } = await findField(context, tableReference, reference, true);
+      const field = await updateField(context.client, context.databaseId, table.id, current2.id, {
+        name: opts.name ?? current2.name,
+        type: opts.type?.toUpperCase() ?? current2.type,
+        description: opts.description ?? current2.description,
+        options: fieldOptions ?? current2.options,
+        aiOptions: current2.aiOptions ?? null,
+        defaultValue: current2.defaultValue ?? null,
+        allowMultipleEntries: opts.multiple ?? current2.allowMultipleEntries
+      });
+      await afterSchemaWrite(context);
+      emit(options, `Updated field ${field.name} (${field.id}, ${field.type}) in ${table.name}.`, {
+        tableId: table.id,
+        field
+      });
+    }
+  );
+  withDatabaseOptions(
+    fields.command("delete").description("Delete a field and its values in every record").argument("<table>", TABLE_ARGUMENT).argument("<field>", FIELD_ARGUMENT)
+  ).action(async (tableReference, reference, opts, command) => {
+    const options = globalOptions(command);
+    const context = await schemaContext(opts);
+    const { table, field } = await findField(context, tableReference, reference, true);
+    await deleteField(context.client, context.databaseId, table.id, field.id);
+    await afterSchemaWrite(context);
+    emit(options, `Deleted field ${field.name} (${field.id}) from ${table.name}.`, {
+      tableId: table.id,
+      deleted: field.id
+    });
+  });
+}
+function registerViews(db2) {
+  const views = db2.command("views").description("The views of a table");
+  withDatabaseOptions(
+    views.command("list").description("List the views of a table").argument("<table>", TABLE_ARGUMENT)
+  ).action(async (reference, opts, command) => {
+    const options = globalOptions(command);
+    const context = await schemaContext(opts);
+    const table = await findTable(context, reference, true);
+    const items = await listViews(context.client, context.databaseId, table.id);
+    if (context.dir) {
+      await writeViewsCache(context.dir, table.id, items);
+    }
+    emit(options, renderViews(items), { tableId: table.id, views: items });
   });
 }
 
-// src/commands/init.ts
-import path10 from "node:path";
-var TRIGGER_ID = "trigger";
-async function resolveWorkspace(client, requested) {
-  const workspaces = await listWorkspaces(client);
-  if (requested) {
-    if (!workspaces.some((workspace) => workspace.id === requested)) {
-      throw new CliError(
-        `You have no access to workspace ${requested}.`,
-        `Known workspaces: ${workspaces.map((w) => `${w.name} (${w.id})`).join(", ")}`
+// src/commands/db/records.ts
+var SEARCH_DOCS_URL = "https://docs.softr.io/softr-api/softr-database-api/records/search-records";
+var MAX_PAGE = 200;
+function withOutputOptions(command) {
+  return command.option("--field-ids", "key record fields by field id instead of field name");
+}
+function withPagingOptions(command) {
+  return command.option("--limit <n>", `records per page, 1 to ${MAX_PAGE} (default 20)`).option("--offset <n>", "records to skip (default 0)").option("--all", `every record, read in pages of ${MAX_PAGE}`);
+}
+function parseCount(value, option, max) {
+  if (value === void 0) {
+    return void 0;
+  }
+  const count = Number(value);
+  if (!Number.isInteger(count) || count < 0 || max !== void 0 && (count < 1 || count > max)) {
+    throw new CliError(`${option} must be a whole number${max ? ` from 1 to ${max}` : " of 0 or more"}.`);
+  }
+  return count;
+}
+function paging(opts) {
+  if (opts.all && opts.limit !== void 0) {
+    throw new CliError("Pass --all or --limit, not both.");
+  }
+  return {
+    offset: parseCount(opts.offset, "--offset") ?? 0,
+    limit: opts.all ? MAX_PAGE : parseCount(opts.limit, "--limit", MAX_PAGE) ?? 20,
+    all: opts.all === true
+  };
+}
+async function readPages(first, read) {
+  const page = await read(first.offset, first.limit);
+  if (!first.all) {
+    return page;
+  }
+  const records = [...page.records];
+  let offset2 = first.offset + page.records.length;
+  while (page.records.length && offset2 < page.metadata.total) {
+    const next = await read(offset2, first.limit);
+    if (!next.records.length) {
+      break;
+    }
+    records.push(...next.records);
+    offset2 += next.records.length;
+  }
+  return { records, metadata: { offset: first.offset, limit: records.length, total: page.metadata.total } };
+}
+function asObject(value, option) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    throw new CliError(`${option} must be a JSON object.`);
+  }
+  return value;
+}
+async function fieldIdsFor(context, table, references) {
+  const found = await findFields(context, table, references);
+  return { table: found.table, ids: new Map([...found.fields].map(([reference, field]) => [reference, field.id])) };
+}
+async function mapFieldKeys(context, table, fields) {
+  const { ids } = await fieldIdsFor(context, table, Object.keys(fields));
+  return Object.fromEntries(Object.entries(fields).map(([key, value]) => [ids.get(key), value]));
+}
+function fieldReferences(condition, found) {
+  if (Array.isArray(condition)) {
+    condition.forEach((item) => fieldReferences(item, found));
+  } else if (condition && typeof condition === "object") {
+    for (const [key, value] of Object.entries(condition)) {
+      if (key === "leftSide" && typeof value === "string") {
+        found.add(value);
+      } else {
+        fieldReferences(value, found);
+      }
+    }
+  }
+}
+function replaceFieldReferences(condition, ids) {
+  if (Array.isArray(condition)) {
+    return condition.map((item) => replaceFieldReferences(item, ids));
+  }
+  if (condition && typeof condition === "object") {
+    return Object.fromEntries(
+      Object.entries(condition).map(([key, value]) => [
+        key,
+        key === "leftSide" && typeof value === "string" ? ids.get(value) ?? value : replaceFieldReferences(value, ids)
+      ])
+    );
+  }
+  return condition;
+}
+function parseSort(spec) {
+  const colon = spec.lastIndexOf(":");
+  const direction = colon > 0 ? spec.slice(colon + 1).trim().toUpperCase() : "";
+  if (direction === "ASC" || direction === "DESC") {
+    return { field: spec.slice(0, colon).trim(), sortType: direction };
+  }
+  return { field: spec.trim(), sortType: "ASC" };
+}
+async function findView(context, table, reference) {
+  const fresh = async () => {
+    const views = await listViews(context.client, context.databaseId, table.id);
+    if (context.dir) {
+      await writeViewsCache(context.dir, table.id, views);
+    }
+    return views;
+  };
+  const cached = context.dir ? (await readViewsCache(context.dir, table.id))?.views : void 0;
+  const view = (cached ? byIdOrName(cached, reference, "view") : void 0) ?? byIdOrName(await fresh(), reference, "view");
+  if (!view) {
+    throw new CliError(
+      `Table ${table.name} has no view with the id or name "${reference}".`,
+      `"softr db views list ${table.id}" shows its views.`
+    );
+  }
+  return view;
+}
+function withFieldNames(record, table) {
+  const names2 = new Map(table.fields.map((field) => [field.id, field.name]));
+  return {
+    ...record,
+    fields: Object.fromEntries(Object.entries(record.fields).map(([key, value]) => [names2.get(key) ?? key, value]))
+  };
+}
+function formatValue(value) {
+  return typeof value === "string" ? value : JSON.stringify(value);
+}
+function renderRecord(record) {
+  return [record.id, ...Object.entries(record.fields).map(([key, value]) => `  ${key}: ${formatValue(value)}`)].join(
+    "\n"
+  );
+}
+function renderPage(page) {
+  if (!page.records.length) {
+    return page.metadata.total ? `No records from offset ${page.metadata.offset}; ${page.metadata.total} in all.` : "No records.";
+  }
+  const shown = page.records.length;
+  const end = page.metadata.offset + shown;
+  const footer = end < page.metadata.total ? `${shown} of ${page.metadata.total} records; --offset ${end} for the next ones, or --all.` : `${shown} of ${page.metadata.total} records.`;
+  return [...page.records.map(renderRecord), footer].join("\n\n");
+}
+function registerRecords(db2) {
+  const records = db2.command("records").description("The records of a table; fields are keyed by name unless --field-ids");
+  withOutputOptions(
+    withPagingOptions(
+      withDatabaseOptions(
+        records.command("list").description(
+          `List a table's records in the order and with the filter of a view, the table's default view unless --view; "records search" without --filter reads every record`
+        ).argument("<table>", TABLE_ARGUMENT).option("--view <view>", "the view id or exact name (default: the table's default view)")
+      )
+    )
+  ).action(
+    async (reference, opts, command) => {
+      const options = globalOptions(command);
+      const pages = paging(opts);
+      const context = await schemaContext(opts);
+      const table = await findTable(context, reference);
+      const viewId = opts.view ? (await findView(context, table, opts.view)).id : void 0;
+      const page = await readPages(
+        pages,
+        (offset2, limit) => listRecords(context.client, context.databaseId, table.id, {
+          viewId,
+          offset: offset2,
+          limit,
+          fieldNames: !opts.fieldIds
+        })
+      );
+      emit(options, renderPage(page), { tableId: table.id, ...page });
+    }
+  );
+  withOutputOptions(
+    withPagingOptions(
+      withDatabaseOptions(
+        records.command("search").description("Find records by a filter, sorted by fields").argument("<table>", TABLE_ARGUMENT).option(
+          "--filter <json>",
+          `the condition as JSON, @<file> or - for stdin; leftSide takes a field name or id (operators: ${SEARCH_DOCS_URL})`
+        ).option(
+          "--sort <field[:asc|desc]>",
+          "sort by a field, repeatable",
+          (value, previous) => [...previous, value],
+          []
+        )
+      )
+    )
+  ).action(
+    async (reference, opts, command) => {
+      const options = globalOptions(command);
+      const pages = paging(opts);
+      const parsed = opts.filter === void 0 ? void 0 : asObject(await readJsonArgument(opts.filter, "--filter"), "--filter");
+      const condition = parsed && "condition" in parsed ? parsed["condition"] : parsed;
+      const sorts = opts.sort.map(parseSort);
+      const context = await schemaContext(opts);
+      const references = new Set(sorts.map((sort) => sort.field));
+      fieldReferences(condition, references);
+      const { table, ids } = await fieldIdsFor(context, await findTable(context, reference), [...references]);
+      const search = (offset2, limit) => ({
+        paging: { offset: offset2, limit },
+        ...sorts.length ? { sorting: sorts.map((sort) => ({ sortingField: ids.get(sort.field), sortType: sort.sortType })) } : {},
+        ...condition === void 0 ? {} : { filter: { condition: replaceFieldReferences(condition, ids) } }
+      });
+      const page = await readPages(
+        pages,
+        (offset2, limit) => searchRecords(context.client, context.databaseId, table.id, search(offset2, limit), !opts.fieldIds)
+      );
+      emit(options, renderPage(page), { tableId: table.id, ...page });
+    }
+  );
+  withOutputOptions(
+    withDatabaseOptions(
+      records.command("get").description("Show one record").argument("<table>", TABLE_ARGUMENT).argument("<recordId>", "the record id")
+    )
+  ).action(async (reference, recordId, opts, command) => {
+    const options = globalOptions(command);
+    const context = await schemaContext(opts);
+    const table = await findTable(context, reference);
+    const record = await getRecord(context.client, context.databaseId, table.id, recordId, !opts.fieldIds);
+    emit(options, renderRecord(record), { tableId: table.id, record });
+  });
+  withOutputOptions(
+    withDatabaseOptions(
+      records.command("create").description("Create a record").argument("<table>", TABLE_ARGUMENT).requiredOption(
+        "--fields <json>",
+        "the values as a JSON object keyed by field name or id, @<file> or - for stdin; {} creates an empty record"
+      )
+    )
+  ).action(async (reference, opts, command) => {
+    const options = globalOptions(command);
+    const fields = asObject(await readJsonArgument(opts.fields, "--fields"), "--fields");
+    const context = await schemaContext(opts);
+    const table = await findTable(context, reference);
+    const record = await createRecord(
+      context.client,
+      context.databaseId,
+      table.id,
+      await mapFieldKeys(context, table, fields),
+      !opts.fieldIds
+    );
+    emit(options, `Created record ${record.id} in ${table.name}.`, { tableId: table.id, record });
+  });
+  withOutputOptions(
+    withDatabaseOptions(
+      records.command("update").description("Change some fields of a record; the others keep their values").argument("<table>", TABLE_ARGUMENT).argument("<recordId>", "the record id").requiredOption(
+        "--fields <json>",
+        "the new values as a JSON object keyed by field name or id, @<file> or - for stdin; null clears a field"
+      )
+    )
+  ).action(
+    async (reference, recordId, opts, command) => {
+      const options = globalOptions(command);
+      const fields = asObject(await readJsonArgument(opts.fields, "--fields"), "--fields");
+      if (!Object.keys(fields).length) {
+        throw new CliError("Nothing to change: --fields is an empty object.");
+      }
+      const context = await schemaContext(opts);
+      const table = await findTable(context, reference);
+      const record = await updateRecord(
+        context.client,
+        context.databaseId,
+        table.id,
+        recordId,
+        await mapFieldKeys(context, table, fields),
+        !opts.fieldIds
       );
+      emit(options, `Updated record ${record.id} in ${table.name}.`, { tableId: table.id, record });
     }
-    return requested;
-  }
-  if (workspaces.length === 1 && workspaces[0]) {
-    return workspaces[0].id;
-  }
-  const preferred = workspaces.find((workspace) => workspace.isDefault);
-  if (preferred) {
-    return preferred.id;
-  }
-  throw new CliError(
-    "Pass --workspace <id>: you have access to several workspaces.",
-    `Choose one of: ${workspaces.map((w) => `${w.name} (${w.id})`).join(", ")}`
   );
-}
-function registerInit(program3) {
-  program3.command("init").description("Create a new workflow with one trigger, on the server and as a local directory").argument("<title>", "the workflow title").option(
-    "--workspace <id>",
-    "workspace to create it in (default: $SOFTR_WORKSPACE_ID, else your only or default workspace)"
-  ).option("--pin-to-app <id>", "application to pin the workflow to (default: $SOFTR_PINNED_APP_ID when set)").option("--trigger <TYPE>", 'trigger type from "spec" (default WEBHOOK)', "WEBHOOK").option("--dir <path>", "directory to create (default: ./<title-slug>)").action(
-    async (title, opts, command) => {
+  withDatabaseOptions(
+    records.command("delete").description("Delete a record").argument("<table>", TABLE_ARGUMENT).argument("<recordId>", "the record id")
+  ).action(async (reference, recordId, opts, command) => {
+    const options = globalOptions(command);
+    const context = await schemaContext(opts);
+    const table = await findTable(context, reference, true);
+    await deleteRecord(context.client, context.databaseId, table.id, recordId);
+    emit(options, `Deleted record ${recordId} from ${table.name}.`, { tableId: table.id, deleted: recordId });
+  });
+  withOutputOptions(
+    withDatabaseOptions(
+      records.command("upload").description("Add a local file to a record's attachment field").argument("<table>", TABLE_ARGUMENT).argument("<recordId>", "the record id").argument("<field>", "the attachment field, by id or exact name").argument("<file>", "the file to upload").option("--name <fileName>", "the file name to store (default: the local file name)")
+    )
+  ).action(
+    async (reference, recordId, fieldReference, file, opts, command) => {
       const options = globalOptions(command);
-      const cwd = process.cwd();
-      const dir = path10.resolve(cwd, opts.dir ?? slug(title));
-      if (await configExists(dir)) {
-        throw new CliError(`${path10.join(dir, CONFIG_FILE_NAME)} already exists.`, "Pick another --dir or title.");
-      }
-      const trigger = findCatalogEntry(opts.trigger, "trigger");
-      const target = resolveTarget();
-      const client = await authenticatedClient(target);
-      const workspaceId = await resolveWorkspace(client, opts.workspace ?? process.env["SOFTR_WORKSPACE_ID"]);
-      const pinToApplicationId = opts.pinToApp ?? process.env["SOFTR_PINNED_APP_ID"];
-      const created = await createWorkflow(client, {
-        workspaceId,
-        applicationId: null,
-        ...pinToApplicationId ? { pinToApplicationId } : {},
-        title,
-        thumbnail: null,
-        triggers: [{ id: TRIGGER_ID, type: trigger.type, version: trigger.version, inputs: trigger.template }],
-        actions: [],
-        paths: [],
-        // Like the studio: the author's time zone, so schedules and waits mean what they read.
-        configuration: { timeZone: Intl.DateTimeFormat().resolvedOptions().timeZone || "UTC" }
+      let content;
+      try {
+        content = await readFile9(file);
+      } catch {
+        throw new CliError(`Cannot read ${file}.`);
+      }
+      const context = await schemaContext(opts);
+      const found = await fieldIdsFor(context, await findTable(context, reference), [fieldReference]);
+      const fieldId = found.ids.get(fieldReference);
+      const fieldType = found.table.fields.find((field) => field.id === fieldId)?.type;
+      if (fieldType !== "ATTACHMENT") {
+        throw new CliError(`Field "${fieldReference}" has the type ${fieldType}; upload needs an ATTACHMENT field.`);
+      }
+      const uploaded = await uploadAttachment(context.client, context.databaseId, found.table.id, recordId, fieldId, {
+        name: opts.name ?? path12.basename(file),
+        content
       });
-      const workflow = await getWorkflow(client, created.id);
-      const config = { $schema: SCHEMA_POINTER, ...toLocalConfig(workflow) };
-      const configFile = await writeConfig(dir, config);
-      await writeSchemaFile(dir);
-      const syncedHash = definitionHash((await packWorkflow(config, dir)).packed);
-      await writeState(dir, {
-        ...target,
-        workflowId: created.id,
-        version: workflow.version,
-        draft: workflow.draft,
-        syncedHash
+      const record = opts.fieldIds ? uploaded : withFieldNames(uploaded, found.table);
+      emit(options, `Uploaded ${opts.name ?? path12.basename(file)} to record ${record.id} in ${found.table.name}.`, {
+        tableId: found.table.id,
+        record
       });
-      const studioUrl = `${target.studioUrl}/workflow/${created.id}`;
-      emit(
-        options,
-        `Created "${title}" (${created.id}) with a ${trigger.type} trigger "${TRIGGER_ID}" in workspace ${workspaceId}${pinToApplicationId ? `, linked to application ${pinToApplicationId}` : ""}.
-  ${path10.relative(cwd, configFile)}
-${studioUrl}
-Next: softr workflows add <TYPE> --dir ${path10.relative(cwd, dir) || "."} (see "spec" for the types), then push and test.`,
-        {
-          workflowId: created.id,
-          workspaceId,
-          pinnedToApplicationId: pinToApplicationId ?? null,
-          title,
-          triggerId: TRIGGER_ID,
-          triggerType: trigger.type,
-          dir,
-          studioUrl
-        }
-      );
     }
   );
 }
 
 // src/commands/integrations.ts
-var import_cli_table32 = __toESM(require_cli_table3(), 1);
-import path11 from "node:path";
-function toRow2(integration) {
+var import_cli_table33 = __toESM(require_cli_table3(), 1);
+import path13 from "node:path";
+function toRow(integration) {
   return {
     id: integration.id,
     name: integration.name,
@@ -15368,7 +16330,7 @@ function renderIntegrations(rows) {
   if (!rows.length) {
     return "No integrations connected in this workspace. Connect one in the studio (Workspace settings > Integrations).";
   }
-  const table = new import_cli_table32.default({
+  const table = new import_cli_table33.default({
     head: ["ID", "Name", "Type", "Account", "Auth"],
     colWidths: [38, 34, 22, 30, 11],
     wordWrap: true,
@@ -15382,7 +16344,7 @@ Use the ID as the integrationId input of a node (see "spec <TYPE>").`;
 }
 async function workflowDirOf(cwd, dir) {
   if (dir) {
-    return path11.resolve(cwd, dir);
+    return path13.resolve(cwd, dir);
   }
   return await configExists(cwd) ? cwd : void 0;
 }
@@ -15399,7 +16361,7 @@ async function workspaceFor(client, requested, workflowDir) {
   return resolveWorkspace(client, void 0);
 }
 function registerIntegrations(program3) {
-  program3.command("integrations").description("List the workspace's connected integrations, whose ids go into integrationId inputs").option(
+  program3.command("integrations").description("List the workspace's connected integrations").option(
     "--workspace <id>",
     "workspace to list (default: $SOFTR_WORKSPACE_ID, else the workflow directory's, else your only or default workspace)"
   ).option("--type <TYPE>", "only this integration type, e.g. SLACK or SOFTR_TABLES").option("--dir <path>", "workflow directory whose workspace to use (default: the current directory)").action(async (opts, command) => {
@@ -15409,7 +16371,7 @@ function registerIntegrations(program3) {
     const client = await authenticatedClient(target);
     const workspaceId = await workspaceFor(client, opts.workspace ?? process.env["SOFTR_WORKSPACE_ID"], workflowDir);
     const wanted = opts.type?.toUpperCase();
-    const rows = (await listWorkspaceIntegrations(client, workspaceId)).map(toRow2).filter((row) => !wanted || row.type === wanted).sort(byTypeThenName);
+    const rows = (await listWorkspaceIntegrations(client, workspaceId)).map(toRow).filter((row) => !wanted || row.type === wanted).sort(byTypeThenName);
     emit(options, `Workspace ${workspaceId}${wanted ? `, type ${wanted}` : ""}:
 ${renderIntegrations(rows)}`, {
       workspaceId,
@@ -15419,6 +16381,105 @@ ${renderIntegrations(rows)}`, {
   });
 }
 
+// src/commands/list.ts
+var import_cli_table34 = __toESM(require_cli_table3(), 1);
+function toRow2(workflow, workspace) {
+  return {
+    id: workflow.id,
+    title: workflow.title,
+    workspaceId: workspace.id,
+    workspaceName: workspace.name,
+    live: workflow.enabledVersion ?? null,
+    version: workflow.version,
+    draft: workflow.draft,
+    updatedAt: workflow.updatedAt ?? null,
+    triggers: (workflow.triggerSummaries ?? []).map(({ id, type }) => ({ id, type }))
+  };
+}
+async function collectWorkflows(client, { workspaceId, applicationId } = {}) {
+  const workspaces = await listWorkspacesWith(client, WORKFLOWS_READ_SCOPE);
+  if (workspaceId) {
+    requireGrantedWorkspace(workspaces, workspaceId, WORKFLOWS_READ_SCOPE);
+  }
+  const selected = workspaceId ? workspaces.granted.filter((workspace) => workspace.id === workspaceId) : workspaces.granted;
+  const listing = { workspaces: [], workflows: [], failures: [] };
+  for (const workspace of selected) {
+    try {
+      const page = await listWorkflows(client, workspace.id, { applicationId });
+      listing.workspaces.push({ id: workspace.id, name: workspace.name });
+      listing.workflows.push(...page.items.map((workflow) => toRow2(workflow, workspace)));
+    } catch (error) {
+      if (!(error instanceof SoftrApiError) || selected.length === 1) {
+        throw error;
+      }
+      listing.failures.push({
+        workspaceId: workspace.id,
+        workspaceName: workspace.name,
+        status: error.status,
+        message: error.body
+      });
+    }
+  }
+  return listing;
+}
+var TITLE_WIDTH = 34;
+function workflowTable(rows) {
+  const table = new import_cli_table34.default({
+    head: ["ID", "Title", "Triggers", "Status", "Version", "Draft"],
+    // Only the free-text title wraps; the other columns size to their content, so trigger types are never cut off.
+    colWidths: [null, TITLE_WIDTH, null, null, null, null],
+    wordWrap: true,
+    style: { head: [], border: [], "padding-left": 1, "padding-right": 1 }
+  });
+  for (const row of rows) {
+    table.push([
+      row.id,
+      row.title,
+      row.triggers.map((trigger) => trigger.type).join("\n") || "-",
+      row.live === null ? "not enabled" : `live v${row.live}`,
+      row.version,
+      row.draft
+    ]);
+  }
+  return table.toString();
+}
+function renderWorkflows({ workspaces, workflows: workflows2, failures }) {
+  const blocks = [];
+  for (const workspace of workspaces) {
+    const rows = workflows2.filter((row) => row.workspaceId === workspace.id);
+    const heading = `Workspace: ${workspace.name} (${workspace.id})`;
+    blocks.push(rows.length ? `${heading}
+${workflowTable(rows)}` : `${heading}
+  (no workflows)`);
+  }
+  if (failures.length) {
+    blocks.push(
+      [
+        `Listing failed for ${failures.length} workspace${failures.length === 1 ? "" : "s"} (skipped):`,
+        ...failures.map(
+          (failure) => `  ${failure.workspaceName} (${failure.workspaceId}): status ${failure.status}${failure.message ? `: ${failure.message}` : ""}`
+        )
+      ].join("\n")
+    );
+  }
+  return blocks.join("\n\n");
+}
+async function emitWorkflowList(options, client, { workspaceId, applicationId, human } = {}) {
+  const listing = await collectWorkflows(client, { workspaceId, applicationId });
+  emit(options, [human, renderWorkflows(listing)].filter(Boolean).join("\n\n"), { ...listing });
+}
+function registerList(program3) {
+  program3.command("list").description("List the workflows you can access, grouped by workspace").option("--workspace <id>", "only this workspace (default: $SOFTR_WORKSPACE_ID when set)").option("--app <id>", "only the workflows linked to this application").action(async (opts, command) => {
+    const options = globalOptions(command);
+    const target = resolveTarget(await readState(process.cwd()));
+    const client = await authenticatedClient(target);
+    await emitWorkflowList(options, client, {
+      workspaceId: opts.workspace ?? process.env["SOFTR_WORKSPACE_ID"],
+      applicationId: opts.app
+    });
+  });
+}
+
 // src/commands/login.ts
 import { execFile } from "node:child_process";
 import { createServer } from "node:http";
@@ -15431,10 +16492,10 @@ async function identify(client) {
   return { userId: owner.id, email: owner.email, statements: owner.statements };
 }
 function scopeWarning(identity) {
-  if (grantsWorkflows(identity.statements)) {
+  if (grantsWorkflows(identity.statements) || grantsDatabases(identity.statements)) {
     return "";
   }
-  return "\nWarning: this token grants no workflows action (workflows:read, workflows:write, workflows:execute); most commands will be refused.";
+  return "\nWarning: this token grants no workflows action (workflows:read, workflows:write, workflows:execute) and no databases action (databases.records:read, databases.records:write, databases.schema:write); most commands will be refused.";
 }
 async function interactiveLogin(target) {
   if (!stdin.isTTY) {
@@ -15684,7 +16745,7 @@ ${identity.statements.map((s) => `  ${s.actions.join(", ")} on ${s.resources.joi
 }
 
 // src/commands/outputs.ts
-var import_cli_table34 = __toESM(require_cli_table3(), 1);
+var import_cli_table36 = __toESM(require_cli_table3(), 1);
 
 // src/project/test-state.ts
 function outdatedReferences(row) {
@@ -15697,28 +16758,28 @@ function renderIssues(issues) {
 
 // src/project/variables.ts
 var MAX_VARIABLES = 200;
-function appendKey(path13, key) {
-  return /^[A-Za-z_]\w*$/.test(key) ? `${path13}.${key}` : `${path13}['${key.replace(/\\/g, "\\\\").replace(/'/g, "\\'")}']`;
+function appendKey(path16, key) {
+  return /^[A-Za-z_]\w*$/.test(key) ? `${path16}.${key}` : `${path16}['${key.replace(/\\/g, "\\\\").replace(/'/g, "\\'")}']`;
 }
 function isPrimitive2(value) {
   return value !== void 0 && value !== null && typeof value !== "object";
 }
-function walk(type, raw, path13, token, out) {
+function walk(type, raw, path16, token, out) {
   if (out.length >= MAX_VARIABLES) {
     return;
   }
-  out.push({ variable: token(path13), path: path13, type, ...isPrimitive2(raw) ? { example: raw } : {} });
+  out.push({ variable: token(path16), path: path16, type, ...isPrimitive2(raw) ? { example: raw } : {} });
   if (type.kind === "object") {
     for (const [key, field] of Object.entries(type.fields)) {
       const rawField = raw !== null && typeof raw === "object" && !Array.isArray(raw) ? raw[key] : void 0;
-      walk(field.type, rawField, appendKey(path13, key), token, out);
+      walk(field.type, rawField, appendKey(path16, key), token, out);
     }
   } else if (type.kind === "array") {
-    walk(type.items, Array.isArray(raw) ? raw[0] : void 0, `${path13}[*]`, token, out);
+    walk(type.items, Array.isArray(raw) ? raw[0] : void 0, `${path16}[*]`, token, out);
   }
 }
 function collectVariables(nodeId, sample, metadata) {
-  const token = (path13) => `{outputs.${nodeId}:::${path13}}`;
+  const token = (path16) => `{outputs.${nodeId}:::${path16}}`;
   const variables = [];
   if (sample !== void 0 && sample !== null) {
     walk(typeOfJson(sample), sample, "$", token, variables);
@@ -15733,7 +16794,7 @@ function collectVariables(nodeId, sample, metadata) {
 }
 
 // src/commands/test.ts
-var import_cli_table33 = __toESM(require_cli_table3(), 1);
+var import_cli_table35 = __toESM(require_cli_table3(), 1);
 var OUTPUTS_FILE = "outputs.json";
 function fieldCount(row) {
   const output = row.sampleOutput?.result?.output;
@@ -15834,7 +16895,7 @@ var LABEL = {
   error: "ERROR"
 };
 function renderResults(results) {
-  const table = new import_cli_table33.default({
+  const table = new import_cli_table35.default({
     head: ["Result", "Node", "Type", "Detail"],
     colWidths: [9, 30, 24, 60],
     wordWrap: true,
@@ -15950,7 +17011,7 @@ function sampleState(row) {
   }
 }
 function renderVariables(nodeId, entries, unverified) {
-  const table = new import_cli_table34.default({
+  const table = new import_cli_table36.default({
     head: ["Variable", "Type", "Example"],
     colWidths: [64, 32, 44],
     wordWrap: true,
@@ -16018,7 +17079,7 @@ function registerOutputs(program3) {
         outdated: Object.keys(outdatedReferences(row))
       };
     });
-    const table = new import_cli_table34.default({
+    const table = new import_cli_table36.default({
       head: ["Node", "Type", "Sample", "Fields"],
       colWidths: [30, 24, 60, 8],
       wordWrap: true,
@@ -16050,19 +17111,19 @@ function pathFromKeys(keys) {
     const only = keys[0].trim();
     return only.startsWith("$") ? only : `$${only.startsWith("[") ? "" : "."}${only}`;
   }
-  let path13 = "$";
+  let path16 = "$";
   for (const key of keys) {
     if (key === "*") {
-      path13 += "[*]";
+      path16 += "[*]";
     } else if (/^\d+$/.test(key)) {
-      path13 += `[${key}]`;
+      path16 += `[${key}]`;
     } else if (/^[A-Za-z_]\w*$/.test(key)) {
-      path13 += `.${key}`;
+      path16 += `.${key}`;
     } else {
-      path13 += `['${key.replace(/\\/g, "\\\\").replace(/'/g, "\\'")}']`;
+      path16 += `['${key.replace(/\\/g, "\\\\").replace(/'/g, "\\'")}']`;
     }
   }
-  return path13;
+  return path16;
 }
 function keysAt(type) {
   switch (type.kind) {
@@ -16087,12 +17148,12 @@ function registerPlaceholder(program3) {
     }
     const rows = await readStateFile(dir, OUTPUTS_FILE) ?? [];
     const outputs = indexOutputs(rows);
-    const path13 = pathFromKeys(keys);
-    if (!parsePath(path13)) {
-      throw new CliError(`Cannot read the path "${path13}".`);
+    const path16 = pathFromKeys(keys);
+    if (!parsePath(path16)) {
+      throw new CliError(`Cannot read the path "${path16}".`);
     }
     const isLoop = location.node.type === LOOP_TYPE;
-    const token = isLoop ? `{loopActionGroup.${nodeId}:::loopVariables.items${path13 === "$" ? "" : path13.slice(1)}}` : `{outputs.${nodeId}:::${path13}}`;
+    const token = isLoop ? `{loopActionGroup.${nodeId}:::loopVariables.items${path16 === "$" ? "" : path16.slice(1)}}` : `{outputs.${nodeId}:::${path16}}`;
     const [description] = describeInputData(
       { id: "probe", type: "CUSTOM_CODE", inputs: { inputData: { probe: token } } },
       config,
@@ -16102,7 +17163,7 @@ function registerPlaceholder(program3) {
       throw new CliError("Could not evaluate the token.");
     }
     if (description.type.kind === "unknown") {
-      const segments = parsePath(path13) ?? [];
+      const segments = parsePath(path16) ?? [];
       let hint = description.note ?? "not found";
       const row = outputs[nodeId];
       if (row?.hasSample && segments.length) {
@@ -16128,7 +17189,7 @@ function registerPlaceholder(program3) {
     emit(options, `${token}
 type: ${type}${example3}  (${status})`, {
       token,
-      path: path13,
+      path: path16,
       type,
       example: description.example ?? null,
       verified: description.verified,
@@ -16137,6 +17198,84 @@ type: ${type}${example3}  (${status})`, {
   });
 }
 
+// src/commands/pull.ts
+import path14 from "node:path";
+async function targetDir(cwd, explicitDir, workflowId, title) {
+  if (explicitDir) {
+    return path14.resolve(cwd, explicitDir);
+  }
+  if (await configExists(cwd)) {
+    const existing = await readConfig(cwd);
+    if (existing.id && existing.id !== workflowId) {
+      throw new CliError(
+        `${CONFIG_FILE_NAME} here belongs to workflow ${existing.id}, not ${workflowId}.`,
+        "Run pull from the parent directory (a new subdirectory is created) or pass --dir."
+      );
+    }
+    return cwd;
+  }
+  return path14.join(cwd, slug(title));
+}
+function registerPull(program3) {
+  program3.command("pull").description("Download a workflow into softr-workflows.jsonc and one code file per custom code node").argument("[workflowId]", "the workflow id (last segment of its studio URL); omit to list what you can pull").option("--dir <path>", "target directory (default: this directory if it holds the workflow, else ./<title-slug>)").option("--force", "overwrite an existing softr-workflows.jsonc and its code files").action(async (workflowId, opts, command) => {
+    const options = globalOptions(command);
+    const cwd = process.cwd();
+    const remembered = await readState(opts.dir ? path14.resolve(cwd, opts.dir) : cwd);
+    const target = resolveTarget(remembered);
+    const client = await authenticatedClient(target);
+    if (!workflowId) {
+      await emitWorkflowList(options, client, {
+        human: "Pick a workflow and run: softr workflows pull <workflowId>"
+      });
+      return;
+    }
+    const workflow = await getWorkflow(client, workflowId);
+    const dir = await targetDir(cwd, opts.dir, workflowId, workflow.title);
+    if (await configExists(dir) && !opts.force) {
+      throw new CliError(
+        `${path14.join(dir, CONFIG_FILE_NAME)} already exists.`,
+        "Pass --force to overwrite it and its code files."
+      );
+    }
+    let rows = [];
+    let outputsNote = "";
+    let outputsFile;
+    try {
+      rows = await getWorkflowOutputs(client, workflowId);
+    } catch (error) {
+      outputsNote = `
+Sample outputs not available, inputData types are unknown: ${error.message}`;
+    }
+    const config = { $schema: SCHEMA_POINTER, ...toLocalConfig(workflow) };
+    const codeFiles = await externalizeCode(config, dir, indexOutputs(rows));
+    await writeSchemaFile(dir);
+    const configFile2 = await writeConfig(dir, config);
+    const syncedHash = definitionHash((await packWorkflow(config, dir)).packed);
+    await writeState(dir, { ...target, workflowId, version: workflow.version, draft: workflow.draft, syncedHash });
+    if (!outputsNote) {
+      outputsFile = await writeStateFile(dir, "outputs.json", rows);
+    }
+    const files = [configFile2, ...codeFiles].map((file) => path14.relative(cwd, file));
+    emitWithVersionNote(
+      options,
+      config,
+      `Pulled "${workflow.title}" (version ${workflow.version}, draft ${workflow.draft}, ${workflow.enabled ? "enabled" : "not enabled"}).
+` + files.map((file) => `  ${file}`).join("\n") + outputsNote,
+      {
+        workflowId,
+        apiUrl: target.apiUrl,
+        title: workflow.title,
+        version: workflow.version,
+        draft: workflow.draft,
+        enabled: workflow.enabled ?? false,
+        dir,
+        files,
+        outputsFile: outputsFile ?? null
+      }
+    );
+  });
+}
+
 // src/commands/publish.ts
 import { stdin as stdin2, stdout } from "node:process";
 import { createInterface as createInterface2 } from "node:readline/promises";
@@ -16374,23 +17513,23 @@ function registerPin(program3) {
 }
 
 // src/commands/push.ts
-import path12 from "node:path";
+import path15 from "node:path";
 
 // src/project/placeholder-check.ts
 var TOKEN = /\{(?:outputs|loopActionGroup)\.[^:{}]+:::[^{}]*\}/g;
-function* stringsIn(value, path13) {
+function* stringsIn(value, path16) {
   if (typeof value === "string") {
-    yield [path13, value];
+    yield [path16, value];
   } else if (Array.isArray(value)) {
     for (const [index, item] of value.entries()) {
-      yield* stringsIn(item, `${path13}[${index}]`);
+      yield* stringsIn(item, `${path16}[${index}]`);
     }
   } else if (value !== null && typeof value === "object") {
     for (const [key, item] of Object.entries(value)) {
       if (key === "actions" || key === "paths") {
         continue;
       }
-      yield* stringsIn(item, path13 ? `${path13}.${key}` : key);
+      yield* stringsIn(item, path16 ? `${path16}.${key}` : key);
     }
   }
 }
@@ -16501,7 +17640,7 @@ ${unbacked.map(
         draft: result.draft,
         inlined,
         studioUrl,
-        dir: path12.resolve(dir),
+        dir: path15.resolve(dir),
         unbackedPlaceholders: unbacked
       }
     );
@@ -16509,10 +17648,10 @@ ${unbacked.map(
 }
 
 // src/commands/spec.ts
-var import_cli_table35 = __toESM(require_cli_table3(), 1);
+var import_cli_table37 = __toESM(require_cli_table3(), 1);
 var TABLE_STYLE2 = { head: [], border: [], "padding-left": 1, "padding-right": 1 };
 function renderList() {
-  const table = new import_cli_table35.default({
+  const table = new import_cli_table37.default({
     head: ["Type", "Kind", "Label", "Summary"],
     colWidths: [40, 9, 24, 70],
     wordWrap: true,
@@ -16540,7 +17679,7 @@ function renderEntry(entry) {
   const blocks = [`${entry.type} (${entry.kind}) \u2014 ${entry.label}`, entry.summary, `Docs: ${entry.docs}`];
   const inputs = Object.entries(entry.inputs);
   if (inputs.length) {
-    const table = new import_cli_table35.default({
+    const table = new import_cli_table37.default({
       head: ["Input", "Type", "Required", "Description"],
       colWidths: [20, 9, 10, 90],
       wordWrap: true,
@@ -16790,21 +17929,27 @@ ${item.lines.map((line) => `       ${line}`).join("\n")}`
 }
 
 // src/commands/workspaces.ts
-var import_cli_table36 = __toESM(require_cli_table3(), 1);
+var import_cli_table38 = __toESM(require_cli_table3(), 1);
 function registerWorkspaces(program3) {
-  program3.command("workspaces").description("The workspaces the stored token reaches, with your role in each").action(async (_opts, command) => {
+  program3.command("workspaces").description("The workspaces the stored token reaches, with your role and the scopes the token grants in each").action(async (_opts, command) => {
     const options = globalOptions(command);
     const target = resolveTarget();
     const client = await authenticatedClient(target);
     const workspaces = await listWorkspaces(client);
-    const table = new import_cli_table36.default({
-      head: ["ID", "Name", "Role", "Default"],
-      colWidths: [38, 34, 14, 9],
+    const table = new import_cli_table38.default({
+      head: ["ID", "Name", "Role", "Default", "Scopes"],
+      colWidths: [38, 26, 10, 9, 34],
       wordWrap: true,
       style: { head: [], border: [], "padding-left": 1, "padding-right": 1 }
     });
     for (const workspace of workspaces) {
-      table.push([workspace.id, workspace.name, workspace.userRole ?? "", workspace.isDefault ? "yes" : ""]);
+      table.push([
+        workspace.id,
+        workspace.name,
+        workspace.userRole ?? "",
+        workspace.isDefault ? "yes" : "",
+        (workspace.scopes ?? []).join(", ")
+      ]);
     }
     emit(
       options,
@@ -16818,11 +17963,12 @@ Pass --workspace <id> to a command, or set SOFTR_WORKSPACE_ID, to work in one of
 // package.json
 var package_default = {
   name: "@softr/cli",
-  version: "0.1.3",
-  description: "The Softr command line: build, test and publish Softr workflows from local files; more Softr APIs to come",
+  version: "0.1.6-se21219.17",
+  description: "The Softr command line: build, test and publish Softr workflows from local files, manage Softr Databases; more Softr APIs to come",
   keywords: [
     "softr",
     "workflows",
+    "databases",
     "cli"
   ],
   license: "UNLICENSED",
@@ -16845,7 +17991,7 @@ var package_default = {
     format: "prettier --write .",
     "format:check": "prettier --check .",
     check: "npm run typecheck && npm run format:check && npm test && npm run build",
-    "check:skill": "npx -y skills-ref@0.1.5 validate skills/softr-cli && npx -y skills-ref@0.1.5 validate skills/softr-workflows"
+    "check:skill": "npx -y skills-ref@0.1.5 validate skills/softr-cli && npx -y skills-ref@0.1.5 validate skills/softr-workflows && npx -y skills-ref@0.1.5 validate skills/softr-db"
   },
   publishConfig: {
     access: "public"
@@ -16868,7 +18014,7 @@ var package_default = {
 };
 
 // src/cli.ts
-var program2 = new Command().name("softr").description("The Softr command line: workflows today, more of Softr to come").version(package_default.version).option("--json", "print results as JSON");
+var program2 = new Command().name("softr").description("The Softr command line: workflows and databases today, more of Softr to come").version(package_default.version).option("--json", "print results as JSON");
 registerLogin(program2);
 registerWorkspaces(program2);
 registerIntegrations(program2);
@@ -16888,4 +18034,10 @@ registerPublish(workflows);
 registerPin(workflows);
 registerSpec(workflows);
 registerSchema(workflows);
+var db = program2.command("db").description("Manage Softr Databases: databases, their tables, fields and records");
+registerDatabases(db);
+registerTables(db);
+registerFields(db);
+registerViews(db);
+registerRecords(db);
 program2.parseAsync(process.argv).catch(reportError);