@base44-preview/cli 0.0.55-pr.546.2cca7dc → 0.0.55-pr.547.7e43787

package/dist/cli/index.js

@@ -120878,7 +120878,7 @@ function parse42(toml, { maxDepth = 1000, integersAsBigInt } = {}) {
   }
   return res;
 }
-async function readFile2(file2) {
+async function readFile3(file2) {
   if (isUrlString(file2)) {
     file2 = new URL(file2);
   }
@@ -134672,7 +134672,7 @@ ${codeblock}`, options8);
     "\\": "\\"
   };
   KEY_PART_RE = /^[a-zA-Z0-9-_]+[ \t]*$/;
-  read_file_default = readFile2;
+  read_file_default = readFile3;
   loadConfigFromPackageJson = process.versions.bun ? async function loadConfigFromBunPackageJson(file2) {
     const { prettier } = await readBunPackageJson(file2);
     return prettier;
@@ -143907,7 +143907,7 @@ var require_parse7 = __commonJS((exports) => {
       extension: url3.getExtension(path18)
     };
     try {
-      const resolver = await readFile3(file2, options8, $refs);
+      const resolver = await readFile4(file2, options8, $refs);
       $ref.pathType = resolver.plugin.name;
       file2.data = resolver.result;
       const parser2 = await parseFile(file2, options8, $refs);
@@ -143920,7 +143920,7 @@ var require_parse7 = __commonJS((exports) => {
       throw err;
     }
   }
-  async function readFile3(file2, options8, $refs) {
+  async function readFile4(file2, options8, $refs) {
     let resolvers = plugins.all(options8.resolve);
     resolvers = plugins.filter(resolvers, "canRead", file2);
     plugins.sort(resolvers);
@@ -218285,7 +218285,6 @@ var PROJECT_CONFIG_PATTERNS = [
   `${PROJECT_SUBDIR}/config.${CONFIG_FILE_EXTENSION_GLOB}`,
   `config.${CONFIG_FILE_EXTENSION_GLOB}`
 ];
-var BASE44_APP_ID_ENV_VAR = "BASE44_APP_ID";
 var TYPES_OUTPUT_SUBDIR = ".types";
 var TYPES_FILENAME = "types.d.ts";
 var AUTH_CLIENT_ID = "base44_cli";
@@ -233981,7 +233980,7 @@ async function parseEnvFile(filePath) {
 }
 var STRIPE_ENV_PREFIX = "BASE44_PROJECTS_";
 var BASE44_ENV_KEYS = [
-  BASE44_APP_ID_ENV_VAR,
+  "BASE44_APP_ID",
   "BASE44_ACCESS_TOKEN",
   "BASE44_REFRESH_TOKEN",
   "BASE44_API_URL"
@@ -241695,35 +241694,18 @@ function loadFromTestOverrides() {
   }
   return null;
 }
-async function initAppContext(options = {}) {
+async function initAppContext() {
   const testConfig = loadFromTestOverrides();
   if (testConfig) {
     cache2 = testConfig;
     return cache2;
   }
-  const projectRoot = findProjectRoot();
-  if (options.appId !== undefined) {
-    const id = options.appId.trim();
-    if (!id) {
-      throw new InvalidInputError("App id cannot be empty.");
-    }
-    cache2 = { id };
-    return cache2;
-  }
   if (cache2) {
     return cache2;
   }
+  const projectRoot = findProjectRoot();
   if (!projectRoot) {
-    throw new ConfigNotFoundError(`No Base44 app ID found. Pass --app-id, set ${BASE44_APP_ID_ENV_VAR}, or run this command from a linked project with base44/.app.jsonc.`, {
-      hints: [
-        { message: "Pass an app ID explicitly with --app-id <id>" },
-        { message: `Set ${BASE44_APP_ID_ENV_VAR} in your environment` },
-        {
-          message: "Run from a linked Base44 project with base44/.app.jsonc, or run 'base44 link'",
-          command: "base44 link"
-        }
-      ]
-    });
+    throw new ConfigNotFoundError("No Base44 project found. Run this command from a project directory with a config.jsonc file.");
   }
   const config3 = await readAppConfig(projectRoot.root);
   const appConfigPath = await findAppConfigPath(projectRoot.root);
@@ -244260,6 +244242,11 @@ function getAppClient() {
     prefixUrl: new URL(`/api/apps/${id}/`, getBase44ApiUrl()).href
   });
 }
+function getSandboxClient(appId) {
+  return base44Client.extend({
+    prefixUrl: new URL(`/api/apps/${appId}/sandbox-bridge/`, getBase44ApiUrl()).href
+  });
+}
 // src/core/clients/oauth-client.ts
 import { randomUUID as randomUUID3 } from "node:crypto";
 var oauthClient = distribution_default.create({
@@ -244451,8 +244438,8 @@ async function ensureAuth(ctx) {
     });
   } catch {}
 }
-async function ensureAppContext(ctx, options = {}) {
-  const appContext = await initAppContext(options);
+async function ensureAppContext(ctx) {
+  const appContext = await initAppContext();
   ctx.app = appContext;
   ctx.errorReporter.setContext({ appId: appContext.id });
 }
@@ -251118,8 +251105,7 @@ class Base44Command extends Command {
           await ensureAuth(this.context);
         }
         if (this._commandOptions.requireAppContext) {
-          const { appId } = this.optsWithGlobals();
-          await ensureAppContext(this.context, { appId });
+          await ensureAppContext(this.context);
         }
         const result = await fn(this.context, ...args) ?? {};
         if (!quiet) {
@@ -251195,7 +251181,7 @@ function createSimpleRunTask(log) {
   };
 }
 // src/cli/utils/stdin.ts
-async function readStdin(flagName = "--stdin") {
+async function readStdin(flagName = "--stdin", options = {}) {
   if (process.stdin.isTTY) {
     throw new InvalidInputError(`${flagName} requires piped input (e.g., echo <value> | base44 ...)`);
   }
@@ -251203,7 +251189,8 @@ async function readStdin(flagName = "--stdin") {
   for await (const chunk of process.stdin) {
     chunks.push(chunk);
   }
-  return Buffer.concat(chunks).toString("utf-8").trim();
+  const text = Buffer.concat(chunks).toString("utf-8");
+  return options.trim === false ? text : text.trim();
 }
 
 // src/cli/utils/secret-input.ts
@@ -253088,11 +253075,7 @@ function printProjectSummary({ name: name2, dashboardUrl, appUrl }, log) {
 }
 
 // src/cli/commands/project/create.ts
-function validateCreateOptions(command2) {
-  const { appId } = command2.optsWithGlobals();
-  if (appId !== undefined) {
-    command2.error(`base44 create cannot be used with --app-id or ${BASE44_APP_ID_ENV_VAR}.`);
-  }
+function validateNonInteractiveFlags(command2) {
   const { path: path17 } = command2.opts();
   if (path17 && !command2.args.length) {
     command2.error("--path requires a project name argument. Usage: base44 create <name> --path <path>");
@@ -253209,7 +253192,7 @@ function getCreateCommand() {
 Examples:
   $ base44 create my-app                                         Creates a base44 project at ./my-app
   $ base44 create my-todo-app --template backend-and-client      Creates a base44 backend-and-client project at ./my-todo-app
-  $ base44 create my-app --path ./projects/my-app --deploy       Creates a base44 project at ./project/my-app and deploys it`).hook("preAction", validateCreateOptions).action(createAction);
+  $ base44 create my-app --path ./projects/my-app --deploy       Creates a base44 project at ./project/my-app and deploys it`).hook("preAction", validateNonInteractiveFlags).action(createAction);
 }
 
 // src/cli/commands/project/deploy.ts
@@ -253305,32 +253288,11 @@ function printStripeResult(r, log) {
   log.info(`  Connectors dashboard: ${theme.colors.links(getConnectorsUrl())}`);
 }
 
-// src/cli/commands/project/app-id-options.ts
-function readExplicitAppId(command2) {
-  const { appId } = command2.optsWithGlobals();
-  const { projectId } = command2.opts();
-  const explicitAppId = command2.getOptionValueSourceWithGlobals("appId") === "cli" ? appId : undefined;
-  const legacyProjectId = command2.getOptionValueSource("projectId") === "cli" ? projectId : undefined;
-  return {
-    appId: explicitAppId,
-    legacyProjectId,
-    value: explicitAppId ?? legacyProjectId
-  };
-}
-
 // src/cli/commands/project/link.ts
-function validateNonInteractiveFlags(command2) {
-  const { create: create4, name: name2 } = command2.opts();
-  const {
-    appId,
-    legacyProjectId,
-    value: selectedAppId
-  } = readExplicitAppId(command2);
-  if (appId && legacyProjectId) {
-    command2.error("--app-id and --project-id cannot be used together");
-  }
-  if (create4 && selectedAppId) {
-    command2.error("--create and --app-id cannot be used together");
+function validateNonInteractiveFlags2(command2) {
+  const { create: create4, name: name2, projectId } = command2.opts();
+  if (create4 && projectId) {
+    command2.error("--create and --projectId cannot be used together");
   }
   if (create4 && !name2) {
     command2.error("--name is required when using --create");
@@ -253399,12 +253361,11 @@ async function promptForExistingProject(linkableProjects) {
   }
   return selectedProject;
 }
-async function link(ctx, options, command2) {
+async function link(ctx, options) {
   const { log, runTask: runTask2, isNonInteractive } = ctx;
-  const appId = readExplicitAppId(command2).value;
-  const skipPrompts = !!options.create || !!appId;
+  const skipPrompts = !!options.create || !!options.projectId;
   if (!skipPrompts && isNonInteractive) {
-    throw new InvalidInputError("--create with --name, or --app-id, is required in non-interactive mode");
+    throw new InvalidInputError("--create with --name, or --projectId, is required in non-interactive mode");
   }
   const projectRoot = findProjectRoot();
   if (!projectRoot) {
@@ -253419,8 +253380,8 @@ async function link(ctx, options, command2) {
       ]
     });
   }
-  let finalAppId;
-  const action = appId ? "choose" : options.create ? "create" : await promptForLinkAction();
+  let finalProjectId;
+  const action = options.projectId ? "choose" : options.create ? "create" : await promptForLinkAction();
   if (action === "choose") {
     const projects = await runTask2("Fetching projects...", async () => listProjects(), {
       successMessage: "Projects fetched",
@@ -253430,32 +253391,32 @@ async function link(ctx, options, command2) {
     if (!linkableProjects.length) {
       return { outroMessage: "No projects available for linking" };
     }
-    let linkedAppId;
-    if (appId) {
-      const project2 = linkableProjects.find((p) => p.id === appId);
+    let projectId;
+    if (options.projectId) {
+      const project2 = linkableProjects.find((p) => p.id === options.projectId);
       if (!project2) {
-        throw new InvalidInputError(`App with ID "${appId}" not found or not available for linking.`, {
+        throw new InvalidInputError(`Project with ID "${options.projectId}" not found or not available for linking.`, {
           hints: [
-            { message: "Check the app ID is correct" },
+            { message: "Check the project ID is correct" },
             {
-              message: "Use 'base44 link' without --app-id to see available projects"
+              message: "Use 'base44 link' without --projectId to see available projects"
             }
           ]
         });
       }
-      linkedAppId = appId;
+      projectId = options.projectId;
     } else {
       const selectedProject = await promptForExistingProject(linkableProjects);
-      linkedAppId = selectedProject.id;
+      projectId = selectedProject.id;
     }
     await runTask2("Linking project...", async () => {
-      await writeAppConfig(projectRoot.root, linkedAppId);
-      setAppContext({ id: linkedAppId, projectRoot: projectRoot.root });
+      await writeAppConfig(projectRoot.root, projectId);
+      setAppContext({ id: projectId, projectRoot: projectRoot.root });
     }, {
       successMessage: "Project linked successfully",
       errorMessage: "Failed to link project"
     });
-    finalAppId = linkedAppId;
+    finalProjectId = projectId;
   }
   if (action === "create") {
     const { name: name2, description } = options.create ? { name: options.name.trim(), description: options.description?.trim() } : await promptForNewProjectDetails();
@@ -253467,15 +253428,13 @@ async function link(ctx, options, command2) {
     });
     await writeAppConfig(projectRoot.root, projectId);
     setAppContext({ id: projectId, projectRoot: projectRoot.root });
-    finalAppId = projectId;
+    finalProjectId = projectId;
   }
-  log.message(`${theme.styles.header("Dashboard")}: ${theme.colors.links(getDashboardUrl(finalAppId))}`);
+  log.message(`${theme.styles.header("Dashboard")}: ${theme.colors.links(getDashboardUrl(finalProjectId))}`);
   return { outroMessage: "Project linked" };
 }
 function getLinkCommand() {
-  return new Base44Command("link", {
-    requireAppContext: false
-  }).description("Link a local project to a Base44 project (create new or link existing)").configureHelp({ showGlobalOptions: true }).option("-c, --create", "Create a new project (skip selection prompt)").option("-n, --name <name>", "Project name (required when --create is used)").option("-d, --description <description>", "Project description").addOption(new Option("-p, --project-id <id>", "Project ID to link to an existing project").hideHelp()).addOption(new Option("--projectId <id>", "Project ID to link to an existing project").hideHelp()).hook("preAction", validateNonInteractiveFlags).action(link);
+  return new Base44Command("link", { requireAppContext: false }).description("Link a local project to a Base44 project (create new or link existing)").option("-c, --create", "Create a new project (skip selection prompt)").option("-n, --name <name>", "Project name (required when --create is used)").option("-d, --description <description>", "Project description").option("-p, --projectId <id>", "Project ID to link to an existing project (skips selection prompt)").hook("preAction", validateNonInteractiveFlags2).action(link);
 }
 
 // src/cli/commands/project/logs.ts
@@ -253565,12 +253524,8 @@ async function fetchLogsForFunctions(functionNames, options, availableFunctionNa
   }
   return allEntries;
 }
-async function getProjectFunctionNames(projectRoot) {
-  const { functions } = await readProjectConfig(projectRoot);
-  return functions.map((fn) => fn.name);
-}
-async function getRemoteFunctionNames() {
-  const { functions } = await listDeployedFunctions();
+async function getAllFunctionNames() {
+  const { functions } = await readProjectConfig();
   return functions.map((fn) => fn.name);
 }
 function validateLimit(limit) {
@@ -253581,18 +253536,15 @@ function validateLimit(limit) {
     throw new InvalidInputError(`Invalid limit: "${limit}". Must be a number between 1 and 1000.`);
   }
 }
-async function logsAction(ctx, options) {
+async function logsAction(_ctx, options) {
   validateLimit(options.limit);
   const specifiedFunctions = parseFunctionNames(options.function);
-  const localProjectRoot = ctx.app?.projectRoot;
-  const availableFunctionNames = localProjectRoot ? await getProjectFunctionNames(localProjectRoot) : await getRemoteFunctionNames();
-  const functionNames = specifiedFunctions.length > 0 ? specifiedFunctions : availableFunctionNames;
+  const allProjectFunctions = await getAllFunctionNames();
+  const functionNames = specifiedFunctions.length > 0 ? specifiedFunctions : allProjectFunctions;
   if (functionNames.length === 0) {
-    return {
-      outroMessage: localProjectRoot ? "No functions found in this project." : "No functions found in this app."
-    };
+    return { outroMessage: "No functions found in this project." };
   }
-  let entries = await fetchLogsForFunctions(functionNames, options, availableFunctionNames);
+  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);
@@ -253608,20 +253560,17 @@ function getLogsCommand() {
 // src/cli/commands/project/scaffold.ts
 import { basename as basename5, resolve as resolve6 } from "node:path";
 function resolveAppId(options) {
-  const appId = options.appId;
+  const appId = options.appId ?? process.env.BASE44_APP_ID;
   if (!appId) {
     throw new InvalidInputError("No app ID found. `base44 scaffold` sets up a local project for an existing Base44 app.", {
-      hints: [
-        { message: "Pass it explicitly with --app-id <id>" },
-        { message: `Set ${BASE44_APP_ID_ENV_VAR} in your environment` }
-      ]
+      hints: [{ message: "Pass it explicitly with --app-id <id>" }]
     });
   }
   return appId;
 }
-async function scaffoldAction(ctx, name2, options, command2) {
+async function scaffoldAction(ctx, name2, options) {
   const { log, runTask: runTask2 } = ctx;
-  const appId = resolveAppId(command2.optsWithGlobals());
+  const appId = resolveAppId(options);
   const resolvedPath = resolve6("./");
   const projectName = (name2 ?? basename5(resolvedPath)).trim();
   const template2 = await getTemplateById("backend-only");
@@ -253653,12 +253602,308 @@ function getScaffoldCommand() {
   return new Base44Command("scaffold", {
     requireAppContext: false,
     fullBanner: true
-  }).description("Scaffold a local project for an existing Base44 app").addArgument(new Argument("name", "Project name").argOptional()).option("--no-skills", "Skip AI agent skills installation").addHelpText("after", `
+  }).description("Scaffold a local project for an existing Base44 app").addArgument(new Argument("name", "Project name").argOptional()).option("--app-id <id>", "Existing Base44 app ID").option("--no-skills", "Skip AI agent skills installation").addHelpText("after", `
 Examples:
   $ base44 scaffold --app-id app_123         Scaffolds the current dir for the given app
   $ base44 scaffold my-app --app-id app_123  Scaffolds the current dir, named "my-app"`).action(scaffoldAction);
 }
 
