Back to Details

base44-sandbox

Compare original and translation side by side

🇺🇸

Original

English
🇨🇳

Translation

Chinese

Base44 in the Cloud Sandbox

Base44 云沙箱开发

Author Base44 app code inside Base44's cloud sandbox with your own coding agent. There is no local checkout: you read, write, and run files through the sandbox tools (over MCP or the 
base44 sandbox
CLI), and the platform builds and deploys from what you write.
For how to connect to the sandbox (MCP endpoint or the 
base44 sandbox
CLI, the 
read_file
/ 
write_file
/ 
edit_file
/ 
run_command
/ 
grep
/ 
list_directory
/ 
create_checkpoint
tools — which the CLI exposes under shorter names (
sandbox read
/ 
sandbox write
/ 
sandbox edit
/ 
sandbox run
/ 
sandbox grep
/ 
sandbox ls
/ 
sandbox checkpoint
), the edit→preview→verify loop, persistence, and concurrency), use the 
base44-remote-dev
 skill. This skill covers what you can author and how once you are connected.
Check these references first. This skill and its siblings (
base44-remote-dev
, 
base44-sdk
) are the source of truth — consult them before searching the web. See Reference order & the complete README.
使用您自己的编码Agent在Base44云沙箱中编写Base44应用代码。无需本地检出：您可通过沙箱工具（基于MCP或
base44 sandbox
CLI）读取、写入和运行文件，平台会根据您编写的内容进行构建和部署。
如需了解如何连接沙箱（MCP端点或
base44 sandbox
CLI，
read_file
/
write_file
/
edit_file
/
run_command
/
grep
/
list_directory
/
create_checkpoint
工具——CLI中使用更短的命令别名：
sandbox read
/
sandbox write
/
sandbox edit
/
sandbox run
/
sandbox grep
/
sandbox ls
/
sandbox checkpoint
）、编辑→预览→验证流程、持久化及并发机制，请使用**
base44-remote-dev
**技能。本技能将介绍连接成功后，您可创建的内容及具体方法。
请先查阅这些参考资料。本技能及其姊妹技能（
base44-remote-dev
、
base44-sdk
）是权威来源——在搜索网络之前，请先参考它们。详见 参考顺序与完整README。

⚡ The mental model: writing the file is the deploy

⚡ 核心思路：写入文件即完成部署

You are working on a remote app, not a local checkout. The project-level CLI workflow does not apply — never run 
base44 deploy
, 
base44 functions deploy
, 
base44 ... push
, 
base44 create
, or 
base44 scaffold
. They assume a local project and a manual deploy step that does not exist here.
Instead: as soon as you write a resource file into the sandbox — a backend function, an entity, or an agent — the platform deploys/syncs it from there. Your write is auto-committed (~5s debounce) and goes live. You do not run, and must not wait for, any 
deploy
/ 
push
command.
One exception — connectors. OAuth connectors aren't authored as files; they're set up against the remote app by its id, either with the MCP connector tools or with the dedicated, projectless 
base44 connectors
commands (which take 
--app-id
and need no local project). See Connectors below.
You may still use 
run_command
(
sandbox run
in the CLI) for ordinary checks (e.g. 
npm run build
, 
npx tsc --noEmit
, 
npm run lint
) and preview — that is verification, not deployment. See the edit→preview→verify loop in 
base44-remote-dev
.
您正在开发的是远程应用，而非本地检出的项目。项目级CLI工作流不适用——切勿运行
base44 deploy
、
base44 functions deploy
、
base44 ... push
、
base44 create
或
base44 scaffold
命令。这些命令假设存在本地项目及手动部署步骤，而在本场景中这些都不存在。
取而代之的是：一旦您将资源文件（后端函数、实体或Agent）写入沙箱，平台就会从沙箱中部署/同步该文件。您的写入操作会自动提交（约5秒防抖）并生效。您无需运行，也不必等待任何
deploy
/
push
命令。
一个例外——连接器。OAuth连接器并非通过文件编写，而是通过应用ID针对远程应用进行配置，可使用MCP连接器工具或专用的无项目
base44 connectors
命令（需指定
--app-id
，无需本地项目）。详见下方 连接器 部分。
您仍可使用
run_command
（CLI中为
sandbox run
）进行常规检查（例如
npm run build
、
npx tsc --noEmit
、
npm run lint
）和预览——这属于验证操作，而非部署。请查看
base44-remote-dev
技能中的编辑→预览→验证流程。

