@base44-preview/cli 0.0.55-pr.545.e6bf97b → 0.0.55-pr.547.7e43787

package/README.md

@@ -60,6 +60,13 @@ The CLI will guide you through project setup. For step-by-step tutorials, see th
 | [`secrets list`](https://docs.base44.com/developers/references/cli/commands/secrets-list) | List project secret names |
 | [`secrets set`](https://docs.base44.com/developers/references/cli/commands/secrets-set) | Set one or more project secrets |
 | [`secrets delete`](https://docs.base44.com/developers/references/cli/commands/secrets-delete) | Delete a project secret |
+| [`sandbox list-directory`](https://docs.base44.com/developers/references/cli/commands/sandbox-list-directory) | List directory entries in an app's remote sandbox |
+| [`sandbox read-file`](https://docs.base44.com/developers/references/cli/commands/sandbox-read-file) | Read file contents from an app's remote sandbox |
+| [`sandbox write-file`](https://docs.base44.com/developers/references/cli/commands/sandbox-write-file) | Create or overwrite a file in an app's remote sandbox |
+| [`sandbox edit-file`](https://docs.base44.com/developers/references/cli/commands/sandbox-edit-file) | Apply exact old→new string edits to a file in the sandbox |
+| [`sandbox grep`](https://docs.base44.com/developers/references/cli/commands/sandbox-grep) | Search files for a pattern in an app's remote sandbox |
+| [`sandbox run-command`](https://docs.base44.com/developers/references/cli/commands/sandbox-run-command) | Run a shell command in an app's remote sandbox |
+| [`sandbox release`](https://docs.base44.com/developers/references/cli/commands/sandbox-release) | Release the external-agent session so the in-app builder can resume |
 | [`site deploy`](https://docs.base44.com/developers/references/cli/commands/site-deploy) | Deploy built site files to Base44 hosting |
 | [`site open`](https://docs.base44.com/developers/references/cli/commands/site-open) | Open the published site in your browser |
 | [`types generate`](https://docs.base44.com/developers/references/cli/commands/types-generate) | Generate TypeScript types from project resources |

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);
@@ -244242,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({
@@ -251176,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 ...)`);
   }
@@ -251184,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
@@ -253602,6 +253608,302 @@ Examples:
   $ 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 () => {
@@ -253898,6 +254200,7 @@ function getTypesCommand() {
 
 // src/cli/commands/dev.ts
 import { join as join28 } from "node:path";
+import process21 from "node:process";
 
 // src/cli/dev/dev-server/main.ts
 var import_cors = __toESM(require_lib4(), 1);
@@ -254054,11 +254357,12 @@ var stringify = (item) => {
     return String(item);
   }
 };
-function createDevLogger(label2, labelColor = theme.styles.dim) {
-  const prefix = label2 ? `${labelColor(`[${label2}]`)} ` : "";
+function createDevLogger() {
   const print = (type, ...args) => {
     const colorize = colorByType[type];
-    console[type](prefix + args.map((item) => colorize(stringify(item))).join(" "));
+    console[type](...args.map((item) => {
+      return colorize(stringify(item));
+    }));
   };
   return {
     log: (...args) => print("log", ...args),
@@ -255425,92 +255729,6 @@ function createCustomIntegrationRoutes(remoteProxy, logger2) {
   return router;
 }
 
-// src/cli/dev/dev-server/serve-runner.ts
-import { spawn as spawn3 } from "node:child_process";
-import process21 from "node:process";
-
-class ServeRunner {
-  command;
-  cwd;
-  env;
-  logger;
-  child;
-  stopping = false;
-  exitListeners = [];
-  constructor(options8) {
-    this.command = options8.command;
-    this.cwd = options8.cwd;
-    this.env = options8.env;
-    this.logger = options8.logger;
-  }
-  start() {
-    if (this.child) {
-      return;
-    }
-    const child = spawn3(this.command, {
-      cwd: this.cwd,
-      shell: true,
-      detached: process21.platform !== "win32",
-      env: { ...process21.env, ...this.env },
-      stdio: ["inherit", "pipe", "pipe"]
-    });
-    this.child = child;
-    this.setupHandlers(child);
-  }
-  onExit(listener) {
-    this.exitListeners.push(listener);
-  }
-  async stop() {
-    const child = this.child;
-    if (!child || child.exitCode !== null) {
-      return;
-    }
-    this.stopping = true;
-    const exited = new Promise((resolve10) => child.once("exit", () => resolve10()));
-    if (process21.platform === "win32" && child.pid) {
-      spawn3("taskkill", ["/pid", String(child.pid), "/T", "/F"]);
-    } else if (child.pid) {
-      try {
-        process21.kill(-child.pid, "SIGTERM");
-      } catch {
-        child.kill();
-      }
-    }
-    await exited;
-  }
-  setupHandlers(child) {
-    child.stdout?.on("data", (data) => this.emitLines(data, "log"));
-    child.stderr?.on("data", (data) => this.emitLines(data, "error"));
-    child.on("error", (error48) => {
-      this.logger.error("Frontend dev server failed to start:", error48);
-      this.notifyExit(null);
-    });
-    child.on("exit", (code2) => {
-      if (this.stopping) {
-        return;
-      }
-      this.logger.error(`Frontend dev server exited with code ${code2}`);
-      this.notifyExit(code2);
-    });
-  }
-  notifyExit(code2) {
-    for (const listener of this.exitListeners) {
-      listener(code2);
-    }
-  }
-  emitLines(data, type) {
-    const lines = data.toString().trimEnd().split(`
-`);
-    for (const line3 of lines) {
-      if (type === "error") {
-        this.logger.error(line3);
-      } else {
-        this.logger.log(line3);
-      }
-    }
-  }
-}
-
 // src/cli/dev/dev-server/watcher.ts
 import { EventEmitter as EventEmitter4 } from "node:events";
 import { relative as relative6 } from "node:path";
@@ -257234,7 +257452,7 @@ async function createDevServer(options8) {
     }
     next();
   });
-  const devLogger = createDevLogger("backend", theme.styles.info);
+  const devLogger = createDevLogger();
   const functionManager = new FunctionManager(functions, devLogger, options8.denoWrapperPath);
   const functionRoutes = createFunctionRouter(functionManager, devLogger);
   app.use("/api/apps/:appId/functions", functionRoutes);
@@ -257332,31 +257550,14 @@ async function createDevServer(options8) {
     }
   });
   await base44ConfigWatcher.start();
-  let serveRunner;
-  if (options8.serve && project2.site?.serveCommand) {
-    serveRunner = new ServeRunner({
-      command: project2.site.serveCommand,
-      cwd: project2.root,
-      env: {
-        VITE_BASE44_APP_ID: options8.serve.appId,
-        VITE_BASE44_APP_BASE_URL: baseUrl
-      },
-      logger: createDevLogger("frontend", theme.colors.base44Orange)
-    });
-  }
   const shutdown = async () => {
     base44ConfigWatcher.close();
     io6.close();
     await functionManager.stopAll();
-    await serveRunner?.stop();
     server.close();
   };
   process.on("SIGINT", shutdown);
   process.on("SIGTERM", shutdown);
-  serveRunner?.onExit(() => {
-    shutdown().finally(() => process.exit(1));
-  });
-  serveRunner?.start();
   return { port, server };
 }
 
@@ -257364,42 +257565,44 @@ async function createDevServer(options8) {
 function localServerUrl(port) {
   return `http://localhost:${port}`;
 }
-async function writeEnvLocal(projectRoot, port, appId, log) {
+async function writeEnvLocalIfMissing(projectRoot, port, log) {
   const envLocalPath = join28(projectRoot, ".env.local");
+  if (await pathExists(envLocalPath)) {
+    return;
+  }
+  const { id: appId } = await initAppContext();
   await writeFile(envLocalPath, `VITE_BASE44_APP_ID=${appId}
 VITE_BASE44_APP_BASE_URL=${localServerUrl(port)}
 `);
-  log.info("Wrote .env.local with app ID and dev server URL");
+  log.info("Created .env.local with app ID and dev server URL");
 }
 async function devAction({ log }, options8) {
   const port = options8.port ? Number(options8.port) : undefined;
-  const serveEnabled = options8.serve !== false;
   let projectRoot;
-  const appId = serveEnabled || options8.writeEnv ? (await initAppContext()).id : undefined;
   const { port: resolvedPort } = await createDevServer({
     log,
     port,
+    cwd: process21.cwd(),
     denoWrapperPath: getDenoWrapperPath(),
-    serve: serveEnabled && appId ? { appId } : undefined,
     loadResources: async () => {
       const { functions, entities, project: project2 } = await readProjectConfig();
       projectRoot = project2.root;
       return { functions, entities, project: project2 };
     }
   });
-  if (options8.writeEnv && projectRoot && appId) {
-    await writeEnvLocal(projectRoot, resolvedPort, appId, log);
+  if (projectRoot) {
+    await writeEnvLocalIfMissing(projectRoot, resolvedPort, log);
   }
   return {
     outroMessage: `Dev server is available at ${theme.colors.links(localServerUrl(resolvedPort))}`
   };
 }
 function getDevCommand() {
-  return new Base44Command("dev").description("Start the development server").option("-p, --port <number>", "Port for the development server").option("--no-serve", "Do not start the frontend dev server (serveCommand)").option("--write-env", "Write the app ID and dev server URL to .env.local").action(devAction);
+  return new Base44Command("dev").description("Start the development server").option("-p, --port <number>", "Port for the development server").action(devAction);
 }
 
 // src/core/exec/run-script.ts
-import { spawn as spawn4 } from "node:child_process";
+import { spawn as spawn3 } from "node:child_process";
 import { copyFileSync, writeFileSync as writeFileSync2 } from "node:fs";
 async function runScript(options8) {
   const { appId, code: code2 } = options8;
@@ -257418,7 +257621,7 @@ async function runScript(options8) {
   copyFileSync(getExecWrapperPath(), tempWrapper.path);
   try {
     const exitCode = await new Promise((resolvePromise) => {
-      const child = spawn4("deno", ["run", "--allow-all", "--node-modules-dir=auto", tempWrapper.path], {
+      const child = spawn3("deno", ["run", "--allow-all", "--node-modules-dir=auto", tempWrapper.path], {
         env: {
           ...process.env,
           SCRIPT_PATH: scriptPath,
@@ -257610,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());
@@ -261861,4 +262065,4 @@ export {
   CLIExitError
 };
 
-//# debugId=A582415BD965E2EA64756E2164756E21
+//# debugId=61B9F8E330C194E064756E2164756E21