+// src/core/resources/sandbox/schema.ts
+var FileErrorSchema = exports_external.object({
+  code: exports_external.string(),
+  message: exports_external.string()
+});
+var ReadFileEntrySchema = exports_external.object({
+  path: exports_external.string(),
+  content: exports_external.string().optional(),
+  start_line: exports_external.number().optional(),
+  end_line: exports_external.number().optional(),
+  total_lines: exports_external.number().optional(),
+  truncated: exports_external.boolean().optional(),
+  error: FileErrorSchema.optional()
+}).transform((data) => ({
+  path: data.path,
+  content: data.content,
+  startLine: data.start_line,
+  endLine: data.end_line,
+  totalLines: data.total_lines,
+  truncated: data.truncated,
+  error: data.error
+}));
+var ReadFileResponseSchema = exports_external.object({
+  files: exports_external.array(ReadFileEntrySchema)
+});
+var WriteFileResponseSchema = exports_external.object({
+  path: exports_external.string(),
+  bytes_written: exports_external.number(),
+  created: exports_external.boolean(),
+  overwritten: exports_external.boolean()
+}).transform((data) => ({
+  path: data.path,
+  bytesWritten: data.bytes_written,
+  created: data.created,
+  overwritten: data.overwritten
+}));
+var EditFileResponseSchema = exports_external.object({
+  path: exports_external.string(),
+  diff: exports_external.string(),
+  applied: exports_external.boolean()
+});
+var GrepMatchSchema = exports_external.object({
+  path: exports_external.string().nullable(),
+  line: exports_external.number().nullable(),
+  text: exports_external.string()
+});
+var GrepResponseSchema = exports_external.object({
+  matches: exports_external.array(GrepMatchSchema),
+  truncated: exports_external.boolean(),
+  returned_matches: exports_external.number()
+}).transform((data) => ({
+  matches: data.matches,
+  truncated: data.truncated,
+  returnedMatches: data.returned_matches
+}));
+var DirectoryEntrySchema = exports_external.object({
+  name: exports_external.string(),
+  path: exports_external.string(),
+  type: exports_external.enum(["file", "directory"]),
+  size: exports_external.number().optional()
+});
+var ListDirectoryResponseSchema = exports_external.object({
+  entries: exports_external.array(DirectoryEntrySchema),
+  truncated: exports_external.boolean()
+});
+var RunCommandResponseSchema = exports_external.object({
+  stdout: exports_external.string(),
+  stderr: exports_external.string(),
+  exit_code: exports_external.number(),
+  truncated: exports_external.boolean(),
+  duration_ms: exports_external.number()
+}).transform((data) => ({
+  stdout: data.stdout,
+  stderr: data.stderr,
+  exitCode: data.exit_code,
+  truncated: data.truncated,
+  durationMs: data.duration_ms
+}));
+var ReleaseResponseSchema = exports_external.object({
+  app_id: exports_external.string(),
+  released: exports_external.boolean()
+}).transform((data) => ({
+  appId: data.app_id,
+  released: data.released
+}));
+
+// src/core/resources/sandbox/api.ts
+async function callTool(appId, tool, payload, schema10, context, timeout2 = 60000) {
+  const client = getSandboxClient(appId);
+  let response;
+  try {
+    response = await client.post(tool, { json: payload, timeout: timeout2 });
+  } catch (error48) {
+    throw await ApiError.fromHttpError(error48, context);
+  }
+  const result = schema10.safeParse(await response.json());
+  if (!result.success) {
+    throw new SchemaValidationError("Invalid response from server", result.error);
+  }
+  return result.data;
+}
+function listDirectory(appId, params) {
+  return callTool(appId, "list_directory", { ...params }, ListDirectoryResponseSchema, "listing directory");
+}
+function readFile2(appId, params) {
+  return callTool(appId, "read_file", { ...params }, ReadFileResponseSchema, "reading file");
+}
+function writeFile2(appId, params) {
+  return callTool(appId, "write_file", { ...params }, WriteFileResponseSchema, `writing file "${params.path}"`);
+}
+function editFile(appId, params) {
+  return callTool(appId, "edit_file", { ...params }, EditFileResponseSchema, `editing file "${params.path}"`);
+}
+function grep(appId, params) {
+  return callTool(appId, "grep", { ...params }, GrepResponseSchema, "searching files");
+}
+function runCommand(appId, params) {
+  return callTool(appId, "run_command", { ...params }, RunCommandResponseSchema, "running command", false);
+}
+function releaseSession(appId) {
+  return callTool(appId, "release", {}, ReleaseResponseSchema, "releasing sandbox session");
+}
+
+// src/cli/commands/sandbox/shared.ts
+async function resolveAppId2(options) {
+  const explicit = options.appId ?? process.env.BASE44_APP_ID;
+  if (explicit) {
+    return explicit;
+  }
+  try {
+    const { id } = await initAppContext();
+    return id;
+  } catch {
+    throw new InvalidInputError("No app ID found. Sandbox commands operate on a remote app.", {
+      hints: [
+        { message: "Pass it explicitly with --app-id <id>" },
+        { message: "Or run from a linked Base44 project directory" }
+      ]
+    });
+  }
+}
+async function resolveFlagOrStdin(flagValue, flagName) {
+  if (flagValue !== undefined) {
+    return flagValue;
+  }
+  if (process.stdin.isTTY) {
+    throw new InvalidInputError(`Provide ${flagName} or pipe the value via stdin (e.g. echo <value> | base44 sandbox ...).`);
+  }
+  return readStdin(flagName, { trim: false });
+}
+function toJsonStdout(result) {
+  return `${JSON.stringify(result, null, 2)}
+`;
+}
+function parsePositiveInt(value, flagName) {
+  if (value === undefined) {
+    return;
+  }
+  const n2 = Number.parseInt(value, 10);
+  if (!Number.isInteger(n2) || n2 < 1) {
+    throw new InvalidInputError(`${flagName} must be a positive integer.`);
+  }
+  return n2;
+}
+
+// src/cli/commands/sandbox/edit-file.ts
+var EditsInputSchema = exports_external.array(exports_external.object({
+  old_text: exports_external.string().min(1),
+  new_text: exports_external.string(),
+  replace_all: exports_external.boolean().optional()
+})).min(1);
+function parseEdits(raw2) {
+  let parsed;
+  try {
+    parsed = JSON.parse(raw2);
+  } catch {
+    throw new InvalidInputError("--edits-json must be valid JSON (an array of { old_text, new_text, replace_all? }).");
+  }
+  const result = EditsInputSchema.safeParse(parsed);
+  if (!result.success) {
+    throw new InvalidInputError("Invalid edits: expected a non-empty array of { old_text (non-empty string), new_text (string), replace_all? (boolean) }.");
+  }
+  return result.data;
+}
+async function editFileAction({ runTask: runTask2 }, path17, options) {
+  const appId = await resolveAppId2(options);
+  const raw2 = await resolveFlagOrStdin(options.editsJson, "--edits-json");
+  const edits = parseEdits(raw2);
+  const result = await runTask2(options.dryRun ? "Previewing edit" : "Editing file", () => editFile(appId, { path: path17, edits, dry_run: options.dryRun }));
+  return {
+    outroMessage: options.dryRun ? "Previewed edit" : "Edited file",
+    stdout: toJsonStdout(result)
+  };
+}
+function getSandboxEditFileCommand() {
+  return new Base44Command("edit-file", { requireAppContext: false }).description("Apply exact old→new string edits to a file in the sandbox").argument("<path>", "File path relative to the app root").option("--edits-json <json>", "JSON array of edits (if omitted, read from stdin)").option("--dry-run", "Return the unified diff without writing").option("--app-id <id>", "Target app ID (defaults to the current app)").addHelpText("after", `
+Each edit is { "old_text": "...", "new_text": "...", "replace_all"?: true }.
+
+Examples:
+  $ echo '[{"old_text":"foo","new_text":"bar"}]' | base44 sandbox edit-file src/x.ts
+  $ base44 sandbox edit-file src/x.ts --dry-run --edits-json '[{"old_text":"a","new_text":"b","replace_all":true}]'`).action(editFileAction);
+}
+
+// src/cli/commands/sandbox/grep.ts
+async function grepAction({ runTask: runTask2 }, pattern, options) {
+  const appId = await resolveAppId2(options);
+  const maxResults = parsePositiveInt(options.maxResults, "--max-results");
+  const result = await runTask2("Searching files", () => grep(appId, {
+    pattern,
+    path: options.path,
+    is_regex: options.regex,
+    case_sensitive: options.caseSensitive,
+    glob: options.glob,
+    max_results: maxResults
+  }));
+  return { outroMessage: "Searched files", stdout: toJsonStdout(result) };
+}
+function getSandboxGrepCommand() {
+  return new Base44Command("grep", { requireAppContext: false }).description("Search files for a pattern in an app's remote sandbox").argument("<pattern>", "Search pattern").option("--path <path>", "Subtree to search, relative to the app root").option("--no-regex", "Treat the pattern as a literal string, not a regex").option("--case-sensitive", "Case-sensitive match").option("--glob <glob>", 'File glob filter, e.g. "*.tsx"').option("--max-results <n>", "Maximum number of match lines to return").option("--app-id <id>", "Target app ID (defaults to the current app)").action(grepAction);
+}
+
+// src/cli/commands/sandbox/list-directory.ts
+async function listDirectoryAction({ runTask: runTask2 }, path17, options) {
+  const appId = await resolveAppId2(options);
+  const maxDepth = parsePositiveInt(options.maxDepth, "--max-depth");
+  const result = await runTask2("Listing directory", () => listDirectory(appId, {
+    path: path17,
+    recursive: options.recursive,
+    max_depth: maxDepth,
+    include_hidden: options.includeHidden
+  }));
+  return { outroMessage: "Listed directory", stdout: toJsonStdout(result) };
+}
+function getSandboxListDirectoryCommand() {
+  return new Base44Command("list-directory", { requireAppContext: false }).description("List directory entries in an app's remote sandbox").argument("[path]", "Directory relative to the app root (default: app root)").option("--recursive", "List nested entries").option("--max-depth <n>", "Max depth when recursive (1-10, default 3)").option("--include-hidden", "Include dotfiles").option("--app-id <id>", "Target app ID (defaults to the current app)").action(listDirectoryAction);
+}
+
+// src/cli/commands/sandbox/read-file.ts
+async function readFileAction({ runTask: runTask2 }, paths, options) {
+  const appId = await resolveAppId2(options);
+  const offset = parsePositiveInt(options.offset, "--offset");
+  const limit = parsePositiveInt(options.limit, "--limit");
+  const result = await runTask2("Reading file", () => readFile2(appId, { paths, offset, limit }));
+  return { outroMessage: "Read file", stdout: toJsonStdout(result) };
+}
+function getSandboxReadFileCommand() {
+  return new Base44Command("read-file", { requireAppContext: false }).description("Read file contents from an app's remote sandbox").argument("<paths...>", "One or more file paths relative to the app root").option("--offset <n>", "1-based start line").option("--limit <n>", "Max lines to return from offset").option("--app-id <id>", "Target app ID (defaults to the current app)").action(readFileAction);
+}
+
+// src/cli/commands/sandbox/release.ts
+async function releaseAction({ runTask: runTask2 }, options) {
+  const appId = await resolveAppId2(options);
+  const result = await runTask2("Releasing sandbox session", () => releaseSession(appId));
+  return {
+    outroMessage: "Released sandbox session",
+    stdout: toJsonStdout(result)
+  };
+}
+function getSandboxReleaseCommand() {
+  return new Base44Command("release", { requireAppContext: false }).description("Release the external-agent session so the in-app builder can resume").option("--app-id <id>", "Target app ID (defaults to the current app)").action(releaseAction);
+}
+
+// src/cli/commands/sandbox/run-command.ts
+async function runCommandAction({ runTask: runTask2 }, commandParts, options) {
+  const appId = await resolveAppId2(options);
+  const timeoutMs = parsePositiveInt(options.timeoutMs, "--timeout-ms");
+  const command2 = commandParts.join(" ");
+  const result = await runTask2("Running command", () => runCommand(appId, { command: command2, cwd: options.cwd, timeout_ms: timeoutMs }));
+  return { outroMessage: "Ran command", stdout: toJsonStdout(result) };
+}
+function getSandboxRunCommandCommand() {
+  return new Base44Command("run-command", { requireAppContext: false }).description("Run a shell command in an app's remote sandbox").argument("<command...>", "Shell command to execute (quote to keep as one)").option("--cwd <path>", "Working directory relative to the app root").option("--timeout-ms <n>", "Timeout in milliseconds (default 120000, max 600000)").option("--app-id <id>", "Target app ID (defaults to the current app)").addHelpText("after", `
+Examples:
+  $ base44 sandbox run-command "npm test"
+  $ base44 sandbox run-command ls -la --cwd src`).action(runCommandAction);
+}
+
+// src/cli/commands/sandbox/write-file.ts
+async function writeFileAction({ runTask: runTask2 }, path17, options) {
+  const appId = await resolveAppId2(options);
+  const content = await resolveFlagOrStdin(options.content, "--content");
+  const result = await runTask2("Writing file", () => writeFile2(appId, { path: path17, content, overwrite: options.overwrite }));
+  return { outroMessage: "Wrote file", stdout: toJsonStdout(result) };
+}
+function getSandboxWriteFileCommand() {
+  return new Base44Command("write-file", { requireAppContext: false }).description("Create or overwrite a file in an app's remote sandbox").argument("<path>", "File path relative to the app root").option("--content <content>", "File content (if omitted, read from stdin)").option("--overwrite", "Overwrite the file if it already exists").option("--app-id <id>", "Target app ID (defaults to the current app)").addHelpText("after", `
+Examples:
+  $ echo "hello" | base44 sandbox write-file notes.txt
+  $ base44 sandbox write-file notes.txt --content "hello" --overwrite`).action(writeFileAction);
+}
+
+// src/cli/commands/sandbox/index.ts
+function getSandboxCommand() {
+  return new Command("sandbox").description("Develop an app remotely via its server-side sandbox").addCommand(getSandboxListDirectoryCommand()).addCommand(getSandboxReadFileCommand()).addCommand(getSandboxWriteFileCommand()).addCommand(getSandboxEditFileCommand()).addCommand(getSandboxGrepCommand()).addCommand(getSandboxRunCommandCommand()).addCommand(getSandboxReleaseCommand());
+}
+
 // src/cli/commands/secrets/delete.ts
 async function deleteSecretAction({ runTask: runTask2 }, key) {
   await runTask2(`Deleting secret "${key}"`, async () => {
@@ -257409,10 +257654,7 @@ function readStdin2() {
     process.stdin.on("error", reject);
   });
 }
-async function execAction({
-  app,
-  isNonInteractive
-}) {
+async function execAction(isNonInteractive) {
   const noInputError = new InvalidInputError("No input provided. Pipe a script to stdin.", {
     hints: [
       { message: "File:  cat ./script.ts | base44 exec" },
@@ -257428,7 +257670,7 @@ async function execAction({
   if (!code2.trim()) {
     throw noInputError;
   }
-  const { exitCode } = await runScript({ appId: app.id, code: code2 });
+  const { exitCode } = await runScript({ appId: getAppContext().id, code: code2 });
   if (exitCode !== 0) {
     process.exitCode = exitCode;
   }
@@ -257441,26 +257683,18 @@ Examples:
     $ cat ./script.ts | base44 exec
 
   Inline script:
-    $ echo "const users = await base44.entities.User.list()" | base44 exec`).action(async (ctx) => {
-    return await execAction(ctx);
+    $ echo "const users = await base44.entities.User.list()" | base44 exec`).action(async ({ isNonInteractive }) => {
+    return await execAction(isNonInteractive);
   });
 }
 
 // src/cli/commands/project/eject.ts
 import { resolve as resolve12 } from "node:path";
 var import_kebabCase2 = __toESM(require_kebabCase(), 1);
-async function eject(ctx, options8, command2) {
+async function eject(ctx, options8) {
   const { log, runTask: runTask2, isNonInteractive } = ctx;
-  const {
-    appId,
-    legacyProjectId,
-    value: selectedAppId
-  } = readExplicitAppId(command2);
-  if (appId && legacyProjectId) {
-    throw new InvalidInputError("--app-id and --project-id cannot be used together");
-  }
-  if (isNonInteractive && !selectedAppId) {
-    throw new InvalidInputError("--app-id is required in non-interactive mode");
+  if (isNonInteractive && !options8.projectId) {
+    throw new InvalidInputError("--project-id is required in non-interactive mode");
   }
   if (isNonInteractive && !options8.path) {
     throw new InvalidInputError("--path is required in non-interactive mode");
@@ -257468,13 +257702,13 @@ async function eject(ctx, options8, command2) {
   const projects = await listProjects();
   const ejectableProjects = projects.filter((p4) => p4.isManagedSourceCode !== false);
   let selectedProject;
-  if (selectedAppId) {
-    const foundProject = ejectableProjects.find((p4) => p4.id === selectedAppId);
+  if (options8.projectId) {
+    const foundProject = ejectableProjects.find((p4) => p4.id === options8.projectId);
     if (!foundProject) {
-      throw new InvalidInputError(`App with ID "${selectedAppId}" not found or not ejectable`, {
+      throw new InvalidInputError(`Project with ID "${options8.projectId}" not found or not ejectable`, {
         hints: [
           {
-            message: "Run 'base44 eject' without --app-id to see available projects"
+            message: "Run 'base44 eject' without --project-id to see available projects"
           }
         ]
       });
@@ -257550,15 +257784,13 @@ async function eject(ctx, options8, command2) {
   return { outroMessage: "Your new project is set and ready to use" };
 }
 function getEjectCommand() {
-  return new Base44Command("eject", {
-    requireAppContext: false
-  }).description("Download the code for an existing Base44 project").configureHelp({ showGlobalOptions: true }).option("-p, --path <path>", "Path where to write the project").option("-y, --yes", "Skip confirmation prompts").addOption(new Option("--project-id <id>", "Project ID to eject (skips interactive selection)").hideHelp()).action(eject);
+  return new Base44Command("eject", { requireAppContext: false }).description("Download the code for an existing Base44 project").option("-p, --path <path>", "Path where to write the project").option("--project-id <id>", "Project ID to eject (skips interactive selection)").option("-y, --yes", "Skip confirmation prompts").action(eject);
 }
 
 // src/cli/program.ts
 function createProgram(context) {
   const program2 = new Command;
-  program2.name("base44").description("Base44 CLI - Unified interface for managing Base44 applications").version(package_default.version).addOption(new Option("--app-id <id>", "Base44 app ID to use").env(BASE44_APP_ID_ENV_VAR));
+  program2.name("base44").description("Base44 CLI - Unified interface for managing Base44 applications").version(package_default.version);
   program2.configureHelp({
     sortSubcommands: true
   });
@@ -257581,6 +257813,7 @@ function createProgram(context) {
   program2.addCommand(getConnectorsCommand());
   program2.addCommand(getFunctionsCommand());
   program2.addCommand(getSecretsCommand());
+  program2.addCommand(getSandboxCommand());
   program2.addCommand(getAuthCommand());
   program2.addCommand(getSiteCommand());
   program2.addCommand(getTypesCommand());
@@ -261832,4 +262065,4 @@ export {
   CLIExitError
 };
 
-//# debugId=01B7F20ACA5BBEAF64756E2164756E21
+//# debugId=61B9F8E330C194E064756E2164756E21