What you can author today

当前支持创建的资源

ResourceStatus in the sandbox
Backend functions (
base44/functions/
)		✅ Supported — write the files; they deploy from the sandbox.
Entities (
base44/entities/
)		✅ Supported — write the 
.jsonc
schema file; it auto-syncs. No 
entities push
.
Agents (
base44/agents/
)		✅ Supported — write the 
.jsonc
config file; it auto-syncs. No 
agents push
.
Frontend code (
src/…
)		✅ Supported — edit normally; HMR/preview reflects it. Use the 
base44-sdk
 skill for SDK API usage.
Connectors (OAuth integrations)✅ Supported — set up via the connect flow below (MCP tools or 
base44 connectors
), not by writing files.
资源类型沙箱支持状态
后端函数 (
base44/functions/
)		✅ 已支持 — 编写文件即可；文件会从沙箱自动部署。
实体 (
base44/entities/
)		✅ 已支持 — 编写
.jsonc
schema文件；文件会自动同步。无需执行
entities push
。
Agent (
base44/agents/
)		✅ 已支持 — 编写
.jsonc
配置文件；文件会自动同步。无需执行
agents push
。
前端代码 (
src/…
)		✅ 已支持 — 正常编辑即可；HMR/预览会实时反映变更。如需SDK API使用方法，请参考**
base44-sdk
**技能。
连接器（OAuth集成）✅ 已支持 — 通过下方连接流程配置（MCP工具或
base44 connectors
），无需编写文件。

Backend functions

后端函数

Backend functions live in 
base44/functions/
, one directory per function (kebab-case name). In the sandbox you only need to create the 
entry.ts
 file directly under 
base44/functions/<name>/
— no 
function.jsonc
is required (the sandbox infers the function from the directory; the config file is ignored in this mode):
base44/functions/
  process-order/
    entry.ts
Entry file — functions run on Deno (not Node.js), export with 
Deno.serve()
, and use the 
npm:
prefix for npm packages:
typescript
import { createClientFromRequest } from "npm:@base44/sdk";

Deno.serve(async (req) => {
  const base44 = createClientFromRequest(req);   // inherits the caller's auth
  const { orderId } = await req.json();
  const order = await base44.entities.Orders.get(orderId);
  return Response.json({ success: true, order });
});
Conventions:
  • Kebab-case directory and function name; entry typically 
    entry.ts
    .
  • createClientFromRequest(req)
    for a client in the caller's auth context; 
    base44.asServiceRole.…
    for admin-level operations.
  • Read secrets with 
    Deno.env.get("KEY")
    (configured in app settings).
  • Return with 
    Response.json(body, { status })
    ; handle errors and set appropriate status codes.
That's enough to author functions correctly. For deeper detail and more examples (service role, secrets, common mistakes), see the 
base44-cli
skill's reference: 
functions-create.md
 — but ignore its "Deploying Functions" / CLI sections and its 
function.jsonc
 guidance, which assume a local project and do not apply in the sandbox (here you only write 
entry.ts
).
Calling the function from the frontend: 
base44.functions.invoke(name, data)
returns the raw axios response — your function's JSON is on 
.data
 (
const result = res.data
), not the top-level object, and it throws on non-2xx (error body at 
err.response.data
). See the 
base44-sdk
skill's 
functions.md
 for details.
后端函数位于
base44/functions/
目录下，每个函数对应一个短横线命名（kebab-case）的目录。在沙箱中，您只需直接在
base44/functions/<name>/
下创建**
entry.ts
**文件即可——无需
function.jsonc
文件（沙箱会从目录推断函数信息；此模式下配置文件会被忽略）：
base44/functions/
  process-order/
    entry.ts
