@base44-preview/cli 0.1.8-pr.589.9d22ef2 → 0.1.9-pr.595.21d640d

package/dist/cli/index.js

@@ -247201,24 +247201,33 @@ var ResourceSourceSchema = exports_external.discriminatedUnion("type", [
 ]);
 
 // src/core/resources/entity/schema.ts
-var FieldConditionSchema = exports_external.union([
-  exports_external.string(),
-  exports_external.number(),
-  exports_external.boolean(),
-  exports_external.null(),
-  exports_external.looseObject({
-    $in: exports_external.unknown().optional(),
-    $nin: exports_external.unknown().optional(),
-    $ne: exports_external.unknown().optional(),
-    $all: exports_external.unknown().optional()
-  })
+var fieldConditionOperators = new Set([
+  "$eq",
+  "$ne",
+  "$in",
+  "$nin",
+  "$gt",
+  "$gte",
+  "$lt",
+  "$lte",
+  "$exists",
+  "$all",
+  "$size",
+  "$elemMatch"
 ]);
-var userConditionAllowedKeys = new Set(["role", "email", "id"]);
-var UserConditionSchema = exports_external.looseObject({
-  role: exports_external.string().optional(),
-  email: exports_external.string().optional(),
-  id: exports_external.string().optional()
-}).refine((val) => Object.keys(val).every((key) => userConditionAllowedKeys.has(key) || key.startsWith("data.")), "Keys must be role, email, id, or match data.* pattern");
+var isScalar = (value) => value === null || ["string", "number", "boolean"].includes(typeof value);
+var isValidFieldCondition = (value) => {
+  if (isScalar(value)) {
+    return true;
+  }
+  if (typeof value === "object" && !Array.isArray(value)) {
+    return Object.keys(value).every((k2) => fieldConditionOperators.has(k2));
+  }
+  return false;
+};
+var supportedOperators = [...fieldConditionOperators].sort().join(", ");
+var FieldConditionSchema = exports_external.union([exports_external.string(), exports_external.number(), exports_external.boolean(), exports_external.null(), exports_external.looseObject({})]).refine(isValidFieldCondition, `Field condition values must be a primitive or an operator object (${supportedOperators})`);
+var UserConditionSchema = exports_external.looseObject({}).refine((val) => Object.keys(val).length > 0 && Object.entries(val).every(([key, value]) => !key.startsWith("$") && isScalar(value)), "user_condition compares user attributes by exact equality: a non-empty object of attribute: scalar pairs, no operators");
 var rlsConditionAllowedKeys = new Set([
   "user_condition",
   "created_by",
@@ -247250,18 +247259,13 @@ var RLSConditionSchema = exports_external.looseObject({
     return exports_external.array(RefineRLSConditionSchema).optional();
   }
 });
-var fieldConditionOperators = new Set(["$in", "$nin", "$ne", "$all"]);
-var isValidFieldCondition = (value) => {
-  if (value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
-    return true;
-  }
-  if (typeof value === "object") {
-    return Object.keys(value).every((k2) => fieldConditionOperators.has(k2));
-  }
-  return false;
-};
-var RefineRLSConditionSchema = RLSConditionSchema.refine((val) => Object.entries(val).every(([key, value]) => rlsConditionAllowedKeys.has(key) || isValidFieldCondition(value)), "Field condition values must be a primitive or an operator object ($in, $nin, $ne, $all)");
-var RLSRuleSchema = exports_external.union([exports_external.boolean(), RefineRLSConditionSchema]);
+var RefineRLSConditionSchema = RLSConditionSchema.refine((val) => Object.entries(val).every(([key, value]) => rlsConditionAllowedKeys.has(key) || isValidFieldCondition(value)), `Field condition values must be a primitive or an operator object (${supportedOperators})`);
+var RLSRuleSchema = exports_external.union([
+  exports_external.boolean(),
+  exports_external.null(),
+  exports_external.literal(""),
+  RefineRLSConditionSchema
+]);
 var EntityRLSSchema = exports_external.looseObject({
   create: RLSRuleSchema.optional(),
   read: RLSRuleSchema.optional(),
@@ -247277,7 +247281,7 @@ var FieldRLSSchema = exports_external.looseObject({
   delete: RLSRuleSchema.optional()
 });
 var PropertyDefinitionSchema = exports_external.looseObject({
-  type: exports_external.string(),
+  type: exports_external.union([exports_external.string(), exports_external.array(exports_external.string())]),
   title: exports_external.string().optional(),
   description: exports_external.string().optional(),
   minLength: exports_external.number().int().min(0).optional(),
@@ -247301,7 +247305,7 @@ var PropertyDefinitionSchema = exports_external.looseObject({
 });
 var EntitySchema = exports_external.looseObject({
   type: exports_external.literal("object").default("object"),
-  name: exports_external.string().min(1).regex(/^[a-zA-Z0-9]+$/, "Entity name must be alphanumeric only"),
+  name: exports_external.string().min(1).regex(/^\w+$/, "Entity name must contain only letters, numbers, and underscores"),
   title: exports_external.string().optional(),
   description: exports_external.string().optional(),
   properties: exports_external.record(exports_external.string(), PropertyDefinitionSchema).default({}),
@@ -247868,13 +247872,145 @@ var functionResource = {
   readAll: readAllFunctions,
   push: (functions) => deployFunctionsSequentially(functions)
 };
+// src/core/resources/function/stream-api.ts
+var StreamLogEventSchema = exports_external.object({
+  time: exports_external.string(),
+  level: exports_external.preprocess((value) => value === "warn" ? "warning" : value, LogLevelSchema),
+  function: exports_external.string().nullable(),
+  message: exports_external.string()
+});
+var StreamEndEventSchema = exports_external.object({
+  reason: exports_external.string(),
+  retriable: exports_external.boolean()
+});
+function buildStreamUrl(filters) {
+  const { id } = getAppContext();
+  const url2 = new URL(`/api/apps/${id}/functions-mgmt/logs/stream`, getBase44ApiUrl());
+  if (filters.functions?.length) {
+    url2.searchParams.set("function", filters.functions.join(","));
+  }
+  if (filters.env) {
+    url2.searchParams.set("env", filters.env);
+  }
+  return url2.href;
+}
+async function buildStreamAuthHeaders() {
+  const workspaceApiKey = getWorkspaceApiKeyFromEnv();
+  if (workspaceApiKey && isWorkspaceApiKey(workspaceApiKey)) {
+    return { api_key: workspaceApiKey };
+  }
+  const auth = await readAuth();
+  if (isTokenExpired(auth)) {
+    const refreshedToken = await refreshAndSaveTokens();
+    if (refreshedToken) {
+      return { Authorization: `Bearer ${refreshedToken}` };
+    }
+  }
+  return { Authorization: `Bearer ${auth.accessToken}` };
+}
+function parseStreamEvent(eventName, data) {
+  try {
+    const payload = JSON.parse(data);
+    if (eventName === "end") {
+      const result = StreamEndEventSchema.safeParse(payload);
+      return result.success ? { kind: "end", end: result.data } : null;
+    }
+    if (eventName === "") {
+      const result = StreamLogEventSchema.safeParse(payload);
+      return result.success ? { kind: "log", log: result.data } : null;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+var STREAM_SILENCE_TIMEOUT_MS = 60000;
+async function readOrSilence(reader) {
+  let timer;
+  const silence = new Promise((resolve3) => {
+    timer = setTimeout(() => resolve3("silence"), STREAM_SILENCE_TIMEOUT_MS);
+  });
+  try {
+    return await Promise.race([reader.read(), silence]);
+  } finally {
+    clearTimeout(timer);
+  }
+}
+async function* readLines(body) {
+  const reader = body.getReader();
+  const decoder = new TextDecoder;
+  let buffered = "";
+  try {
+    while (true) {
+      const result = await readOrSilence(reader);
+      if (result === "silence") {
+        await reader.cancel();
+        return;
+      }
+      if (result.done || !result.value)
+        return;
+      buffered += decoder.decode(result.value, { stream: true });
+      const lines = buffered.split(`
+`);
+      buffered = lines.pop() ?? "";
+      yield* lines;
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}
+async function* readStreamEvents(body) {
+  let eventName = "";
+  for await (const line of readLines(body)) {
+    if (line.startsWith("event:")) {
+      eventName = line.slice(6).trim();
+      continue;
+    }
+    if (line.startsWith("data:")) {
+      const event = parseStreamEvent(eventName, line.slice(5));
+      eventName = "";
+      if (event)
+        yield event;
+      continue;
+    }
+    if (line.trim() === "")
+      eventName = "";
+  }
+}
+var STREAM_CONNECT_TIMEOUT_MS = 1e4;
+async function openLogStream(filters) {
+  const connectPhase = new AbortController;
+  const connectTimer = setTimeout(() => connectPhase.abort(), STREAM_CONNECT_TIMEOUT_MS);
+  let response;
+  try {
+    response = await fetch(buildStreamUrl(filters), {
+      headers: {
+        Accept: "text/event-stream",
+        ...await buildStreamAuthHeaders()
+      },
+      signal: connectPhase.signal
+    });
+  } catch {
+    return null;
+  } finally {
+    clearTimeout(connectTimer);
+  }
+  if (!response.ok || !response.body)
+    return null;
+  return readStreamEvents(response.body);
+}
 // src/core/project/config.ts
 class ProjectConfigReader {
   pluginSourceByNamespace = new Map;
-  async readProjectConfig(projectRoot) {
+  async readProjectSettings(projectRoot) {
     const { root, configPath } = await this.findConfigOrThrow(projectRoot);
     const project = await this.readConfigFile(configPath);
     this.assertPluginProjectDoesNotLoadPlugins(project, configPath);
+    return { ...project, root, configPath };
+  }
+  async readProjectConfig(projectRoot) {
+    const project = await this.readProjectSettings(projectRoot);
+    const { configPath } = project;
     const localResources = await this.readProjectResources(configPath, project);
     const pluginResources = await this.readPlugins(project.plugins, configPath);
     const entities = mergeProjectAndPluginEntities(localResources.entities, pluginResources.entities, configPath);
@@ -247884,7 +248020,7 @@ class ProjectConfigReader {
     ];
     this.validateFunctionNames(functions, configPath);
     return {
-      project: { ...project, root, configPath },
+      project,
       entities,
       functions,
       agents: localResources.agents,
@@ -248022,6 +248158,10 @@ async function readProjectConfig(projectRoot) {
   const reader = new ProjectConfigReader;
   return await reader.readProjectConfig(projectRoot);
 }
+async function readProjectSettings(projectRoot) {
+  const reader = new ProjectConfigReader;
+  return await reader.readProjectSettings(projectRoot);
+}
 // src/core/project/template.ts
 var import_ejs = __toESM(require_ejs(), 1);
 var import_front_matter2 = __toESM(require_front_matter(), 1);
@@ -248034,7 +248174,7 @@ import { join as join12 } from "node:path";
 // package.json
 var package_default = {
   name: "base44",
-  version: "0.1.8",
+  version: "0.1.9",
   description: "Base44 CLI - Unified interface for managing Base44 applications",
   type: "module",
   bin: {
@@ -248335,7 +248475,9 @@ async function deploySite(siteOutputDir) {
   if (!await pathExists(siteOutputDir)) {
     throw new InvalidInputError(`Output directory does not exist: ${siteOutputDir}. Make sure to build your project first.`, {
       hints: [
-        { message: "Run your build command (e.g., 'npm run build') first" }
+        {
+          message: "Run 'base44 build' first (it injects your app id; a bare 'npm run build' does not)"
+        }
       ]
     });
   }
@@ -248343,7 +248485,9 @@ async function deploySite(siteOutputDir) {
   if (filePaths.length === 0) {
     throw new ConfigInvalidError(`No files found in output directory: ${siteOutputDir}. Make sure to build your project first.`, siteOutputDir, {
       hints: [
-        { message: "Run your build command (e.g., 'npm run build') first" }
+        {
+          message: "Run 'base44 build' first (it injects your app id; a bare 'npm run build' does not)"
+        }
       ]
     });
   }
@@ -255586,6 +255730,14 @@ function writeJsonError(error48) {
       envelope.hints = error48.hints;
     }
   }
+  if (error48 instanceof ApiError) {
+    if (error48.statusCode !== undefined) {
+      envelope.statusCode = error48.statusCode;
+    }
+    if (error48.requestId !== undefined) {
+      envelope.requestId = error48.requestId;
+    }
+  }
   process.stdout.write(`${JSON.stringify(envelope)}
 `);
 }
@@ -255682,6 +255834,18 @@ async function confirmPush({
   });
   return !Ct(proceed) && proceed;
 }
+// src/cli/utils/datetime.ts
+var import_ms2 = __toESM(require_ms(), 1);
+var HAS_TIMEZONE_SUFFIX = /Z$|[+-]\d{2}:\d{2}$/;
+function normalizeDatetime(value) {
+  const duration3 = import_ms2.default(value);
+  if (duration3 !== undefined) {
+    return new Date(Date.now() - duration3).toISOString();
+  }
+  if (HAS_TIMEZONE_SUFFIX.test(value))
+    return value;
+  return `${value}Z`;
+}
 // src/cli/utils/json.ts
 function toJsonStdout(result) {
   return `${JSON.stringify(result, null, 2)}
@@ -257539,8 +257703,8 @@ function getDeleteCommand() {
 }
 
 // src/cli/commands/functions/formatDeployResult.ts
-function formatDuration(ms) {
-  return `${(ms / 1000).toFixed(1)}s`;
+function formatDuration(ms2) {
+  return `${(ms2 / 1000).toFixed(1)}s`;
 }
 function formatDeployResult(result, log) {
   const label = result.name.padEnd(25);
@@ -257873,7 +258037,11 @@ async function completeProjectSetup({
       const { appUrl } = await runTask2("Installing dependencies...", async (updateMessage) => {
         await execa({ cwd: resolvedPath, shell: true })`${installCommand}`;
         updateMessage("Building project...");
-        await execa({ cwd: resolvedPath, shell: true })`${buildCommand}`;
+        await execa({
+          cwd: resolvedPath,
+          shell: true,
+          env: { VITE_BASE44_APP_ID: projectId }
+        })`${buildCommand}`;
         updateMessage("Deploying site...");
         return await deploySite(join25(resolvedPath, outputDirectory));
       }, {
@@ -258353,7 +258521,6 @@ function getLinkCommand() {
 }
 
 // src/cli/commands/project/logs.ts
-var import_ms2 = __toESM(require_ms(), 1);
 function parseFunctionFilters(options) {
   const filters = {};
   if (options.since) {
@@ -258381,15 +258548,6 @@ function parseFunctionNames(option) {
     return [];
   return option.split(",").map((s) => s.trim()).filter((s) => s.length > 0);
 }
-function normalizeDatetime(value) {
-  const duration3 = import_ms2.default(value);
-  if (duration3 !== undefined) {
-    return new Date(Date.now() - duration3).toISOString();
-  }
-  if (/Z$|[+-]\d{2}:\d{2}$/.test(value))
-    return value;
-  return `${value}Z`;
-}
 function formatEntry(entry) {
   const time3 = entry.time.substring(0, 19).replace("T", " ");
   const level = entry.level.toUpperCase().padEnd(5);
@@ -258423,9 +258581,73 @@ function writeFollowLine(entry, jsonMode) {
   process.stdout.write(`${line}
 `);
 }
-async function followLogs(functionNames, options, availableFunctionNames, jsonMode) {
-  let state = { lastTime: "", boundaryKeys: new Set };
-  let first = true;
+var delay2 = (ms2) => new Promise((resolve9) => setTimeout(resolve9, ms2));
+function streamEventToLogEntry(event) {
+  return {
+    time: event.time,
+    level: event.level,
+    message: event.function ? `[${event.function}] ${event.message}` : event.message,
+    source: event.function ?? ""
+  };
+}
+async function printStreamUntilEnd(stream, levelFilter, jsonMode, startTime) {
+  let lastTime = startTime;
+  let producedEvents = false;
+  try {
+    for await (const event of stream) {
+      producedEvents = true;
+      if (event.kind === "end")
+        return { lastTime, producedEvents, end: event.end };
+      if (levelFilter && event.log.level !== levelFilter)
+        continue;
+      writeFollowLine(streamEventToLogEntry(event.log), jsonMode);
+      if (event.log.time > lastTime)
+        lastTime = event.log.time;
+    }
+  } catch {}
+  return { lastTime, producedEvents, end: null };
+}
+var STREAM_RECONNECT_DELAY_MS = 1000;
+var MAX_DROPS_SINCE_LAST_EVENT = 2;
+async function streamUntilExhausted(options, jsonMode) {
+  const filters = {
+    functions: parseFunctionNames(options.function),
+    env: options.env
+  };
+  let everConnected = false;
+  let lastTime = "";
+  let dropsSinceLastEvent = 0;
+  while (true) {
+    const stream = await openLogStream(filters);
+    if (!stream)
+      break;
+    everConnected = true;
+    const ending = await printStreamUntilEnd(stream, options.level, jsonMode, lastTime);
+    lastTime = ending.lastTime;
+    if (ending.end) {
+      if (!ending.end.retriable)
+        break;
+      dropsSinceLastEvent = 0;
+    } else {
+      dropsSinceLastEvent = ending.producedEvents ? 1 : dropsSinceLastEvent + 1;
+      if (dropsSinceLastEvent >= MAX_DROPS_SINCE_LAST_EVENT)
+        break;
+    }
+    await delay2(STREAM_RECONNECT_DELAY_MS);
+  }
+  return { everConnected, lastTime };
+}
+async function followLogs(functionNames, options, availableFunctionNames, jsonMode, logger2) {
+  const { everConnected, lastTime } = await streamUntilExhausted(options, jsonMode);
+  logger2.warn(everConnected ? "Realtime stream disconnected — falling back to polling (lines may lag ~20-30s)." : "Realtime stream unavailable — falling back to polling (lines may lag ~20-30s).");
+  return pollLogs(functionNames, options, availableFunctionNames, jsonMode, {
+    lastTime,
+    boundaryKeys: new Set
+  });
+}
+async function pollLogs(functionNames, options, availableFunctionNames, jsonMode, initialState) {
+  let state = initialState;
+  let first = state.lastTime === "";
   while (true) {
     const pollOptions = first ? options : { ...options, since: state.lastTime };
     const entries = await fetchLogsForFunctions(functionNames, pollOptions, availableFunctionNames);
@@ -258435,7 +258657,7 @@ async function followLogs(functionNames, options, availableFunctionNames, jsonMo
     for (const entry of fresh)
       writeFollowLine(entry, jsonMode);
     first = false;
-    await new Promise((resolve9) => setTimeout(resolve9, 2000));
+    await delay2(2000);
   }
 }
 function formatLogs(entries, env3) {
@@ -258521,6 +258743,9 @@ async function logsAction(ctx, options) {
     };
   }
   if (options.follow) {
+    if (options.since) {
+      throw new InvalidInputError("--since cannot be combined with --follow yet (the realtime stream starts from now).");
+    }
     if (options.until) {
       throw new InvalidInputError("--until cannot be combined with --follow (a stream has no end).");
     }
@@ -258528,7 +258753,7 @@ async function logsAction(ctx, options) {
       throw new InvalidInputError("--order cannot be combined with --follow (a live tail always streams oldest to newest).");
     }
     options.order = "asc";
-    return followLogs(functionNames, options, availableFunctionNames, ctx.jsonMode);
+    return followLogs(functionNames, options, availableFunctionNames, ctx.jsonMode, ctx.log);
   }
   let entries = await fetchLogsForFunctions(functionNames, options, availableFunctionNames);
   const limit = options.limit ? Number.parseInt(options.limit, 10) : undefined;
@@ -259030,7 +259255,7 @@ async function deployAction2(ctx, options) {
   if (isNonInteractive && !options.yes) {
     throw new InvalidInputError("--yes is required in non-interactive mode");
   }
-  const { project: project2 } = await readProjectConfig();
+  const project2 = await readProjectSettings();
   const outputDirectory = project2.site?.outputDirectory;
   if (!outputDirectory) {
     throw new ConfigNotFoundError("No site configuration found.", {
@@ -259267,6 +259492,235 @@ function getTypesCommand() {
   return new Command("types").description("Manage TypeScript type generation").addCommand(getTypesGenerateCommand());
 }
 
+// src/core/resources/workflow/schema.ts
+var WorkflowRunStatusSchema = exports_external.enum([
+  "running",
+  "completed",
+  "failed",
+  "cancelled"
+]);
+var WorkflowListItemSchema = exports_external.object({
+  id: exports_external.string(),
+  name: exports_external.string(),
+  description: exports_external.string().nullable().optional(),
+  status: exports_external.string(),
+  status_reason: exports_external.string().nullable().optional(),
+  total_runs: exports_external.number().default(0),
+  consecutive_failures: exports_external.number().default(0),
+  last_run_at: exports_external.string().nullable().optional(),
+  last_run_status: exports_external.string().nullable().optional()
+}).transform((data) => ({
+  id: data.id,
+  name: data.name,
+  description: data.description ?? null,
+  status: data.status,
+  statusReason: data.status_reason ?? null,
+  totalRuns: data.total_runs,
+  consecutiveFailures: data.consecutive_failures,
+  lastRunAt: data.last_run_at ?? null,
+  lastRunStatus: data.last_run_status ?? null
+}));
+var ListWorkflowsResponseSchema = exports_external.array(WorkflowListItemSchema);
+var WorkflowRunSchema = exports_external.object({
+  run_id: exports_external.string(),
+  workflow_id: exports_external.string(),
+  workflow_name: exports_external.string().default(""),
+  trigger_type: exports_external.string().default(""),
+  status: exports_external.string(),
+  started_at: exports_external.string().nullable().optional(),
+  completed_at: exports_external.string().nullable().optional(),
+  duration_ms: exports_external.number().default(0),
+  steps_count: exports_external.number().default(0),
+  error_message: exports_external.string().nullable().optional(),
+  is_test_run: exports_external.boolean().default(false),
+  status_reason: exports_external.string().default("")
+}).transform((data) => ({
+  runId: data.run_id,
+  workflowId: data.workflow_id,
+  workflowName: data.workflow_name,
+  triggerType: data.trigger_type,
+  status: data.status,
+  startedAt: data.started_at ?? null,
+  completedAt: data.completed_at ?? null,
+  durationMs: data.duration_ms,
+  stepsCount: data.steps_count,
+  errorMessage: data.error_message ?? null,
+  isTestRun: data.is_test_run,
+  statusReason: data.status_reason
+}));
+var ListWorkflowRunsResponseSchema = exports_external.array(WorkflowRunSchema);
+
+// src/core/resources/workflow/api.ts
+async function listWorkflows(limit) {
+  const appClient = getAppClient();
+  const searchParams = new URLSearchParams;
+  if (limit !== undefined) {
+    searchParams.set("limit", String(limit));
+  }
+  let response;
+  try {
+    response = await appClient.get("workflows", { searchParams });
+  } catch (error48) {
+    throw await ApiError.fromHttpError(error48, "listing workflows");
+  }
+  const result = ListWorkflowsResponseSchema.safeParse(await response.json());
+  if (!result.success) {
+    throw new SchemaValidationError("Invalid workflows response from server", result.error);
+  }
+  return result.data;
+}
+function buildRunsQueryString(filters) {
+  const params = new URLSearchParams;
+  if (filters.status) {
+    params.set("status", filters.status);
+  }
+  if (filters.since) {
+    params.set("since", filters.since);
+  }
+  if (filters.limit !== undefined) {
+    params.set("limit", String(filters.limit));
+  }
+  return params;
+}
+async function listWorkflowRuns(filters = {}) {
+  const appClient = getAppClient();
+  let response;
+  try {
+    response = await appClient.get("workflows/runs", {
+      searchParams: buildRunsQueryString(filters)
+    });
+  } catch (error48) {
+    throw await ApiError.fromHttpError(error48, "listing workflow runs");
+  }
+  const result = ListWorkflowRunsResponseSchema.safeParse(await response.json());
+  if (!result.success) {
+    throw new SchemaValidationError("Invalid workflow runs response from server", result.error);
+  }
+  return result.data;
+}
+// src/cli/commands/workflows/legacy-app.ts
+var isWorkflowsNotEnabled = (error48) => error48 instanceof ApiError && error48.statusCode === 403;
+function rethrowLegacyAppAsExplanation(error48) {
+  if (isWorkflowsNotEnabled(error48)) {
+    throw new InvalidInputError("Workflows are not enabled for this app — it predates the Workflows system, so its automation runs are not readable via this command.");
+  }
+  throw error48;
+}
+
+// src/cli/commands/workflows/limit.ts
+var MAX_LIMIT = 200;
+function parseLimit(limit) {
+  if (limit === undefined)
+    return;
+  const parsed = Number.parseInt(limit, 10);
+  if (Number.isNaN(parsed) || parsed < 1 || parsed > MAX_LIMIT) {
+    throw new InvalidInputError(`Invalid limit: "${limit}". Must be a number between 1 and ${MAX_LIMIT}.`);
+  }
+  return parsed;
+}
+
+// src/cli/commands/workflows/list.ts
+function formatWorkflowLine(workflow) {
+  const lastRun = workflow.lastRunAt ? `last run ${workflow.lastRunStatus ?? "unknown"} at ${workflow.lastRunAt}` : "never ran";
+  const failures = workflow.consecutiveFailures > 0 ? ` (${workflow.consecutiveFailures} consecutive failures)` : "";
+  return `${workflow.name}  [${workflow.status}]  runs: ${workflow.totalRuns}, ${lastRun}${failures}`;
+}
+async function listAction({ log, runTask: runTask2, jsonMode }, options8) {
+  const limit = parseLimit(options8.limit);
+  const workflows = await runTask2("Fetching workflows from Base44", async () => listWorkflows(limit).catch(rethrowLegacyAppAsExplanation), {
+    successMessage: "Workflows fetched successfully",
+    errorMessage: "Failed to fetch workflows"
+  });
+  if (jsonMode) {
+    return {
+      outroMessage: `Found ${workflows.length} workflows.`,
+      stdout: `${JSON.stringify({ workflows }, null, 2)}
+`
+    };
+  }
+  if (workflows.length === 0) {
+    return { outroMessage: "This app has no workflows." };
+  }
+  for (const workflow of workflows) {
+    log.info(formatWorkflowLine(workflow));
+  }
+  return { outroMessage: `Found ${workflows.length} workflows.` };
+}
+function getWorkflowsListCommand() {
+  return new Base44Command("list").description("List this app's workflows").option("-n, --limit <n>", `Number of workflows to return (1-${MAX_LIMIT}, default: 30)`).action(listAction);
+}
+
+// src/cli/commands/workflows/runs.ts
+function formatDuration2(durationMs) {
+  if (durationMs === 0)
+    return "";
+  return `  ${(durationMs / 1000).toFixed(1)}s`;
+}
+function formatRunTags(run) {
+  const tags = [run.triggerType, run.isTestRun ? "test" : null].filter(Boolean);
+  return tags.length > 0 ? `  (${tags.join(", ")})` : "";
+}
+function formatFailureDetail(run) {
+  const reason = run.statusReason ? ` [${run.statusReason}]` : "";
+  const message = run.errorMessage ? `
+    ${run.errorMessage}` : "";
+  return `${reason}${message}`;
+}
+function formatRunLine(run) {
+  const time3 = (run.startedAt ?? "").substring(0, 19).replace("T", " ");
+  const status = run.status.toUpperCase().padEnd(9);
+  const base = `${time3} ${status} ${run.workflowName}${formatRunTags(run)}${formatDuration2(run.durationMs)}`;
+  const failureDetail = run.status === "failed" || run.status === "cancelled" ? formatFailureDetail(run) : "";
+  return `${base}${failureDetail}`;
+}
+async function describeEmptyResult(hasFilters) {
+  const workflows = await listWorkflows().catch(() => null);
+  if (workflows === null) {
+    return "No runs found.";
+  }
+  if (workflows.length === 0) {
+    return "This app has no workflows, so there are no runs.";
+  }
+  const names = workflows.map((workflow) => workflow.name).join(", ");
+  return hasFilters ? `No runs match your filters. Workflows in this app: ${names}.` : `No runs yet. Workflows in this app: ${names}.`;
+}
+async function runsAction(ctx, options8) {
+  const limit = parseLimit(options8.limit);
+  const runs = await ctx.runTask("Fetching workflow runs from Base44", async () => listWorkflowRuns({
+    status: options8.status,
+    since: options8.since,
+    limit
+  }).catch(rethrowLegacyAppAsExplanation), {
+    successMessage: "Workflow runs fetched successfully",
+    errorMessage: "Failed to fetch workflow runs"
+  });
+  if (ctx.jsonMode) {
+    return {
+      outroMessage: `Found ${runs.length} runs.`,
+      stdout: `${JSON.stringify({ runs }, null, 2)}
+`
+    };
+  }
+  if (runs.length === 0) {
+    const hasFilters = Boolean(options8.status || options8.since);
+    return { outroMessage: await describeEmptyResult(hasFilters) };
+  }
+  for (const run of runs) {
+    ctx.log.info(formatRunLine(run));
+  }
+  return { outroMessage: `Found ${runs.length} runs.` };
+}
+function getWorkflowsRunsCommand() {
+  return new Base44Command("runs").description("List workflow runs for this app, newest first (includes scheduled, manual, and test runs)").addOption(new Option("--status <status>", "Filter by run status").choices([
+    ...WorkflowRunStatusSchema.options
+  ])).option("--since <datetime>", "Show runs started after this time. ISO datetime or relative shorthand (e.g. 1h, 30m, 2d)", normalizeDatetime).option("-n, --limit <n>", `Number of runs to return (1-${MAX_LIMIT}, default: 30)`).action(runsAction);
+}
+
+// src/cli/commands/workflows/index.ts
+function getWorkflowsCommand() {
+  return new Command("workflows").description("Inspect this app's workflows and their runs").addCommand(getWorkflowsListCommand()).addCommand(getWorkflowsRunsCommand());
+}
+
 // src/cli/commands/workspace/shared.ts
 function workspaceTag(workspace2) {
   const role = workspace2.userRole ?? "member";
@@ -260261,7 +260715,8 @@ var fieldTypes = [
   "number",
   "boolean",
   "array",
-  "object"
+  "object",
+  "null"
 ];
 
 class Validator {
@@ -260321,6 +260776,14 @@ class Validator {
     if (!property) {
       return { hasError: false };
     }
+    if (Array.isArray(property.type)) {
+      const types = property.type;
+      const matched = types.some((type) => !this.validateValue(value, { ...property, type }, fieldPath).hasError);
+      return matched ? { hasError: false } : {
+        hasError: true,
+        error: this.createValidationError(`Error in field ${fieldPath}: Input should be a valid ${types.join(" or ")}`)
+      };
+    }
     const propertyType = property.type;
     if (!fieldTypes.includes(propertyType)) {
       return {
@@ -260361,6 +260824,14 @@ class Validator {
           }
         }
         break;
+      case "null":
+        if (value !== null) {
+          return {
+            hasError: true,
+            error: this.createValidationError(`Error in field ${fieldPath}: Input should be null`)
+          };
+        }
+        break;
       case "integer":
         if (!Number.isInteger(value)) {
           return {
@@ -260780,7 +261251,9 @@ function evaluateCondition(condition, record2, user) {
 function checkRLS(rule, record2, user) {
   if (user?.is_service === true)
     return true;
-  if (rule === undefined)
+  if (rule === undefined || rule === null || rule === "")
+    return true;
+  if (typeof rule === "object" && Object.keys(rule).length === 0)
     return true;
   if (typeof rule === "boolean")
     return rule;
@@ -263331,6 +263804,10 @@ function validateDevOptions(command2) {
   if (appId !== undefined) {
     command2.error(`base44 dev cannot be used with --app-id or ${BASE44_APP_ID_ENV_VAR}.`);
   }
+  const { port, remote } = command2.opts();
+  if (remote && port !== undefined) {
+    command2.error("--port applies to the local backend, which --remote does not start.");
+  }
 }
 function requireLinkedProject({ app }) {
   if (!app?.projectRoot) {
@@ -263338,31 +263815,44 @@ function requireLinkedProject({ app }) {
   }
   return { id: app.id, projectRoot: app.projectRoot };
 }
-async function createConfiguredServeRunner(app, backendUrl) {
+async function resolveConfiguredSite(app) {
   const { project: project2 } = await readProjectConfig(app.projectRoot);
   const serveCommand = project2.site?.serveCommand;
-  if (!serveCommand) {
-    return;
-  }
-  return createServeCommandRunner({
-    serveCommand,
-    projectRoot: project2.root,
-    appId: app.id,
-    appBaseUrl: backendUrl
-  });
+  return serveCommand ? { serveCommand, projectRoot: project2.root } : undefined;
 }
-function startServeCommand(runner, backend) {
+function stopRunnerOnProcessSignals(runner) {
   const stop2 = () => void runner.stop();
   process.on("SIGINT", stop2);
   process.on("SIGTERM", stop2);
+}
+function startServeCommand(runner, backend) {
+  stopRunnerOnProcessSignals(runner);
   runner.onExit(() => {
     backend.shutdown().finally(() => process.exit(1));
   });
   createDevLogger("backend", theme.styles.info).log(`Backend running on ${backend.url}`);
   runner.start();
 }
-async function devAction(ctx, options8) {
-  const app = requireLinkedProject(ctx);
+async function remoteDevAction(app) {
+  const site2 = await resolveConfiguredSite(app);
+  if (!site2) {
+    throw new ConfigInvalidError("base44 dev --remote serves the frontend against the production backend, but this project has no site.serveCommand in base44/config.jsonc.");
+  }
+  const appBaseUrl = await getSiteUrl();
+  const runner = createServeCommandRunner({
+    ...site2,
+    appId: app.id,
+    appBaseUrl
+  });
+  stopRunnerOnProcessSignals(runner);
+  runner.onExit((code2) => process.exit(code2 ?? 1));
+  runner.start();
+  return {
+    outroMessage: `Frontend dev server targets ${theme.styles.bold(appBaseUrl)} — every write hits your live app`
+  };
+}
+async function localDevAction(ctx, app, options8) {
+  const site2 = await resolveConfiguredSite(app);
   const siteUrlPromise = getSiteUrl().catch(() => {
     return;
   });
@@ -263377,15 +263867,23 @@ async function devAction(ctx, options8) {
     }
   });
   const backendUrl = localServerUrl(backend.port);
-  const runner = await createConfiguredServeRunner(app, backendUrl);
-  if (runner) {
+  if (site2) {
+    const runner = createServeCommandRunner({
+      ...site2,
+      appId: app.id,
+      appBaseUrl: backendUrl
+    });
     startServeCommand(runner, { url: backendUrl, shutdown: backend.shutdown });
   }
-  const outroMessage = runner ? "Open your app using the frontend dev server URL" : `Dev server is available at ${theme.colors.links(backendUrl)}`;
+  const outroMessage = site2 ? "Open your app using the frontend dev server URL" : `Dev server is available at ${theme.colors.links(backendUrl)}`;
   return { outroMessage };
 }
+async function devAction(ctx, options8) {
+  const app = requireLinkedProject(ctx);
+  return options8.remote ? remoteDevAction(app) : localDevAction(ctx, app, options8);
+}
 function getDevCommand() {
-  return new Base44Command("dev").description("Start the development server").option("-p, --port <number>", "Port for the development server").hook("preAction", validateDevOptions).action(devAction);
+  return new Base44Command("dev").description("Start the development server").option("-p, --port <number>", "Port for the development server").option("--remote", "Serve the frontend against the production backend instead of a local one").hook("preAction", validateDevOptions).action(devAction);
 }
 
 // src/core/exec/run-script.ts
@@ -263648,6 +264146,7 @@ function createProgram(context) {
   program2.addCommand(getAgentSkillsCommand());
   program2.addCommand(getConnectorsCommand());
   program2.addCommand(getFunctionsCommand());
+  program2.addCommand(getWorkflowsCommand());
   program2.addCommand(getSecretsCommand());
   program2.addCommand(getSandboxCommand());
   program2.addCommand(getAuthCommand());
@@ -267903,4 +268402,4 @@ export {
   CLIExitError
 };
 
-//# debugId=D124AF9A61B7AEE264756E2164756E21
+//# debugId=844375621C10BF7464756E2164756E21