@base44-preview/cli 0.0.33-pr.286.ddceb19 → 0.0.33-pr.331.8d14c8e

package/dist/cli/index.js

@@ -17446,7 +17446,7 @@ var require_lodash2 = __commonJS((exports, module) => {
         }
         return mapped.length && mapped[0] === arrays[0] ? baseIntersection(mapped, undefined2, comparator) : [];
       });
-      function join12(array2, separator) {
+      function join15(array2, separator) {
         return array2 == null ? "" : nativeJoin.call(array2, separator);
       }
       function last(array2) {
@@ -17468,7 +17468,7 @@ var require_lodash2 = __commonJS((exports, module) => {
       function nth(array2, n2) {
         return array2 && array2.length ? baseNth(array2, toInteger(n2)) : undefined2;
       }
-      var pull = baseRest(pullAll);
+      var pull2 = baseRest(pullAll);
       function pullAll(array2, values2) {
         return array2 && array2.length && values2 && values2.length ? basePullAll(array2, values2) : array2;
       }
@@ -19233,7 +19233,7 @@ __p += '`;
       lodash.pickBy = pickBy;
       lodash.property = property;
       lodash.propertyOf = propertyOf;
-      lodash.pull = pull;
+      lodash.pull = pull2;
       lodash.pullAll = pullAll;
       lodash.pullAllBy = pullAllBy;
       lodash.pullAllWith = pullAllWith;
@@ -19378,7 +19378,7 @@ __p += '`;
       lodash.isUndefined = isUndefined;
       lodash.isWeakMap = isWeakMap;
       lodash.isWeakSet = isWeakSet;
-      lodash.join = join12;
+      lodash.join = join15;
       lodash.kebabCase = kebabCase2;
       lodash.last = last;
       lodash.lastIndexOf = lastIndexOf;
@@ -20007,7 +20007,7 @@ function cleanDoc(doc2) {
   return mapDoc(doc2, (currentDoc) => cleanDocFn(currentDoc));
 }
 function replaceEndOfLine(doc2, replacement = literalline) {
-  return mapDoc(doc2, (currentDoc) => typeof currentDoc === "string" ? join12(replacement, currentDoc.split(`
+  return mapDoc(doc2, (currentDoc) => typeof currentDoc === "string" ? join15(replacement, currentDoc.split(`
 `)) : currentDoc);
 }
 function canBreakFn(doc2) {
@@ -20087,7 +20087,7 @@ function indentIfBreak(contents, options) {
     negate: options.negate
   };
 }
-function join12(separator, docs) {
+function join15(separator, docs) {
   assertDoc(separator);
   assertDocArray(docs);
   const parts = [];
@@ -20798,7 +20798,7 @@ var init_doc = __esm(() => {
   MODE_FLAT = Symbol("MODE_FLAT");
   DOC_FILL_PRINTED_LENGTH = Symbol("DOC_FILL_PRINTED_LENGTH");
   builders = {
-    join: join12,
+    join: join15,
     line,
     softline,
     hardline,
@@ -125712,7 +125712,7 @@ Expected it to be ${EXPECTED_TYPE_VALUES}.`;
       return mapDoc2(doc2, (currentDoc) => cleanDocFn2(currentDoc));
     }
     function replaceEndOfLine2(doc2, replacement = literalline2) {
-      return mapDoc2(doc2, (currentDoc) => typeof currentDoc === "string" ? join14(replacement, currentDoc.split(`
+      return mapDoc2(doc2, (currentDoc) => typeof currentDoc === "string" ? join17(replacement, currentDoc.split(`
 `)) : currentDoc);
     }
     function canBreakFn2(doc2) {
@@ -125798,7 +125798,7 @@ Expected it to be ${EXPECTED_TYPE_VALUES}.`;
         negate: options8.negate
       };
     }
-    function join14(separator, docs) {
+    function join17(separator, docs) {
       assertDoc2(separator);
       assertDocArray2(docs);
       const parts = [];
@@ -126463,7 +126463,7 @@ Expected it to be ${EXPECTED_TYPE_VALUES}.`;
       }
     }
     var builders2 = {
-      join: join14,
+      join: join17,
       line: line3,
       softline: softline2,
       hardline: hardline4,
@@ -155678,10 +155678,10 @@ var require_view = __commonJS((exports, module) => {
   var debug = require_src4()("express:view");
   var path18 = __require("node:path");
   var fs28 = __require("node:fs");
-  var dirname11 = path18.dirname;
+  var dirname13 = path18.dirname;
   var basename4 = path18.basename;
   var extname2 = path18.extname;
-  var join15 = path18.join;
+  var join18 = path18.join;
   var resolve5 = path18.resolve;
   module.exports = View;
   function View(name2, options8) {
@@ -155717,7 +155717,7 @@ var require_view = __commonJS((exports, module) => {
     for (var i5 = 0;i5 < roots.length && !path19; i5++) {
       var root2 = roots[i5];
       var loc = resolve5(root2, name2);
-      var dir = dirname11(loc);
+      var dir = dirname13(loc);
       var file2 = basename4(loc);
       path19 = this.resolve(dir, file2);
     }
@@ -155743,12 +155743,12 @@ var require_view = __commonJS((exports, module) => {
   };
   View.prototype.resolve = function resolve6(dir, file2) {
     var ext = this.ext;
-    var path19 = join15(dir, file2);
+    var path19 = join18(dir, file2);
     var stat2 = tryStat(path19);
     if (stat2 && stat2.isFile()) {
       return path19;
     }
-    path19 = join15(dir, basename4(file2, ext), "index" + ext);
+    path19 = join18(dir, basename4(file2, ext), "index" + ext);
     stat2 = tryStat(path19);
     if (stat2 && stat2.isFile()) {
       return path19;
@@ -159443,7 +159443,7 @@ var require_send = __commonJS((exports, module) => {
   var Stream2 = __require("stream");
   var util2 = __require("util");
   var extname2 = path18.extname;
-  var join15 = path18.join;
+  var join18 = path18.join;
   var normalize = path18.normalize;
   var resolve5 = path18.resolve;
   var sep = path18.sep;
@@ -159615,7 +159615,7 @@ var require_send = __commonJS((exports, module) => {
         return res;
       }
       parts = path19.split(sep);
-      path19 = normalize(join15(root2, path19));
+      path19 = normalize(join18(root2, path19));
     } else {
       if (UP_PATH_REGEXP.test(path19)) {
         debug('malicious path "%s"', path19);
@@ -159755,7 +159755,7 @@ var require_send = __commonJS((exports, module) => {
           return self2.onStatError(err);
         return self2.error(404);
       }
-      var p4 = join15(path19, self2._index[i5]);
+      var p4 = join18(path19, self2._index[i5]);
       debug('stat "%s"', p4);
       fs28.stat(p4, function(err2, stat2) {
         if (err2)
@@ -162834,7 +162834,7 @@ var {
 } = import__.default;
 
 // src/cli/commands/agents/pull.ts
-import { dirname as dirname7, join as join9 } from "node:path";
+import { dirname as dirname7, join as join10 } from "node:path";
 
 // node_modules/@clack/core/dist/index.mjs
 var import_picocolors = __toESM(require_picocolors(), 1);
@@ -178557,10 +178557,9 @@ class ApiError extends SystemError {
       } catch {
         message = error48.message;
       }
-      const statusCode = ApiError.normalizeStatusCode(error48.response.status, responseBody);
       const requestBody = error48.options.context?.__requestBody;
       return new ApiError(`Error ${context}: ${message}`, {
-        statusCode,
+        statusCode: error48.response.status,
         requestUrl: error48.request.url,
         requestMethod: error48.request.method,
         requestBody,
@@ -178617,12 +178616,6 @@ class ApiError extends SystemError {
       return;
     return REASON_HINTS[reason];
   }
-  static normalizeStatusCode(statusCode, responseBody) {
-    if (responseBody?.error_type === "KeyError") {
-      return 404;
-    }
-    return statusCode;
-  }
 }
 
 class FileNotFoundError extends SystemError {
@@ -185316,7 +185309,7 @@ var generateGlobTasks = normalizeArguments(generateTasks);
 var generateGlobTasksSync = normalizeArgumentsSync(generateTasksSync);
 
 // src/core/project/config.ts
-import { dirname as dirname5, join as join6 } from "node:path";
+import { dirname as dirname5, join as join7 } from "node:path";
 
 // src/core/resources/agent/schema.ts
 var EntityOperationSchema = exports_external.enum(["create", "update", "delete", "read"]);
@@ -186019,13 +186012,26 @@ var DeployFunctionsResponseSchema = exports_external.object({
   skipped: exports_external.array(exports_external.string()).optional().nullable(),
   errors: exports_external.array(exports_external.object({ name: exports_external.string(), message: exports_external.string() })).nullable()
 });
-var LogLevelSchema = exports_external.enum(["log", "info", "warn", "error", "debug"]);
-var FunctionLogEntrySchema = exports_external.object({
-  time: exports_external.string(),
-  level: LogLevelSchema,
-  message: exports_external.string()
+var DeploySingleFunctionResponseSchema = exports_external.object({
+  status: exports_external.enum(["deployed", "unchanged", "error"]),
+  error: exports_external.string().optional().nullable(),
+  duration_ms: exports_external.number().optional().nullable()
+});
+var FunctionAutomationInfoSchema = exports_external.object({
+  name: exports_external.string(),
+  type: exports_external.string(),
+  is_active: exports_external.boolean()
+});
+var FunctionInfoSchema = exports_external.object({
+  name: exports_external.string(),
+  deployment_id: exports_external.string(),
+  entry: exports_external.string(),
+  files: exports_external.array(FunctionFileSchema),
+  automations: exports_external.array(FunctionAutomationInfoSchema)
+});
+var ListFunctionsResponseSchema = exports_external.object({
+  functions: exports_external.array(FunctionInfoSchema)
 });
-var FunctionLogsResponseSchema = exports_external.array(FunctionLogEntrySchema);
 
 // src/core/resources/function/api.ts
 function toDeployPayloadItem(fn) {
@@ -186056,39 +186062,39 @@ async function deployFunctions(functions) {
   }
   return result.data;
 }
-function buildLogsQueryString(filters) {
-  const params = new URLSearchParams;
-  if (filters.since) {
-    params.set("since", filters.since);
-  }
-  if (filters.until) {
-    params.set("until", filters.until);
-  }
-  if (filters.level) {
-    params.set("level", filters.level);
+async function deploySingleFunction(name2, payload) {
+  const appClient = getAppClient();
+  let response;
+  try {
+    response = await appClient.put(`backend-functions/${encodeURIComponent(name2)}`, { json: payload, timeout: false });
+  } catch (error48) {
+    throw await ApiError.fromHttpError(error48, `deploying function "${name2}"`);
   }
-  if (filters.limit !== undefined) {
-    params.set("limit", String(filters.limit));
+  const result = DeploySingleFunctionResponseSchema.safeParse(await response.json());
+  if (!result.success) {
+    throw new SchemaValidationError("Invalid response from server", result.error);
   }
-  if (filters.order) {
-    params.set("order", filters.order);
+  return result.data;
+}
+async function deleteSingleFunction(name2) {
+  const appClient = getAppClient();
+  try {
+    await appClient.delete(`backend-functions/${encodeURIComponent(name2)}`, { timeout: 60000 });
+  } catch (error48) {
+    throw await ApiError.fromHttpError(error48, `deleting function "${name2}"`);
   }
-  return params;
 }
-async function fetchFunctionLogs(functionName, filters = {}) {
+async function listDeployedFunctions() {
   const appClient = getAppClient();
-  const searchParams = buildLogsQueryString(filters);
   let response;
   try {
-    response = await appClient.get(`functions-mgmt/${functionName}/logs`, {
-      searchParams
-    });
+    response = await appClient.get("backend-functions", { timeout: 30000 });
   } catch (error48) {
-    throw await ApiError.fromHttpError(error48, `fetching function logs: '${functionName}'`);
+    throw await ApiError.fromHttpError(error48, "listing deployed functions");
   }
-  const result = FunctionLogsResponseSchema.safeParse(await response.json());
+  const result = ListFunctionsResponseSchema.safeParse(await response.json());
   if (!result.success) {
-    throw new SchemaValidationError("Invalid function logs response from server", result.error);
+    throw new SchemaValidationError("Invalid response from server", result.error);
   }
   return result.data;
 }
@@ -186150,6 +186156,115 @@ async function pushFunctions(functions) {
   const functionsWithCode = await Promise.all(functions.map(loadFunctionCode));
   return deployFunctions(functionsWithCode);
 }
+async function deployOne(fn) {
+  try {
+    const loaded = await loadFunctionCode(fn);
+    const resp = await deploySingleFunction(loaded.name, {
+      entry: loaded.entry,
+      files: loaded.files,
+      automations: loaded.automations
+    });
+    return { name: loaded.name, ...resp };
+  } catch (error48) {
+    return {
+      name: fn.name,
+      status: "error",
+      error: error48 instanceof Error ? error48.message : String(error48)
+    };
+  }
+}
+async function pushFunctionsSingle(functions, options) {
+  if (functions.length === 0)
+    return [];
+  const concurrency = options?.concurrency ?? 1;
+  if (concurrency <= 1) {
+    const results2 = [];
+    for (const fn of functions) {
+      options?.onStart?.([fn.name]);
+      const result = await deployOne(fn);
+      results2.push(result);
+      options?.onResult?.(result);
+    }
+    return results2;
+  }
+  const results = [];
+  for (let i = 0;i < functions.length; i += concurrency) {
+    const batch = functions.slice(i, i + concurrency);
+    options?.onStart?.(batch.map((fn) => fn.name));
+    const batchResults = await Promise.all(batch.map(deployOne));
+    for (const result of batchResults) {
+      results.push(result);
+      options?.onResult?.(result);
+    }
+  }
+  return results;
+}
+async function pruneRemovedFunctions(localFunctionNames) {
+  const remote = await listDeployedFunctions();
+  const localSet = new Set(localFunctionNames);
+  const toDelete = remote.functions.filter((f) => !localSet.has(f.name));
+  const results = [];
+  for (const fn of toDelete) {
+    try {
+      await deleteSingleFunction(fn.name);
+      results.push({ name: fn.name, deleted: true });
+    } catch (error48) {
+      results.push({
+        name: fn.name,
+        deleted: false,
+        error: error48 instanceof Error ? error48.message : String(error48)
+      });
+    }
+  }
+  return results;
+}
+// src/core/resources/function/pull.ts
+import { join as join6 } from "node:path";
+async function writeFunctions(functionsDir, functions) {
+  const written = [];
+  const skipped = [];
+  for (const fn of functions) {
+    const functionDir = join6(functionsDir, fn.name);
+    const configPath = join6(functionDir, "function.jsonc");
+    if (await isFunctionUnchanged(functionDir, fn)) {
+      skipped.push(fn.name);
+      continue;
+    }
+    const config5 = {
+      name: fn.name,
+      entry: fn.entry
+    };
+    if (fn.automations.length > 0) {
+      config5.automations = fn.automations;
+    }
+    await writeJsonFile(configPath, config5);
+    for (const file2 of fn.files) {
+      await writeFile(join6(functionDir, file2.path), file2.content);
+    }
+    written.push(fn.name);
+  }
+  return { written, skipped };
+}
+async function isFunctionUnchanged(functionDir, fn) {
+  if (!await pathExists(functionDir)) {
+    return false;
+  }
+  for (const file2 of fn.files) {
+    const filePath = join6(functionDir, file2.path);
+    if (!await pathExists(filePath)) {
+      return false;
+    }
+    try {
+      const localContent = await readTextFile(filePath);
+      if (localContent !== file2.content) {
+        return false;
+      }
+    } catch {
+      return false;
+    }
+  }
+  return true;
+}
 // src/core/resources/function/resource.ts
 var functionResource = {
   readAll: readAllFunctions,
@@ -186194,10 +186309,10 @@ async function readProjectConfig(projectRoot) {
   const project = result.data;
   const configDir = dirname5(configPath);
   const [entities, functions, agents, connectors] = await Promise.all([
-    entityResource.readAll(join6(configDir, project.entitiesDir)),
-    functionResource.readAll(join6(configDir, project.functionsDir)),
-    agentResource.readAll(join6(configDir, project.agentsDir)),
-    connectorResource.readAll(join6(configDir, project.connectorsDir))
+    entityResource.readAll(join7(configDir, project.entitiesDir)),
+    functionResource.readAll(join7(configDir, project.functionsDir)),
+    agentResource.readAll(join7(configDir, project.agentsDir)),
+    connectorResource.readAll(join7(configDir, project.connectorsDir))
   ]);
   return {
     project: { ...project, root, configPath },
@@ -186294,7 +186409,7 @@ async function readAppConfig(projectRoot) {
 // src/core/project/template.ts
 var import_ejs = __toESM(require_ejs(), 1);
 var import_front_matter = __toESM(require_front_matter(), 1);
-import { dirname as dirname6, join as join7 } from "node:path";
+import { dirname as dirname6, join as join8 } from "node:path";
 async function listTemplates() {
   const parsed = await readJsonFile(getTemplatesIndexPath());
   const result = TemplatesConfigSchema.safeParse(parsed);
@@ -186304,23 +186419,23 @@ async function listTemplates() {
   return result.data.templates;
 }
 async function renderTemplate(template, destPath, data) {
-  const templateDir = join7(getTemplatesDir(), template.path);
+  const templateDir = join8(getTemplatesDir(), template.path);
   const files = await globby("**/*", {
     cwd: templateDir,
     dot: true,
     onlyFiles: true
   });
   for (const file2 of files) {
-    const srcPath = join7(templateDir, file2);
+    const srcPath = join8(templateDir, file2);
     try {
       if (file2.endsWith(".ejs")) {
         const rendered = await import_ejs.default.renderFile(srcPath, data);
         const { attributes, body } = import_front_matter.default(rendered);
-        const destFile = attributes.outputFileName ? join7(dirname6(file2), attributes.outputFileName) : file2.replace(/\.ejs$/, "");
-        const destFilePath = join7(destPath, destFile);
+        const destFile = attributes.outputFileName ? join8(dirname6(file2), attributes.outputFileName) : file2.replace(/\.ejs$/, "");
+        const destFilePath = join8(destPath, destFile);
         await writeFile(destFilePath, body);
       } else {
-        const destFilePath = join7(destPath, file2);
+        const destFilePath = join8(destPath, file2);
         await copyFile(srcPath, destFilePath);
       }
     } catch (error48) {
@@ -186423,7 +186538,7 @@ async function getSiteFilePaths(outputDir) {
 // src/core/site/deploy.ts
 import { randomUUID } from "node:crypto";
 import { tmpdir } from "node:os";
-import { join as join8 } from "node:path";
+import { join as join9 } from "node:path";
 async function deploySite(siteOutputDir) {
   if (!await pathExists(siteOutputDir)) {
     throw new FileNotFoundError(`Output directory does not exist: ${siteOutputDir}. Make sure to build your project first.`, {
@@ -186440,7 +186555,7 @@ async function deploySite(siteOutputDir) {
       ]
     });
   }
-  const archivePath = join8(tmpdir(), `base44-site-${randomUUID()}.tar.gz`);
+  const archivePath = join9(tmpdir(), `base44-site-${randomUUID()}.tar.gz`);
   try {
     await createArchive(siteOutputDir, archivePath);
     return await uploadSite(archivePath);
@@ -194053,6 +194168,7 @@ async function printUpgradeNotificationIfAvailable() {
 
 // src/cli/utils/runCommand.ts
 async function runCommand(commandFn, options, context) {
+  console.log();
   if (options?.fullBanner) {
     await printBanner(context.isNonInteractive);
     We("");
@@ -194078,11 +194194,8 @@ async function runCommand(commandFn, options, context) {
       const appConfig = await initAppConfig();
       context.errorReporter.setContext({ appId: appConfig.id });
     }
-    const result = await commandFn();
-    Le(result.outroMessage || "");
-    if (result.stdout) {
-      process.stdout.write(result.stdout);
-    }
+    const { outroMessage } = await commandFn();
+    Le(outroMessage || "");
   } catch (error48) {
     const errorMessage = error48 instanceof Error ? error48.message : String(error48);
     R2.error(errorMessage);
@@ -194123,7 +194236,7 @@ function getDashboardUrl(projectId) {
 async function pullAgentsAction() {
   const { project: project2 } = await readProjectConfig();
   const configDir = dirname7(project2.configPath);
-  const agentsDir = join9(configDir, project2.agentsDir);
+  const agentsDir = join10(configDir, project2.agentsDir);
   const remoteAgents = await runTask("Fetching agents from Base44", async () => {
     return await fetchAgents();
   }, {
@@ -194217,11 +194330,11 @@ function getWhoamiCommand(context) {
 }
 
 // src/cli/commands/connectors/pull.ts
-import { dirname as dirname8, join as join10 } from "node:path";
+import { dirname as dirname8, join as join11 } from "node:path";
 async function pullConnectorsAction() {
   const { project: project2 } = await readProjectConfig();
   const configDir = dirname8(project2.configPath);
-  const connectorsDir = join10(configDir, project2.connectorsDir);
+  const connectorsDir = join11(configDir, project2.connectorsDir);
   const remoteConnectors = await runTask("Fetching connectors from Base44", async () => {
     return await listConnectors();
   }, {
@@ -195069,48 +195182,218 @@ function getEntitiesPushCommand(context) {
   }));
 }
 
+// src/cli/commands/functions/delete.ts
+async function deleteFunctionAction(name2) {
+  try {
+    await deleteSingleFunction(name2);
+    R2.success(`${name2} deleted`);
+    return { outroMessage: `Function "${name2}" deleted` };
+  } catch (error48) {
+    if (error48 instanceof ApiError && error48.statusCode === 404) {
+      R2.warn(`Function "${name2}" not found on remote`);
+      return { outroMessage: `Function "${name2}" not found` };
+    }
+    throw error48;
+  }
+}
+function getDeleteCommand(context) {
+  return new Command("delete").description("Delete a deployed backend function").argument("<name>", "Name of the function to delete").action(async (name2) => {
+    await runCommand(() => deleteFunctionAction(name2), { requireAuth: true }, context);
+  });
+}
+
 // src/cli/commands/functions/deploy.ts
-async function deployFunctionsAction() {
+function formatDuration(ms) {
+  return `${(ms / 1000).toFixed(1)}s`;
+}
+function formatResult(r) {
+  const label = r.name.padEnd(25);
+  if (r.status === "deployed") {
+    const timing = r.duration_ms ? theme.styles.dim(` (${formatDuration(r.duration_ms)})`) : "";
+    R2.success(`${label} deployed${timing}`);
+  } else if (r.status === "unchanged") {
+    R2.success(`${label} unchanged`);
+  } else {
+    R2.error(`${label} error: ${r.error}`);
+  }
+}
+async function deployFunctionsAction(name2, options) {
   const { functions } = await readProjectConfig();
-  if (functions.length === 0) {
+  const toDeploy = name2 ? functions.filter((f) => f.name === name2) : functions;
+  if (toDeploy.length === 0) {
+    if (name2) {
+      throw new InvalidInputError(`Function "${name2}" not found in project`);
+    }
     return {
       outroMessage: "No functions found. Create functions in the 'functions' directory."
     };
   }
-  R2.info(`Found ${functions.length} ${functions.length === 1 ? "function" : "functions"} to deploy`);
-  const result = await runTask("Deploying functions to Base44", async () => {
-    return await pushFunctions(functions);
+  R2.info(`Found ${toDeploy.length} ${toDeploy.length === 1 ? "function" : "functions"} to deploy`);
+  let completed = 0;
+  const total = toDeploy.length;
+  const results = await pushFunctionsSingle(toDeploy, {
+    concurrency: options.concurrency,
+    onStart: (names) => {
+      const label = names.length === 1 ? names[0] : `${names.length} functions`;
+      R2.step(theme.styles.dim(`[${completed}/${total}] Deploying ${label}...`));
+    },
+    onResult: (r) => {
+      completed++;
+      formatResult(r);
+    }
+  });
+  const succeeded = results.filter((r) => r.status !== "error").length;
+  const failed = results.filter((r) => r.status === "error").length;
+  if (options.prune) {
+    R2.info("Pruning remote functions not found locally...");
+    const allLocalNames = functions.map((f) => f.name);
+    const pruneResults = await pruneRemovedFunctions(allLocalNames);
+    for (const pr of pruneResults) {
+      if (pr.deleted) {
+        R2.success(`${pr.name.padEnd(25)} deleted`);
+      } else {
+        R2.error(`${pr.name.padEnd(25)} error: ${pr.error}`);
+      }
+    }
+    if (pruneResults.length > 0) {
+      const pruned = pruneResults.filter((r) => r.deleted).length;
+      R2.info(`${pruned} function${pruned !== 1 ? "s" : ""} pruned`);
+    }
+  }
+  const parts = [];
+  if (succeeded > 0)
+    parts.push(`${succeeded}/${results.length} succeeded`);
+  if (failed > 0)
+    parts.push(`${failed} error${failed !== 1 ? "s" : ""}`);
+  const summary = parts.join(", ") || "No functions deployed";
+  return { outroMessage: summary };
+}
+function getDeployCommand(context) {
+  return new Command("deploy").description("Deploy local functions to Base44").argument("[name]", "Deploy a single function by name").option("--prune", "Delete remote functions not found locally").option("-c, --concurrency <n>", "Number of functions to deploy in parallel").action(async (name2, options) => {
+    await runCommand(() => {
+      let concurrency;
+      if (options.concurrency !== undefined) {
+        const n2 = parseInt(options.concurrency, 10);
+        if (Number.isNaN(n2) || n2 < 1) {
+          throw new InvalidInputError("--concurrency must be a positive integer");
+        }
+        concurrency = n2;
+      }
+      return deployFunctionsAction(name2, { prune: options.prune, concurrency });
+    }, { requireAuth: true }, context);
+  });
+}
+
+// src/cli/commands/functions/list.ts
+async function listFunctionsAction() {
+  const { functions } = await listDeployedFunctions();
+  if (functions.length === 0) {
+    return { outroMessage: "No functions deployed" };
+  }
+  for (const fn of functions) {
+    const autoCount = fn.automations.length;
+    const autoLabel = autoCount > 0 ? theme.styles.dim(` (${autoCount} automation${autoCount > 1 ? "s" : ""})`) : "";
+    R2.message(`  ${fn.name}${autoLabel}`);
+  }
+  return {
+    outroMessage: `${functions.length} function${functions.length !== 1 ? "s" : ""} deployed`
+  };
+}
+function getListCommand(context) {
+  return new Command("list").description("List deployed backend functions").action(async () => {
+    await runCommand(listFunctionsAction, { requireAuth: true }, context);
+  });
+}
+
+// src/cli/commands/functions/new.ts
+import { dirname as dirname9, join as join12 } from "node:path";
+var FUNCTION_TEMPLATE = `Deno.serve(async (req: Request) => {
+  return new Response(JSON.stringify({ message: "Hello from {{name}}!" }), {
+    headers: { "Content-Type": "application/json" },
+  });
+});
+`;
+async function newFunctionAction(name2) {
+  if (name2.includes(".")) {
+    throw new InvalidInputError("Function name cannot contain dots");
+  }
+  const { project: project2, functions } = await readProjectConfig();
+  if (functions.some((f) => f.name === name2)) {
+    throw new InvalidInputError(`Function "${name2}" already exists in this project`);
+  }
+  const configDir = dirname9(project2.configPath);
+  const functionsDir = join12(configDir, project2.functionsDir);
+  const functionDir = join12(functionsDir, name2);
+  if (await pathExists(functionDir)) {
+    throw new InvalidInputError(`Directory "${functionDir}" already exists`);
+  }
+  const configPath = join12(functionDir, "function.jsonc");
+  const entryPath = join12(functionDir, "index.ts");
+  await writeJsonFile(configPath, { name: name2, entry: "index.ts" });
+  await writeFile(entryPath, FUNCTION_TEMPLATE.replace("{{name}}", name2));
+  R2.success(`Created ${configPath}`);
+  R2.success(`Created ${entryPath}`);
+  return {
+    outroMessage: `Function "${name2}" created. Deploy with: base44 functions deploy ${name2}`
+  };
+}
+function getNewCommand(context) {
+  return new Command("new").description("Create a new backend function from template").argument("<name>", "Name for the new function").action(async (name2) => {
+    await runCommand(() => newFunctionAction(name2), { requireAuth: false }, context);
+  });
+}
+
+// src/cli/commands/functions/pull.ts
+import { dirname as dirname10, join as join13 } from "node:path";
+async function pullFunctionsAction(name2) {
+  const { project: project2 } = await readProjectConfig();
+  const configDir = dirname10(project2.configPath);
+  const functionsDir = join13(configDir, project2.functionsDir);
+  const remoteFunctions = await runTask("Fetching functions from Base44", async () => {
+    const { functions } = await listDeployedFunctions();
+    return functions;
   }, {
-    successMessage: "Functions deployed successfully",
-    errorMessage: "Failed to deploy functions"
+    successMessage: "Functions fetched successfully",
+    errorMessage: "Failed to fetch functions"
   });
-  if (result.deployed.length > 0) {
-    R2.success(`Deployed: ${result.deployed.join(", ")}`);
+  const toPull = name2 ? remoteFunctions.filter((f) => f.name === name2) : remoteFunctions;
+  if (name2 && toPull.length === 0) {
+    return {
+      outroMessage: `Function "${name2}" not found on remote`
+    };
   }
-  if (result.deleted.length > 0) {
-    R2.warn(`Deleted: ${result.deleted.join(", ")}`);
+  if (toPull.length === 0) {
+    return { outroMessage: "No functions found on remote" };
   }
-  if (result.errors && result.errors.length > 0) {
-    const errorMessages = result.errors.map((e2) => `'${e2.name}' function: ${e2.message}`).join(`
-`);
-    throw new ApiError(`Function deployment errors:
-${errorMessages}`, {
-      hints: [
-        { message: "Check the function code for syntax errors" },
-        { message: "Ensure all imports are valid" }
-      ]
-    });
+  const { written, skipped } = await runTask("Writing function files", async () => {
+    return await writeFunctions(functionsDir, toPull);
+  }, {
+    successMessage: "Function files written successfully",
+    errorMessage: "Failed to write function files"
+  });
+  if (written.length > 0) {
+    R2.success(`Written: ${written.join(", ")}`);
   }
-  return { outroMessage: "Functions deployed to Base44" };
+  if (skipped.length > 0) {
+    R2.info(`Skipped (unchanged): ${skipped.join(", ")}`);
+  }
+  return {
+    outroMessage: `Pulled ${toPull.length} function${toPull.length !== 1 ? "s" : ""} to ${functionsDir}`
+  };
 }
-function getFunctionsDeployCommand(context) {
-  return new Command("functions").description("Manage project functions").addCommand(new Command("deploy").description("Deploy local functions to Base44").action(async () => {
-    await runCommand(deployFunctionsAction, { requireAuth: true }, context);
-  }));
+function getPullCommand(context) {
+  return new Command("pull").description("Pull deployed functions from Base44 to local files").argument("[name]", "Pull a single function by name").action(async (name2) => {
+    await runCommand(() => pullFunctionsAction(name2), { requireAuth: true }, context);
+  });
+}
+
+// src/cli/commands/functions/index.ts
+function getFunctionsCommand(context) {
+  return new Command("functions").description("Manage backend functions").addCommand(getNewCommand(context)).addCommand(getDeployCommand(context)).addCommand(getPullCommand(context)).addCommand(getListCommand(context)).addCommand(getDeleteCommand(context));
 }
 
 // src/cli/commands/project/create.ts
-import { basename as basename3, join as join11, resolve as resolve2 } from "node:path";
+import { basename as basename3, join as join14, resolve as resolve2 } from "node:path";
 var import_lodash = __toESM(require_lodash(), 1);
 var DEFAULT_TEMPLATE_ID = "backend-only";
 async function getTemplateById(templateId) {
@@ -195246,7 +195529,7 @@ async function executeCreate({
         updateMessage("Building project...");
         await execa({ cwd: resolvedPath, shell: true })`${buildCommand}`;
         updateMessage("Deploying site...");
-        return await deploySite(join11(resolvedPath, outputDirectory));
+        return await deploySite(join14(resolvedPath, outputDirectory));
       }, {
         successMessage: theme.colors.base44Orange("Site deployed successfully"),
         errorMessage: "Failed to deploy site"
@@ -195348,7 +195631,7 @@ ${summaryLines.join(`
   }
   return { outroMessage: "App deployed successfully" };
 }
-function getDeployCommand(context) {
+function getDeployCommand2(context) {
   return new Command("deploy").description("Deploy all project resources (entities, functions, agents, connectors, and site)").option("-y, --yes", "Skip confirmation prompt").action(async (options) => {
     await runCommand(() => deployAction({
       ...options,
@@ -195503,122 +195786,6 @@ function getLinkCommand(context) {
   });
 }
 
-// src/cli/commands/project/logs.ts
-function parseFunctionFilters(options) {
-  const filters = {};
-  if (options.since) {
-    filters.since = options.since;
-  }
-  if (options.until) {
-    filters.until = options.until;
-  }
-  if (options.limit) {
-    filters.limit = Number.parseInt(options.limit, 10);
-  }
-  if (options.order) {
-    filters.order = options.order.toLowerCase();
-  }
-  return filters;
-}
-function parseFunctionNames(option) {
-  if (!option)
-    return [];
-  return option.split(",").map((s) => s.trim()).filter((s) => s.length > 0);
-}
-function normalizeDatetime(value) {
-  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);
-  const message = entry.message.trim();
-  return `${time3} ${level} ${message}`;
-}
-function formatLogs(entries) {
-  if (entries.length === 0) {
-    return `No logs found matching the filters.
-`;
-  }
-  const header2 = `Showing ${entries.length} function log entries
-`;
-  return [header2, ...entries.map(formatEntry)].join(`
-`);
-}
-function normalizeLogEntry(entry, functionName) {
-  return {
-    time: entry.time,
-    level: entry.level,
-    message: `[${functionName}] ${entry.message}`,
-    source: functionName
-  };
-}
-async function fetchLogsForFunctions(functionNames, options, availableFunctionNames) {
-  const filters = parseFunctionFilters(options);
-  const allEntries = [];
-  for (const functionName of functionNames) {
-    let logs;
-    try {
-      logs = await fetchFunctionLogs(functionName, filters);
-    } catch (error48) {
-      if (error48 instanceof ApiError && error48.statusCode === 404 && availableFunctionNames.length > 0) {
-        const available = availableFunctionNames.join(", ");
-        throw new InvalidInputError(`Function "${functionName}" was not found in this app`, {
-          hints: [
-            {
-              message: `Available functions in this project: ${available}`
-            },
-            {
-              message: "Make sure the function has been deployed before fetching logs",
-              command: "base44 functions deploy"
-            }
-          ]
-        });
-      }
-      throw error48;
-    }
-    const entries = logs.map((entry) => normalizeLogEntry(entry, functionName));
-    allEntries.push(...entries);
-  }
-  if (functionNames.length > 1) {
-    const order = options.order?.toUpperCase() === "ASC" ? 1 : -1;
-    allEntries.sort((a2, b) => order * a2.time.localeCompare(b.time));
-  }
-  return allEntries;
-}
-async function getAllFunctionNames() {
-  const { functions } = await readProjectConfig();
-  return functions.map((fn) => fn.name);
-}
-async function logsAction(options) {
-  const specifiedFunctions = parseFunctionNames(options.function);
-  const allProjectFunctions = await getAllFunctionNames();
-  const functionNames = specifiedFunctions.length > 0 ? specifiedFunctions : allProjectFunctions;
-  if (functionNames.length === 0) {
-    return { outroMessage: "No functions found in this project." };
-  }
-  let entries = await fetchLogsForFunctions(functionNames, options, allProjectFunctions);
-  const limit = options.limit ? Number.parseInt(options.limit, 10) : undefined;
-  if (limit !== undefined && entries.length > limit) {
-    entries = entries.slice(0, limit);
-  }
-  const logsOutput = options.json ? `${JSON.stringify(entries, null, 2)}
-` : formatLogs(entries);
-  return { outroMessage: "Fetched logs", stdout: logsOutput };
-}
-function getLogsCommand(context) {
-  return new Command("logs").description("Fetch function logs for this app").option("--function <names>", "Filter by function name(s), comma-separated. If omitted, fetches logs for all project functions").option("--since <datetime>", "Show logs from this time (ISO format)", normalizeDatetime).option("--until <datetime>", "Show logs until this time (ISO format)", normalizeDatetime).option("-n, --limit <n>", "Results per page (1-1000, default: 50)", (v) => {
-    const n2 = Number.parseInt(v, 10);
-    if (Number.isNaN(n2) || n2 < 1 || n2 > 1000) {
-      throw new InvalidInputError(`Invalid limit: "${v}". Must be a number between 1 and 1000.`);
-    }
-    return v;
-  }).addOption(new Option("--order <order>", "Sort order").choices(["asc", "desc"])).option("--json", "Output raw JSON").action(async (options) => {
-    await runCommand(() => logsAction(options), { requireAuth: true }, context);
-  });
-}
-
 // src/cli/commands/site/deploy.ts
 import { resolve as resolve3 } from "node:path";
 async function deployAction2(options) {
@@ -195763,10 +195930,10 @@ function toPascalCase(name2) {
   return name2.split(/[-_\s]+/).map((w8) => w8.charAt(0).toUpperCase() + w8.slice(1)).join("");
 }
 // src/core/types/update-project.ts
-import { join as join14 } from "node:path";
+import { join as join17 } from "node:path";
 var TYPES_INCLUDE_PATH = `${PROJECT_SUBDIR}/${TYPES_OUTPUT_SUBDIR}/*.d.ts`;
 async function updateProjectConfig(projectRoot) {
-  const tsconfigPath = join14(projectRoot, "tsconfig.json");
+  const tsconfigPath = join17(projectRoot, "tsconfig.json");
   if (!await pathExists(tsconfigPath)) {
     return false;
   }
@@ -195809,7 +195976,7 @@ function getTypesCommand(context) {
 }
 
 // src/cli/commands/dev.ts
-import { dirname as dirname12, join as join16 } from "node:path";
+import { dirname as dirname14, join as join19 } from "node:path";
 
 // src/cli/dev/dev-server/main.ts
 var import_cors = __toESM(require_lib4(), 1);
@@ -195957,10 +196124,10 @@ function createDevLogger() {
 
 // src/cli/dev/dev-server/function-manager.ts
 import { spawn as spawn2, spawnSync as spawnSync2 } from "node:child_process";
-import { dirname as dirname11, join as join15 } from "node:path";
+import { dirname as dirname13, join as join18 } from "node:path";
 import { fileURLToPath as fileURLToPath7 } from "node:url";
-var __dirname5 = dirname11(fileURLToPath7(import.meta.url));
-var WRAPPER_PATH = join15(__dirname5, "../deno-runtime/main.js");
+var __dirname5 = dirname13(fileURLToPath7(import.meta.url));
+var WRAPPER_PATH = join18(__dirname5, "../deno-runtime/main.js");
 var READY_TIMEOUT = 30000;
 
 class FunctionManager {
@@ -196212,8 +196379,8 @@ async function devAction(options8) {
     port,
     loadResources: async () => {
       const { project: project2 } = await readProjectConfig();
-      const configDir = dirname12(project2.configPath);
-      const functions = await functionResource.readAll(join16(configDir, project2.functionsDir));
+      const configDir = dirname14(project2.configPath);
+      const functions = await functionResource.readAll(join19(configDir, project2.functionsDir));
       return { functions };
     }
   });
@@ -196330,17 +196497,16 @@ function createProgram(context) {
   program2.addCommand(getLogoutCommand(context));
   program2.addCommand(getCreateCommand(context));
   program2.addCommand(getDashboardCommand(context));
-  program2.addCommand(getDeployCommand(context));
+  program2.addCommand(getDeployCommand2(context));
   program2.addCommand(getLinkCommand(context));
   program2.addCommand(getEjectCommand(context));
   program2.addCommand(getEntitiesPushCommand(context));
   program2.addCommand(getAgentsCommand(context));
   program2.addCommand(getConnectorsCommand(context));
-  program2.addCommand(getFunctionsDeployCommand(context));
+  program2.addCommand(getFunctionsCommand(context));
   program2.addCommand(getSiteCommand(context));
   program2.addCommand(getTypesCommand(context));
   program2.addCommand(getDevCommand(context), { hidden: true });
-  program2.addCommand(getLogsCommand(context), { hidden: true });
   return program2;
 }
 
@@ -196379,7 +196545,7 @@ function nanoid3(size = 21) {
 }
 
 // node_modules/posthog-node/dist/extensions/error-tracking/modifiers/module.node.mjs
-import { dirname as dirname13, posix, sep } from "path";
+import { dirname as dirname15, posix, sep } from "path";
 function createModulerModifier() {
   const getModuleFromFileName = createGetModuleFromFilename();
   return async (frames) => {
@@ -196388,7 +196554,7 @@ function createModulerModifier() {
     return frames;
   };
 }
-function createGetModuleFromFilename(basePath = process.argv[1] ? dirname13(process.argv[1]) : process.cwd(), isWindows4 = sep === "\\") {
+function createGetModuleFromFilename(basePath = process.argv[1] ? dirname15(process.argv[1]) : process.cwd(), isWindows4 = sep === "\\") {
   const normalizedBase = isWindows4 ? normalizeWindowsPath2(basePath) : basePath;
   return (filename) => {
     if (!filename)
@@ -200605,4 +200771,4 @@ export {
   CLIExitError
 };
 
-//# debugId=682DFFEB8217B90164756E2164756E21
+//# debugId=F8CDDD826B08FA8A64756E2164756E21