入口文件——函数运行在Deno（而非Node.js）环境中，需通过
Deno.serve()
导出，并使用
npm:
前缀引入npm包：
typescript
import { createClientFromRequest } from "npm:@base44/sdk";

Deno.serve(async (req) => {
  const base44 = createClientFromRequest(req);   // 继承调用方的认证信息
  const { orderId } = await req.json();
  const order = await base44.entities.Orders.get(orderId);
  return Response.json({ success: true, order });
});
约定：
  • 目录和函数名称使用短横线命名（kebab-case）；入口文件通常为
    entry.ts
    。
  • 使用
    createClientFromRequest(req)
    获取调用方认证上下文的客户端；使用
    base44.asServiceRole.…
    执行管理员级操作。
  • 使用
    Deno.env.get("KEY")
    读取密钥（在应用设置中配置）。
  • 使用
    Response.json(body, { status })
    返回响应；处理错误并设置合适的状态码。
以上内容足以让您正确编写函数。如需更深入的细节和更多示例（服务角色、密钥、常见错误），请查看
base44-cli
技能的参考文档：
functions-create.md
——但请忽略其中的“部署函数”/CLI部分以及**
function.jsonc
**相关指导，这些内容假设存在本地项目，不适用于沙箱环境（在此环境中您只需编写
entry.ts
）。
从前端调用函数：
base44.functions.invoke(name, data)
返回原始axios响应——函数返回的JSON数据位于**
.data
属性中（
const result = res.data
），而非顶层对象；且当响应状态码非2xx时会抛出错误**（错误体位于
err.response.data
）。如需详情，请查看
base44-sdk
技能的
functions.md
。

Entities

实体

One 
.jsonc
file per entity in 
base44/entities/
. Just write the file — it auto-syncs; don't run 
base44 entities push
or 
deploy
.
  • File name: 
    {kebab-case}.jsonc
    — e.g. 
    team-member.jsonc
    for an entity named 
    TeamMember
    .
  • Entity 
    name
    :     PascalCase, alphanumeric only (
    /^[a-zA-Z0-9]+$/
    ).
  • Field names: 
    snake_case
    .
jsonc
// base44/entities/task.jsonc
{
  "name": "Task",
  "type": "object",
  "properties": {
    "title": { "type": "string", "description": "Task title" },
    "status": { "type": "string", "enum": ["todo", "doing", "done"], "default": "todo" },
    "due_date": { "type": "string", "format": "date" },
    "board_id": { "type": "string", "description": "Owning board" }
  },
  "required": ["title"]
}
Field types: 
string
, 
number
, 
integer
, 
boolean
, 
array
, 
object
, 
binary
. String formats include 
date
, 
date-time
, 
email
, 
uri
, 
uuid
, 
file
, 
richtext
. For full schema detail and row-level security (RLS), see the 
base44-cli
references 
entities-create.md
 and 
rls-examples.md
 — but ignore their 
entities push
/ deploy sections; the sandbox syncs the file for you.
每个实体对应
base44/entities/
目录下的一个
.jsonc
文件。只需编写文件——文件会自动同步；切勿运行
base44 entities push
或
deploy
命令。
  • 文件名：
    {短横线命名}.jsonc
    ——例如，名为
    TeamMember
    的实体对应
    team-member.jsonc
    。
  • 实体
    name
    ：大驼峰命名（PascalCase），仅包含字母数字（
    /^[a-zA-Z0-9]+$/
    ）。
  • 字段名：蛇形命名（snake_case）。
