@softr/cli 0.1.4 → 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 Table8 = 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;
       }
     };
-    Table8.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 = Table8;
+    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(path15) {
-    if (path15 === void 0) return this._executableDir;
-    this._executableDir = path15;
+  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;
   }
   /**
@@ -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 path15 of pathSets.flat()) {
-    const to = path15.toActionId;
-    if (!to || !nodes.has(path15.fromActionId) || !nodes.has(to) || outgoing.get(path15.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(path15.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);
@@ -6130,43 +6130,45 @@ var BASE_URLS = {
   studio: (target) => target.studioApiUrl,
   tables: (target) => target.tablesApiUrl
 };
-async function send(client, service, method, path15, body) {
+async function send(client, service, method, path16, body) {
   const init = {
     method,
     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 response = await fetch(`${BASE_URLS[service](client.target)}${path15}`, 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} ${path15} failed with status ${response.status}${text ? `: ${text}` : ""}`,
+    `${method} ${path16} failed with status ${response.status}${text ? `: ${text}` : ""}`,
     response.status,
     text,
     hintFor(response.status, client, service)
   );
 }
-async function apiRequest(client, method, path15, body) {
-  const response = await send(client, "workflows", method, path15, 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, path15, body) {
-  await send(client, "workflows", method, path15, body);
+async function apiRequestVoid(client, method, path16, body) {
+  await send(client, "workflows", method, path16, body);
 }
-async function tablesRequest(client, method, path15, body) {
-  const response = await send(client, "tables", method, path15, body);
+async function tablesRequest(client, method, path16, body) {
+  const response = await send(client, "tables", method, path16, body);
   return await response.json();
 }
-async function tablesRequestVoid(client, method, path15, body) {
-  await send(client, "tables", method, path15, body);
+async function tablesRequestVoid(client, method, path16, body) {
+  await send(client, "tables", method, path16, body);
 }
-async function studioRequest(client, method, path15, body) {
-  const response = await send(client, "studio", method, path15, body);
+async function studioRequest(client, method, path16, body) {
+  const response = await send(client, "studio", method, path16, body);
   return await response.json();
 }
 
@@ -6177,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}
@@ -6989,12 +6994,12 @@ function parseTree(text, errors = [], options = ParseOptions.DEFAULT) {
   }
   return result;
 }
-function findNodeAtLocation(root, path15) {
+function findNodeAtLocation(root, path16) {
   if (!root) {
     return void 0;
   }
   let node = root;
-  for (let segment of path15) {
+  for (let segment of path16) {
     if (typeof segment === "string") {
       if (node.type !== "object" || !Array.isArray(node.children)) {
         return void 0;
@@ -7348,14 +7353,14 @@ function getNodeType(value) {
 
 // node_modules/jsonc-parser/lib/esm/impl/edit.js
 function setProperty(text, originalPath, value, options) {
-  const path15 = originalPath.slice();
+  const path16 = originalPath.slice();
   const errors = [];
   const root = parseTree(text, errors);
   let parent = void 0;
   let lastSegment = void 0;
-  while (path15.length > 0) {
-    lastSegment = path15.pop();
-    parent = findNodeAtLocation(root, path15);
+  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 };
@@ -7578,8 +7583,8 @@ function printParseErrorCode(code) {
   }
   return "<unknown ParseErrorCode>";
 }
-function modify(text, path15, value, options) {
-  return setProperty(text, path15, 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) => {
@@ -7636,8 +7641,8 @@ function parseJsoncFile(file, text) {
 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 flags = await Promise.all(dirs.map((dir) => holds(dir)));
-  return dirs.filter((_, index) => flags[index]);
+  const flags2 = await Promise.all(dirs.map((dir) => holds(dir)));
+  return dirs.filter((_, index) => flags2[index]);
 }
 async function readConfig(dir) {
   const file = configPath(dir);
@@ -8284,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;
@@ -8305,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;
@@ -8317,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;
     }
   }
@@ -8326,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;
@@ -11111,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();
@@ -11334,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;
@@ -11416,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") {
@@ -13036,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;
@@ -13590,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(path15) {
-  let rest = path15.trim();
+function parsePath(path16) {
+  let rest = path16.trim();
   if (rest.startsWith("$")) {
     rest = rest.slice(1);
   }
@@ -14091,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, path15, source, outputs) {
-  const segments = parsePath(path15);
+function describeOutputRef(nodeId, path16, source, outputs) {
+  const segments = parsePath(path16);
   if (!segments) {
-    return { type: UNKNOWN, source, verified: false, note: `unsupported path "${path15}"` };
+    return { type: UNKNOWN, source, verified: false, note: `unsupported path "${path16}"` };
   }
   const row = outputs[nodeId];
   if (!row) {
@@ -14575,6 +14580,103 @@ async function deleteDatabase(client, databaseId, force) {
 async function listTables(client, databaseId) {
   return (await tablesRequest(client, "GET", `${DATABASES}/${encodeURIComponent(databaseId)}/tables`)).data;
 }
+function tablePath(databaseId, tableId) {
+  const tables = `${DATABASES}/${encodeURIComponent(databaseId)}/tables`;
+  return tableId ? `${tables}/${encodeURIComponent(tableId)}` : tables;
+}
+async function createTable(client, databaseId, table) {
+  return (await tablesRequest(client, "POST", tablePath(databaseId), table)).data;
+}
+async function updateTable(client, databaseId, tableId, table) {
+  return (await tablesRequest(client, "PUT", tablePath(databaseId, tableId), table)).data;
+}
+async function deleteTable(client, databaseId, tableId, force) {
+  await tablesRequestVoid(client, "DELETE", `${tablePath(databaseId, tableId)}${force ? "?force=true" : ""}`);
+}
+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";
@@ -14612,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 path15 = "/v1/oauth/token";
-  const response = await fetch(`${target.studioApiUrl}${path15}`, {
+  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()
@@ -14621,7 +14723,7 @@ async function tokenRequest(target, form) {
   if (!response.ok) {
     const text = await response.text();
     throw new SoftrApiError(
-      `POST ${path15} 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
@@ -14791,8 +14893,26 @@ async function authenticatedClient(target) {
 }
 
 // src/project/db-dir.ts
-import { mkdir as mkdir5, readFile as readFile6, rm, writeFile as writeFile6 } from "node:fs/promises";
+import { mkdir as mkdir5, readdir as readdir2, readFile as readFile6, rm, writeFile as writeFile6 } from "node:fs/promises";
 import path8 from "node:path";
+
+// 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";
@@ -14841,8 +14961,41 @@ 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;
 }
+function viewsDir(dir) {
+  return path8.join(dir, DB_CACHE_DIR_NAME, "views");
+}
+async function readViewsCache(dir, tableId) {
+  try {
+    return JSON.parse(await readFile6(path8.join(viewsDir(dir), `${tableId}.json`), "utf8"));
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return void 0;
+    }
+    throw error;
+  }
+}
+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");
+}
+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 refreshSchemaCache(client, dir, databaseId) {
   const [database, tables] = await Promise.all([getDatabase(client, databaseId), listTables(client, databaseId)]);
   return writeSchemaCache(dir, database, tables);
@@ -14903,25 +15056,19 @@ async function databaseDirFor(cwd, explicitDir, databaseId, dirName) {
   return { dir: sibling2, existing: false };
 }
 async function findReachableDatabase(client, reference) {
-  const reachable = await listDatabases(client);
-  const byId = reachable.find((database) => database.id === reference);
-  if (byId) {
-    return byId;
-  }
-  const byName = reachable.filter((database) => database.name === reference);
-  if (byName.length > 1) {
-    throw new CliError(
-      `Several databases are named "${reference}".`,
-      `Pass the id of one: ${byName.map((database) => `${database.id} (workspace ${database.workspaceId})`).join(", ")}`
-    );
-  }
-  if (!byName[0]) {
+  const database = byIdOrName(
+    await listDatabases(client),
+    reference,
+    "database",
+    (item) => `${item.id} (workspace ${item.workspaceId})`
+  );
+  if (!database) {
     throw new CliError(
       `The token reaches no database with the id or name "${reference}".`,
       '"softr db list" shows the ones it reaches.'
     );
   }
-  return byName[0];
+  return database;
 }
 async function bindDatabaseDir(client, cwd, reference, explicitDir) {
   const here = path8.resolve(cwd, explicitDir ?? ".");
@@ -14944,6 +15091,10 @@ async function bindDatabaseDir(client, cwd, reference, explicitDir) {
   return { databaseId: database.id, dir, wrote: !existing };
 }
 
+// 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 {
@@ -15420,18 +15571,11 @@ Next: softr workflows add <TYPE> --dir ${path10.relative(cwd, dir) || "."} (see
 }
 
 // src/commands/db/databases.ts
-var DATABASE_ARGUMENT = `the database id (default: $SOFTR_DATABASE_ID, else the one in ${DB_CONFIG_FILE_NAME})`;
-var DIR_OPTION = `database directory, the one holding ${DB_CONFIG_FILE_NAME} (default: the current directory)`;
 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({
-    head: ["ID", "Name", "Workspace", "Tables"],
-    colWidths: [38, 34, 38, 8],
-    wordWrap: true,
-    style: { head: [], border: [], "padding-left": 1, "padding-right": 1 }
-  });
+  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)]);
   }
@@ -15502,7 +15646,7 @@ Wrote ${path11.join(relativeDir(cwd, dir), DB_CONFIG_FILE_NAME)}.` : "";
       );
     }
   );
-  db2.command("update").description("Change a database's name or description").argument("[databaseId]", DATABASE_ARGUMENT).option("--name <name>", "the new name").option("--description <text>", "the new description").option("--dir <path>", DIR_OPTION).action(
+  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.");
@@ -15521,7 +15665,7 @@ Wrote ${path11.join(relativeDir(cwd, dir), DB_CONFIG_FILE_NAME)}.` : "";
       emit(options, `Updated database ${database.name} (${database.id}).`, { database });
     }
   );
-  db2.command("delete").description("Delete a database; one that still has tables needs --force").argument("[databaseId]", DATABASE_ARGUMENT).option("--force", "also delete its tables and all their records").option("--dir <path>", DIR_OPTION).action(async (databaseId, opts, command) => {
+  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());
@@ -15538,9 +15682,637 @@ ${path11.join(relativeDir(process.cwd(), target.dir), DB_CONFIG_FILE_NAME)} stil
   });
 }
 
-// src/commands/integrations.ts
-var import_cli_table32 = __toESM(require_cli_table3(), 1);
+// 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");
+  }
+  try {
+    return JSON.parse(text);
+  } catch {
+    throw new CliError(`${option} is not valid JSON.`, hint ?? "Pass inline JSON, @<file> or - for stdin.");
+  }
+}
+
+// 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 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.`
+    );
+  }
+  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);
+  }
+}
+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 });
+    }
+  );
+  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(
+          '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."
+        );
+      }
+      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.`);
+      }
+      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 });
+    }
+  );
+  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 });
+    }
+  );
+  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
+      });
+    }
+  );
+  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/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 });
+    }
+  );
+  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);
+      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 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
+      });
+    }
+  );
+}
+
+// src/commands/integrations.ts
+var import_cli_table33 = __toESM(require_cli_table3(), 1);
+import path13 from "node:path";
 function toRow(integration) {
   return {
     id: integration.id,
@@ -15558,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,
@@ -15572,7 +16344,7 @@ Use the ID as the integrationId input of a node (see "spec <TYPE>").`;
 }
 async function workflowDirOf(cwd, dir) {
   if (dir) {
-    return path12.resolve(cwd, dir);
+    return path13.resolve(cwd, dir);
   }
   return await configExists(cwd) ? cwd : void 0;
 }
@@ -15610,7 +16382,7 @@ ${renderIntegrations(rows)}`, {
 }
 
 // src/commands/list.ts
-var import_cli_table33 = __toESM(require_cli_table3(), 1);
+var import_cli_table34 = __toESM(require_cli_table3(), 1);
 function toRow2(workflow, workspace) {
   return {
     id: workflow.id,
@@ -15652,7 +16424,7 @@ async function collectWorkflows(client, { workspaceId, applicationId } = {}) {
 }
 var TITLE_WIDTH = 34;
 function workflowTable(rows) {
-  const table = new import_cli_table33.default({
+  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],
@@ -15973,7 +16745,7 @@ ${identity.statements.map((s) => `  ${s.actions.join(", ")} on ${s.resources.joi
 }
 
 // src/commands/outputs.ts
-var import_cli_table35 = __toESM(require_cli_table3(), 1);
+var import_cli_table36 = __toESM(require_cli_table3(), 1);
 
 // src/project/test-state.ts
 function outdatedReferences(row) {
@@ -15986,28 +16758,28 @@ function renderIssues(issues) {
 
 // src/project/variables.ts
 var MAX_VARIABLES = 200;
-function appendKey(path15, key) {
-  return /^[A-Za-z_]\w*$/.test(key) ? `${path15}.${key}` : `${path15}['${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, path15, token, out) {
+function walk(type, raw, path16, token, out) {
   if (out.length >= MAX_VARIABLES) {
     return;
   }
-  out.push({ variable: token(path15), path: path15, 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(path15, 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, `${path15}[*]`, token, out);
+    walk(type.items, Array.isArray(raw) ? raw[0] : void 0, `${path16}[*]`, token, out);
   }
 }
 function collectVariables(nodeId, sample, metadata) {
-  const token = (path15) => `{outputs.${nodeId}:::${path15}}`;
+  const token = (path16) => `{outputs.${nodeId}:::${path16}}`;
   const variables = [];
   if (sample !== void 0 && sample !== null) {
     walk(typeOfJson(sample), sample, "$", token, variables);
@@ -16022,7 +16794,7 @@ function collectVariables(nodeId, sample, metadata) {
 }
 
 // src/commands/test.ts
-var import_cli_table34 = __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;
@@ -16123,7 +16895,7 @@ var LABEL = {
   error: "ERROR"
 };
 function renderResults(results) {
-  const table = new import_cli_table34.default({
+  const table = new import_cli_table35.default({
     head: ["Result", "Node", "Type", "Detail"],
     colWidths: [9, 30, 24, 60],
     wordWrap: true,
@@ -16239,7 +17011,7 @@ function sampleState(row) {
   }
 }
 function renderVariables(nodeId, entries, unverified) {
-  const table = new import_cli_table35.default({
+  const table = new import_cli_table36.default({
     head: ["Variable", "Type", "Example"],
     colWidths: [64, 32, 44],
     wordWrap: true,
@@ -16307,7 +17079,7 @@ function registerOutputs(program3) {
         outdated: Object.keys(outdatedReferences(row))
       };
     });
-    const table = new import_cli_table35.default({
+    const table = new import_cli_table36.default({
       head: ["Node", "Type", "Sample", "Fields"],
       colWidths: [30, 24, 60, 8],
       wordWrap: true,
@@ -16339,19 +17111,19 @@ function pathFromKeys(keys) {
     const only = keys[0].trim();
     return only.startsWith("$") ? only : `$${only.startsWith("[") ? "" : "."}${only}`;
   }
-  let path15 = "$";
+  let path16 = "$";
   for (const key of keys) {
     if (key === "*") {
-      path15 += "[*]";
+      path16 += "[*]";
     } else if (/^\d+$/.test(key)) {
-      path15 += `[${key}]`;
+      path16 += `[${key}]`;
     } else if (/^[A-Za-z_]\w*$/.test(key)) {
-      path15 += `.${key}`;
+      path16 += `.${key}`;
     } else {
-      path15 += `['${key.replace(/\\/g, "\\\\").replace(/'/g, "\\'")}']`;
+      path16 += `['${key.replace(/\\/g, "\\\\").replace(/'/g, "\\'")}']`;
     }
   }
-  return path15;
+  return path16;
 }
 function keysAt(type) {
   switch (type.kind) {
@@ -16376,12 +17148,12 @@ function registerPlaceholder(program3) {
     }
     const rows = await readStateFile(dir, OUTPUTS_FILE) ?? [];
     const outputs = indexOutputs(rows);
-    const path15 = pathFromKeys(keys);
-    if (!parsePath(path15)) {
-      throw new CliError(`Cannot read the path "${path15}".`);
+    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${path15 === "$" ? "" : path15.slice(1)}}` : `{outputs.${nodeId}:::${path15}}`;
+    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,
@@ -16391,7 +17163,7 @@ function registerPlaceholder(program3) {
       throw new CliError("Could not evaluate the token.");
     }
     if (description.type.kind === "unknown") {
-      const segments = parsePath(path15) ?? [];
+      const segments = parsePath(path16) ?? [];
       let hint = description.note ?? "not found";
       const row = outputs[nodeId];
       if (row?.hasSample && segments.length) {
@@ -16417,7 +17189,7 @@ function registerPlaceholder(program3) {
     emit(options, `${token}
 type: ${type}${example3}  (${status})`, {
       token,
-      path: path15,
+      path: path16,
       type,
       example: description.example ?? null,
       verified: description.verified,
@@ -16427,10 +17199,10 @@ type: ${type}${example3}  (${status})`, {
 }
 
 // src/commands/pull.ts
-import path13 from "node:path";
+import path14 from "node:path";
 async function targetDir(cwd, explicitDir, workflowId, title) {
   if (explicitDir) {
-    return path13.resolve(cwd, explicitDir);
+    return path14.resolve(cwd, explicitDir);
   }
   if (await configExists(cwd)) {
     const existing = await readConfig(cwd);
@@ -16442,13 +17214,13 @@ async function targetDir(cwd, explicitDir, workflowId, title) {
     }
     return cwd;
   }
-  return path13.join(cwd, slug(title));
+  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 ? path13.resolve(cwd, opts.dir) : cwd);
+    const remembered = await readState(opts.dir ? path14.resolve(cwd, opts.dir) : cwd);
     const target = resolveTarget(remembered);
     const client = await authenticatedClient(target);
     if (!workflowId) {
@@ -16461,7 +17233,7 @@ function registerPull(program3) {
     const dir = await targetDir(cwd, opts.dir, workflowId, workflow.title);
     if (await configExists(dir) && !opts.force) {
       throw new CliError(
-        `${path13.join(dir, CONFIG_FILE_NAME)} already exists.`,
+        `${path14.join(dir, CONFIG_FILE_NAME)} already exists.`,
         "Pass --force to overwrite it and its code files."
       );
     }
@@ -16483,7 +17255,7 @@ Sample outputs not available, inputData types are unknown: ${error.message}`;
     if (!outputsNote) {
       outputsFile = await writeStateFile(dir, "outputs.json", rows);
     }
-    const files = [configFile2, ...codeFiles].map((file) => path13.relative(cwd, file));
+    const files = [configFile2, ...codeFiles].map((file) => path14.relative(cwd, file));
     emitWithVersionNote(
       options,
       config,
@@ -16741,23 +17513,23 @@ function registerPin(program3) {
 }
 
 // src/commands/push.ts
-import path14 from "node:path";
+import path15 from "node:path";
 
 // src/project/placeholder-check.ts
 var TOKEN = /\{(?:outputs|loopActionGroup)\.[^:{}]+:::[^{}]*\}/g;
-function* stringsIn(value, path15) {
+function* stringsIn(value, path16) {
   if (typeof value === "string") {
-    yield [path15, value];
+    yield [path16, value];
   } else if (Array.isArray(value)) {
     for (const [index, item] of value.entries()) {
-      yield* stringsIn(item, `${path15}[${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, path15 ? `${path15}.${key}` : key);
+      yield* stringsIn(item, path16 ? `${path16}.${key}` : key);
     }
   }
 }
@@ -16868,7 +17640,7 @@ ${unbacked.map(
         draft: result.draft,
         inlined,
         studioUrl,
-        dir: path14.resolve(dir),
+        dir: path15.resolve(dir),
         unbackedPlaceholders: unbacked
       }
     );
@@ -16876,10 +17648,10 @@ ${unbacked.map(
 }
 
 // src/commands/spec.ts
-var import_cli_table36 = __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_table36.default({
+  const table = new import_cli_table37.default({
     head: ["Type", "Kind", "Label", "Summary"],
     colWidths: [40, 9, 24, 70],
     wordWrap: true,
@@ -16907,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_table36.default({
+    const table = new import_cli_table37.default({
       head: ["Input", "Type", "Required", "Description"],
       colWidths: [20, 9, 10, 90],
       wordWrap: true,
@@ -17157,14 +17929,14 @@ ${item.lines.map((line) => `       ${line}`).join("\n")}`
 }
 
 // src/commands/workspaces.ts
-var import_cli_table37 = __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 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_table37.default({
+    const table = new import_cli_table38.default({
       head: ["ID", "Name", "Role", "Default", "Scopes"],
       colWidths: [38, 26, 10, 9, 34],
       wordWrap: true,
@@ -17191,7 +17963,7 @@ 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.4",
+  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",
@@ -17219,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"
@@ -17264,4 +18036,8 @@ 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);