jsonc
// base44/entities/task.jsonc
{
  "name": "Task",
  "type": "object",
  "properties": {
    "title": { "type": "string", "description": "任务标题" },
    "status": { "type": "string", "enum": ["todo", "doing", "done"], "default": "todo" },
    "due_date": { "type": "string", "format": "date" },
    "board_id": { "type": "string", "description": "所属看板" }
  },
  "required": ["title"]
}
字段类型包括：
string
、
number
、
integer
、
boolean
、
array
、
object
、
binary
。字符串格式包括
date
、
date-time
、
email
、
uri
、
uuid
、
file
、
richtext
。如需完整的schema细节和行级安全（RLS）相关内容，请查看
base44-cli
技能的参考文档
entities-create.md
和
rls-examples.md
——但请忽略其中的
entities push
/部署部分；沙箱会自动同步文件。

Agents

Agent

One 
.jsonc
file per agent in 
base44/agents/
. Just write the file — it auto-syncs; don't run 
base44 agents push
or 
deploy
.
  • File name: 
    {agent_name}.jsonc
    — e.g. 
    support_agent.jsonc
    .
  • Agent 
    name
    :     
    /^[a-z0-9_]+$/
    (lowercase, underscores, 1–100 chars).
jsonc
// base44/agents/support_agent.jsonc
{
  "name": "support_agent",
  "description": "Brief description of what this agent does",
  "instructions": "Detailed instructions for the agent's behavior",
  "tool_configs": [
    { "entity_name": "tasks", "allowed_operations": ["read", "create", "update", "delete"] },
    { "function_name": "send_email", "description": "Send an email notification" }
  ],
  "whatsapp_greeting": "Hello! How can I help you today?"
}
Required: 
name
, 
description
, 
instructions
. Optional: 
tool_configs
(default 
[]
), 
whatsapp_greeting
. Tool configs are either an entity tool (
entity_name
+ 
allowed_operations
: any of 
read
/
create
/
update
/
delete
) or a backend-function tool (
function_name
+ 
description
). For the full agent schema, see the Agent Schema section of the 
base44-cli
skill's 
SKILL.md
 — but ignore its 
agents push
/ 
agents pull
/ deploy commands, which assume a local project; in the sandbox the file auto-syncs.
每个Agent对应
base44/agents/
目录下的一个
.jsonc
文件。只需编写文件——文件会自动同步；切勿运行
base44 agents push
或
deploy
命令。
  • 文件名：
    {agent_name}.jsonc
    ——例如
    support_agent.jsonc
    。
  • Agent 
    name
    ：
    /^[a-z0-9_]+$/
    （小写字母、下划线，长度1-100字符）。
jsonc
// base44/agents/support_agent.jsonc
{
  "name": "support_agent",
  "description": "该Agent功能的简要描述",
  "instructions": "该Agent行为的详细指令",
  "tool_configs": [
    { "entity_name": "tasks", "allowed_operations": ["read", "create", "update", "delete"] },
    { "function_name": "send_email", "description": "发送邮件通知" }
  ],
  "whatsapp_greeting": "您好！请问我能为您提供什么帮助？"
}
必填字段：
name
、
description
、
instructions
。可选字段：
tool_configs
（默认
[]
）、
whatsapp_greeting
。工具配置可以是实体工具（
entity_name
+ 
allowed_operations
：可选
read
/
create
/
update
/
delete
中的任意组合）或后端函数工具（
function_name
+ 
description
）。如需完整的Agent schema，请查看
base44-cli
技能
SKILL.md
中的Agent Schema部分——但请忽略其中的
agents push
/
agents pull
/部署命令，这些内容假设存在本地项目；在沙箱环境中文件会自动同步。

Connectors (OAuth integrations)

连接器（OAuth集成）

Connectors (Google Calendar, Gmail, Slack, …) give your backend functions tokens to call third-party APIs. In remote-dev there are no connector files to write — you operate on the connector directly against the app by its id. Two surfaces, same backend and same behavior:
Declarative scopes — read before you set. Connecting a connector replaces its scope set with exactly the scopes you pass (it does not merge). Any scope you omit is removed and the user is re-prompted to consent. Always list the connector's current scopes first and pass the complete desired set (the ones you want to keep plus any new ones).
OAuth needs a human. Connecting returns an authorization URL the user must open in a browser to sign in and consent — you cannot complete it yourself. After they finish, re-list to confirm it's connected and to read the granted scopes (a provider may grant fewer than you requested).
连接器（Google日历、Gmail、Slack等）为后端函数提供调用第三方API的令牌。在远程开发场景中，无需编写连接器文件——您只需通过应用ID直接操作远程应用的连接器。有两种操作方式，底层逻辑和行为一致：
声明式权限范围——配置前请阅读。连接连接器会替换其现有的权限范围集合，完全使用您传入的权限范围（不会合并）。任何您未列出的权限范围都会被移除，用户需重新授权同意。请始终先列出连接器当前的权限范围，再传入完整的期望集合（保留现有权限范围 + 添加新权限范围）。
OAuth需要人工操作。连接操作会返回一个授权URL，用户必须在浏览器中打开该URL进行登录和授权——您无法自行完成此步骤。用户完成授权后，重新列出连接器即可确认已连接，并读取已授予的权限范围（服务商可能会授予比您请求更少的权限）。

Over MCP (
base44-remote-dev
transport)

通过MCP（
base44-remote-dev
传输方式）

Two tools, both taking 
appId
. Scopes: 
list_connectors
needs 
apps:read
; 
initiate_connector_connection
needs 
apps:write
(note: not 
sandbox:write
).
  1. list_connectors
     — 
    { appId, integrationTypes? }
    . With no 
    integrationTypes
    , returns the full catalog; each entry has the connector's name, description, whether it's connected, and (if connected) its status and granted scopes. Pass 
    integrationTypes
    for full detail on specific connectors.
  2. initiate_connector_connection
     — 
    { appId, integrationType, scopes, connectionConfig? }
    . 
    scopes
    is the complete desired set (see the declarative-scopes note). Returns either 
    already_authorized: true
    (nothing to do) or a 
    redirect_url
    for the user to open. After they sign in, call 
    list_connectors
    again to verify.
On appId <APP_ID>: call list_connectors to read googlecalendar's current scopes,
then initiate_connector_connection for googlecalendar with the full scope set
(existing + the calendar.events scope I need). Give me the authorization URL.
有两个工具，均需传入
appId
。权限范围：
list_connectors
需要
apps:read
；
initiate_connector_connection
需要
apps:write
（注意：不是
sandbox:write
）。
  1. list_connectors
     — 参数为
    { appId, integrationTypes? }
    。若不传入
    integrationTypes
    ，则返回完整的连接器目录；每个条目包含连接器名称、描述、是否已连接，以及（若已连接）状态和已授予的权限范围。传入
    integrationTypes
    可获取特定连接器的详细信息。
  2. initiate_connector_connection
     — 参数为
    { appId, integrationType, scopes, connectionConfig? }
    。
    scopes
    为完整的期望权限范围集合（请查看声明式权限范围的注意事项）。返回结果要么是
    already_authorized: true
    （无需操作），要么是供用户打开的
    redirect_url
    。用户登录后，再次调用
    list_connectors
    验证连接状态。
针对appId <APP_ID>：调用list_connectors读取googlecalendar的当前权限范围，然后使用完整的权限范围集合（现有权限 + 我需要的calendar.events权限）调用initiate_connector_connection连接googlecalendar。请提供授权URL。

Over the CLI (projectless, 
--app-id
)

通过CLI（无项目，使用
--app-id
）

These 
base44 connectors
subcommands work without a local project — they resolve the app id from 
--app-id
, then 
BASE44_APP_ID
, then a local 
.app.jsonc
. No 
config.jsonc
is required.
bash
undefined
这些
base44 connectors
子命令无需本地项目即可运行——它们会从
--app-id
、
BASE44_APP_ID
环境变量或本地
.app.jsonc
文件中解析应用ID。无需
config.jsonc
文件。
bash
undefined

1. See available integration types for the app

1. 查看应用可用的集成类型

npx base44 connectors list-available --app-id <APP_ID>
npx base44 connectors list-available --app-id <APP_ID>

2. Initialize the connector and start OAuth (sets it to EXACTLY these scopes).

2. 初始化连接器并启动OAuth（将权限范围设置为完全匹配以下列表）。

Non-interactive: prints the authorization URL. Interactive: also opens the

非交互式：打印授权URL。交互式：同时打开浏览器并轮询直到授权完成。

browser and polls until authorized.

—
npx base44 connectors initiate --app-id <APP_ID>
--integration-type googlecalendar
--scopes https://www.googleapis.com/auth/calendar.readonly https://www.googleapis.com/auth/calendar.events
npx base44 connectors initiate --app-id <APP_ID>
--integration-type googlecalendar
--scopes https://www.googleapis.com/auth/calendar.readonly https://www.googleapis.com/auth/calendar.events

3. (optional) Fetch the resulting connector config

3.（可选）获取生成的连接器配置

npx base44 connectors pull --app-id <APP_ID> --dir ./connectors

`--scopes` accepts a space- or comma-separated list. As with MCP, the user must open the printed authorization URL to finish consent; afterwards `list-available` / `pull` reflects the connected state and granted scopes.

> This is the **only** Base44 CLI use that belongs in remote-dev — it targets a remote app by id with no local project and no deploy step. It is not a contradiction of the "no CLI" rule above, which is about local-project/deploy commands.
npx base44 connectors pull --app-id <APP_ID> --dir ./connectors

`--scopes`接受空格或逗号分隔的权限范围列表。与MCP方式相同，用户必须打开打印的授权URL完成授权；之后`list-available`/`pull`命令会反映连接器的连接状态和已授予的权限范围。

> 这是远程开发场景中唯一适用的Base44 CLI用法——它通过ID定位远程应用，无需本地项目和部署步骤。这与上文提到的“禁用CLI”规则并不矛盾，该规则针对的是本地项目/部署命令。

Using a connected connector in code

在代码中使用已连接的连接器

Connecting only authorizes the connector. To actually call the third-party API, fetch its OAuth access token inside a backend function with the service-role connectors module — 
base44.asServiceRole.connectors.getConnection(integrationType)
— and use the returned 
accessToken
(and optional 
connectionConfig
) in your own 
fetch
:
typescript
import { createClientFromRequest } from "npm:@base44/sdk";

Deno.serve(async (req) => {
  const base44 = createClientFromRequest(req);

  // App-scoped OAuth token — backend / service role only.
  const { accessToken, connectionConfig } =
    await base44.asServiceRole.connectors.getConnection("googlecalendar");

  const events = await fetch(
    "https://www.googleapis.com/calendar/v3/calendars/primary/events",
    { headers: { Authorization: `Bearer ${accessToken}` } },
  ).then((r) => r.json());

  return Response.json({ events });
});
Notes: the connector is app-scoped (one connected account shared by all users); Base44 refreshes the token for you; you make the API calls. 
getConnection()
replaces the deprecated 
getAccessToken()
. For the full module reference (signatures, 
connectionConfig
, the list of available services and their type identifiers), see the 
base44-sdk
skill's 
connectors.md
.
连接操作仅完成连接器的授权。要实际调用第三方API，需在后端函数中通过服务角色连接器模块获取OAuth访问令牌——
base44.asServiceRole.connectors.getConnection(integrationType)
——并使用返回的
accessToken
（可选
connectionConfig
）执行自定义
fetch
请求：
typescript
import { createClientFromRequest } from "npm:@base44/sdk";

Deno.serve(async (req) => {
  const base44 = createClientFromRequest(req);

  // 应用级OAuth令牌——仅后端/服务角色可用。
  const { accessToken, connectionConfig } =
    await base44.asServiceRole.connectors.getConnection("googlecalendar");

  const events = await fetch(
    "https://www.googleapis.com/calendar/v3/calendars/primary/events",
    { headers: { Authorization: `Bearer ${accessToken}` } },
  ).then((r) => r.json());

  return Response.json({ events });
});
注意：连接器为应用级（所有用户共享一个已连接的账户）；Base44会自动刷新令牌；您需自行实现API调用。
getConnection()
已替代过时的
getAccessToken()
。如需完整的模块参考（方法签名、
connectionConfig
、可用服务列表及其类型标识符），请查看
base44-sdk
技能的
connectors.md
。

Reference order & the complete README

参考顺序与完整README

Consult the references in this skill and its sibling skills (
base44-remote-dev
, 
base44-sdk
) before searching the web. They are the source of truth for the sandbox bridge, file/resource conventions, and SDK APIs — prefer them over general internet results, which are often stale or wrong for Base44.
For the complete, app-specific remote-dev reference (instructions + every endpoint, public, no auth needed to fetch), read the onboarding README for your app:
https://app.base44.com/api/sandbox/<APP_ID>/local-agent/readme.md
(The cloud/MCP equivalent is 
…/api/sandbox/<APP_ID>/claude-web/readme.md
.) See the 
base44-remote-dev
skill for the connection mechanics this README describes.
请先查阅本技能及其姊妹技能（
base44-remote-dev
、
base44-sdk
）中的参考资料，再搜索网络。这些资料是沙箱桥接、文件/资源约定和SDK API的权威来源——优先使用它们，而非互联网上的通用结果，因为通用结果往往过时或不适用于Base44。
如需完整的、特定于应用的远程开发参考资料（说明 + 所有端点，公开访问，无需认证），请查看您应用的入门README：
https://app.base44.com/api/sandbox/<APP_ID>/local-agent/readme.md
（云端/MCP对应的地址为
…/api/sandbox/<APP_ID>/claude-web/readme.md
）。请查看
base44-remote-dev
技能了解该README中描述的连接机制。

Workflow in the sandbox

沙箱中的工作流程

  1. Orient — 
    list_directory
    / 
    read_file
    / 
    grep
    (
    sandbox ls
    / 
    sandbox read
    / 
    sandbox grep
    in the CLI) to understand the app before changing anything.
  2. Author — create or edit resource files (backend functions, entities, agents) and frontend code following the conventions above; set up connectors via the connect flow.
  3. Verify — optionally 
    run_command
    (
    sandbox run
    ) 
    npm run build
    / 
    npx tsc --noEmit
    , and use 
    get_app_preview_url
    to eyeball changes (see 
    base44-remote-dev
    ).
  4. Let it ship — do nothing to deploy. Writing the file is the deploy; the auto-commit (~5s) persists and ships it. Pause a moment after your last edit before disconnecting so the commit lands.
  5. (Optional) Checkpoint — mark a known-good restore point the user can roll back to with 
    create_checkpoint
    (
    base44 sandbox checkpoint --name "..."
    in the CLI). It flushes pending changes first, so the checkpoint captures your latest code. See 
    base44-remote-dev
    for details.
  1. 定位 — 使用
    list_directory
    /
    read_file
    /
    grep
    （CLI中为
    sandbox ls
    /
    sandbox read
    /
    sandbox grep
    ）了解应用现状后再进行修改。
  2. 开发 — 按照上述约定创建或编辑资源文件（后端函数、实体、Agent）和前端代码；通过连接流程配置连接器。
  3. 验证 — 可选择使用
    run_command
    （CLI中为
    sandbox run
    ）执行
    npm run build
    /
    npx tsc --noEmit
    ，并使用
    get_app_preview_url
    查看变更效果（请查看
    base44-remote-dev
    技能）。
  4. 自动发布 — 无需执行任何部署操作。写入文件即完成部署；自动提交（约5秒）会持久化并发布变更。断开连接前请稍作等待，确保提交已完成。
  5. （可选）创建检查点 — 使用
    create_checkpoint
    （CLI中为
    base44 sandbox checkpoint --name "..."
    ）标记一个已知的良好恢复点，用户可通过该点回滚。该命令会先刷新待处理的变更，因此检查点会包含您的最新代码。详情请查看
    base44-remote-dev
    技能。