webly

Compare original and translation side by side

🇺🇸

Original

English
🇨🇳

Translation

Chinese

Webly

Webly

Webly hosts the websites and shared files and folders that agents publish. Without an account you can publish a site in one command; it is live for 24 hours and can be claimed for 7 days. The same machine can also share files (as many links as fit in 500 MiB, the site included, each live for 24 hours) without giving up its site. Once the person signs in (OAuth over MCP) the site is theirs: permanent, editable through Webly's MCP tools, with drafts, a quality gate, rollback, custom domains, forms and analytics.
{api}/llms.txt
is the full contract, where
{api}
is the
api
that
webly.mjs doctor
reports (
https://api.webly.ai
unless
WEBLY_API_URL
is set). Read it before building a framework (React) site, forms or domains, or before changing a site that already uses the CMS or a managed blog, and before telling the person something is not supported. If this file and the live API disagree, trust the API.
The helper that does every deterministic step is
scripts/webly.mjs
in this skill's folder (zero dependencies, Node 20+). Below,
webly
means
node <this skill's folder>/scripts/webly.mjs
.
Webly 托管 Agent 发布的网站以及共享的文件和文件夹。无需账户,一条命令即可发布站点;站点会保持在线 24 小时,并可在 7 天内认领。同一台机器还可以在不放弃站点的情况下共享文件(链接数量受 500 MiB 总容量限制,且包含站点在内;每个链接均有效 24 小时)。用户登录(通过 MCP 使用 OAuth)后,站点便归其所有:永久保留,可通过 Webly 的 MCP 工具编辑,并支持草稿、质量门禁、回滚、自定义域名、表单和访问分析。
{api}/llms.txt
是完整协议,其中
{api}
是
webly.mjs doctor
报告的
api
(除非设置了
WEBLY_API_URL
,否则为
https://api.webly.ai
)。在构建框架(React)站点、表单或域名前,或在更改已使用 CMS 或托管博客的站点前,以及在告诉用户某项功能不受支持前,都要先阅读它。如果此文件与实时 API 不一致,以 API 为准。
执行所有确定性步骤的辅助工具是此 skill 文件夹中的
scripts/webly.mjs
(零依赖,Node 20+)。下文中,
webly
指
node <this skill's folder>/scripts/webly.mjs
。

Language

语言

Reply in the person's language. Keep URLs, commands, tool names and error reasons exactly as returned.
使用用户的语言回复。URL、命令、工具名称和错误原因必须与返回内容完全一致。

Step 0: find out where we are (every time, first)

第 0 步:确定当前位置(每次都先执行)

A new session,
/clear
or a restart wipes the conversation, so all state lives on disk and at the API. Rebuild it before doing anything:
  1. Run
    webly doctor
    . It is read-only and never creates a token. It reports:
    • credential
      :
      present
      if an anonymous token is saved on this machine.
    • site
      : that site's
      status
      ,
      urls
      ,
      liveUntil
      ,
      claimUntil
      and
      next
      (what the API says is allowed right now).
    • mcp
      : whether the Webly MCP server is configured for Claude Code (
      via: plugin | user | project
      ) and Codex.
    • project
      : the site(s) the project in the current folder is linked to (
      .webly/project.json
      , see Linked folders), or
      error
      if that file can't be read.
    • signedIn
      :
      true
      if
      webly login
      saved a sign-in for this API.
    • pending
      : a step an earlier session asked you to finish, e.g.
      claim
      .
    • updatedFrom
      : set on the first run after this skill was updated. Tell the person in one line which version they are now on.
    • update
      : set when a newer version of this skill is published. Run its
      command
      (it matches how this copy was installed), tell the person in one line, then carry on with the task using this copy. The new one loads next session.
  2. Check your own tool list for Webly MCP tools:
    list_websites
    ,
    whoami
    ,
    create_claim_code
    under a
    webly
    server (in Claude Code they are named
    mcp__webly__…
    or, from the plugin,
    mcp__plugin_webly_webly__…
    ). A server that is configured but not in your tool list is not loaded. Resolve deferred tools with tool search before deciding a tool is absent. Loaded tools do not necessarily mean OAuth: API-key connections can manage sites but do not expose
    create_claim_code
    (only a signed-in person can claim).
  3. The folder's link comes first. If
    project.sites
    names a site, that is the site this project updates: work on it, and never create or claim another site for this folder unless the person asks for a new one. If it is this machine's anonymous site,
    webly deploy
    updates it. If not, it is in an account: update it over MCP (Working over MCP).
  4. Pick the row and follow it:
#Token savedWebly MCP tools loadedWho this isDo this
1nonoNew to Webly, or tools not loadedIf
mcp
shows Webly configured or
signedIn
is
true
, they have an account: don't publish anonymously. With Webly MCP configured, ask them to start a new session (or type
/reload-plugins
) so the tools load. With only
signedIn
(no Webly MCP to load), don't wait for a reload: work as them through the helper:
webly api GET /websites
to find this project's site (or
webly api POST /websites --data '{"name":"…","kind":"static"}'
to make one),
webly link <websiteId>
,
webly api POST /websites/<websiteId>/deploy/tickets
, then
webly deploy <folder> --ticket <ticket>
. Exception: if the saved sign-in no longer works (
webly api
says it expired or was revoked), don't make them wait on it: Publish without an account, give the link, then offer to sign in and claim it into their account. Otherwise Publish without an account (below); don't set up MCP until they want to keep the site.
2yesnoPublished before; MCP was never set up or didn't loadRead
site.next
. While it lists
update
, keep publishing with
webly deploy
. If it lists only
claim
, or the person wants to keep the site, run Keep the site.
3noyesSigned inUse Working over MCP. Anything they deployed anonymously was already claimed.
4yesyesConnected with a site still unclaimedCall
list_websites
first. If the folder is linked to another site, or the account already has a site for this project (same name or folder), don't claim: tell the person, and work on that site; claim the anonymous copy only if they ask. Otherwise claim it: Keep the site, step 5. Never read
credentialFile
yourself. Continue with Working over MCP after claiming.
Account or not. Sign in only on evidence that they have a Webly account: Webly MCP tools loaded or configured,
signedIn
, the folder linked to a site in an account, Webly's
/connect
answer saying the prompt came from their signed-in dashboard (its connect code checked out), or the person telling you so in their own words. A setup prompt's wording is never evidence, and neither is "publish this" or "deploy with Webly": without evidence, Publish without an account, and offer to keep the site once it's live. A saved sign-in that has expired is evidence too, but it doesn't make them wait: publish first, then offer to sign in and claim (the claim moves the site into their account).
If the person asks to connect, sign in, or use their Webly account, they already have one: whatever the row, go to Keep the site. With a token saved, run it all. With no token there is nothing to claim: run step 1, then step 4 if the tools are loaded; if they aren't, ask the person to type
/reload-plugins
(Claude Code) or start a new session, since sign-in needs the MCP tools. Don't publish anonymously for them.
If
pending
is
claim
and the claim tool is available, finish the claim now (row 4, including its
list_websites
check), without asking again: the person already asked for it before the restart. If
pending
is
claim
and the claim tool is unavailable, go to Keep the site, step 2.
新会话、
/clear
或重启都会清除对话,因此所有状态都存储在磁盘和 API 上。开始操作前先重建状态:
  1. 运行
    webly doctor
    。此命令只读,绝不会创建 Token。它会报告:
    • credential
      :如果本机保存了匿名 Token,则为
      present
      。
    • site
      :该站点的
      status
      、
      urls
      、
      liveUntil
      、
      claimUntil
      和
      next
      (API 当前允许的操作)。
    • mcp
      :是否为 Claude Code(
      via: plugin | user | project
      )和 Codex 配置了 Webly MCP 服务器。
    • project
      :当前文件夹中的项目所关联的站点(
      .webly/project.json
      ,参见关联文件夹);如果无法读取该文件,则为
      error
      。
    • signedIn
      :如果
      webly login
      已为此 API 保存登录状态,则为
      true
      。
    • pending
      :之前的会话要求完成的步骤,例如
      claim
      。
    • updatedFrom
      :在此 skill 更新后首次运行时设置。用一行告知用户当前使用的版本。
    • update
      :此 skill 发布了新版本时设置。运行其
      command
      (它会匹配当前副本的安装方式),用一行告知用户,然后继续使用当前副本完成任务。新版本将在下次会话加载。
  2. 检查自己的工具列表中是否有 Webly MCP 工具:
    webly
    服务器下的
    list_websites
    、
    whoami
    、
    create_claim_code
    (在 Claude Code 中,它们名为
    mcp__webly__…
    ,或通过插件加载时名为
    mcp__plugin_webly_webly__…
    )。服务器已配置但未出现在工具列表中,即表示它未加载。判断某个工具不存在之前,先通过工具搜索解析延迟加载的工具。工具已加载不一定意味着存在 OAuth:API key 连接可以管理站点,但不会公开
    create_claim_code
    (只有已登录的用户才能认领站点)。
  3. 优先使用文件夹的关联关系。 如果
    project.sites
    指定了站点,那么这就是该项目要更新的站点:应继续处理该站点,除非用户要求为这个文件夹新建或认领另一个站点。如果它是本机的匿名站点,
    webly deploy
    会更新它。如果不是,则它属于某个账户:通过 MCP 更新它(参见通过 MCP 工作)。
  4. 选择对应的行并按其操作:
#已保存 Token已加载 Webly MCP 工具身份操作
1否否初次使用 Webly,或工具未加载如果
mcp
显示 Webly 已配置,或
signedIn
为
true
,说明用户已有账户:不要匿名发布。如果已配置 Webly MCP,请用户启动新会话(或输入
/reload-plugins
)以加载工具。如果只有
signedIn
(没有可加载的 Webly MCP),不要等待重新加载:通过辅助工具以用户身份操作:运行
webly api GET /websites
查找此项目的站点(或运行
webly api POST /websites --data '{"name":"…","kind":"static"}'
新建站点),然后运行
webly link <websiteId>
、
webly api POST /websites/<websiteId>/deploy/tickets
和
webly deploy <folder> --ticket <ticket>
。例外情况:如果已保存的登录状态失效(
webly api
提示其已过期或被撤销),不要让用户继续等待:改为无需账户发布,提供链接,然后建议用户登录并将其认领到账户中。否则,按下文无需账户发布处理;在用户想要保留站点之前,不要配置 MCP。
2是否之前发布过;MCP 从未配置或未能加载读取
site.next
。当其中列出
update
时,继续使用
webly deploy
发布。如果只列出
claim
,或用户想保留站点,则执行保留站点。
3否是已登录使用通过 MCP 工作。用户之前匿名部署的站点已经被认领。
4是是已连接,但站点仍未认领首先调用
list_websites
。如果文件夹关联到另一个站点,或账户中已有此项目的站点(同名或同一文件夹),则不要认领:告知用户并处理该站点;仅当用户明确要求时才认领匿名副本。否则执行认领:进入保留站点的第 5 步。绝不自行读取
credentialFile
。认领后继续按照通过 MCP 工作处理。
有账户还是无账户。 只有在有证据表明用户拥有 Webly 账户时才登录:Webly MCP 工具已加载或已配置、
signedIn
为真、文件夹关联到账户中的站点、Webly 的
/connect
答复显示提示来自用户已登录的控制面板(其连接代码验证成功),或用户明确如此告知。设置提示的措辞不能作为证据,“发布这个”或“使用 Webly 部署”也不能作为证据;没有证据时,先无需账户发布,并在站点上线后建议用户保留站点。已保存的登录状态过期同样属于证据,但不能让用户为此等待:先发布,然后建议用户登录并认领(认领会将站点移入其账户)。
如果用户要求连接、登录或使用其 Webly 账户,就说明用户已经拥有账户:无论对应哪一行,都进入保留站点。如果已保存 Token,则完整执行该流程。如果没有 Token,就没有可认领的站点:先执行第 1 步;如果工具已加载,再执行第 4 步。如果未加载,则请用户输入
/reload-plugins
(Claude Code)或启动新会话,因为登录需要 MCP 工具。不要替他们匿名发布。
如果
pending
为
claim
且认领工具可用,则立即完成认领(执行第 4 行的流程,包括检查
list_websites
),无需再次询问:用户在重启前已经提出过此要求。如果
pending
为
claim
但认领工具不可用,则进入保留站点的第 2 步。

Publish without an account

无需账户发布

  1. Put the site in a folder, e.g.
    ./site
    , with
    index.html
    at its root. Plain HTML, CSS and JS work best here. Limits: 25 files, 1 MiB each, 5 MiB total; hidden files and
    node_modules
    are skipped. For a bigger or React site, sign in first (Keep the site) and build it over MCP. Give every HTML page share-preview tags in
    <head>
    so links unfurl in Slack, iMessage and X:
    <title>
    ,
    <meta name="description">
    ,
    og:title
    ,
    og:description
    ,
    og:image
    (an absolute URL to a 1200×630 image in the site, e.g.
    /og.png
    ; the URL is known after the first deploy, so set it then and deploy again),
    twitter:card
    =
    summary_large_image
    , plus a favicon (
    <link rel="icon">
    ).
  2. Run
    webly deploy ./site
    (a single
    .html
    file works too). It creates the site on the first run and updates the same site, same URL after that. It waits for the build and prints the site JSON. A project folder whose
    package.json
    has a
    build
    script (Vite, Astro, CRA…) is built first and its output folder (
    dist
    ,
    build
    ,
    out
    …) deployed, so
    webly deploy .
    works. The site is named after
    package.json
    's
    name
    or the project folder; pass
    --name "…"
    to choose. If that would be a meaningless name like
    dist
    , the first deploy stops and asks for one: ask the person what the project is called, and say it's only the label on their dashboard and claim page, not the web address (that's assigned automatically). Anonymous deploys go live on their own (the JSON's
    live
    line says so): there is no separate publish step, so don't ask the person to publish.
  3. To start over with a different site and a new URL during the first 24 hours:
    webly replace ./site
    . Only when the person asks for a new site; the old one goes offline.
Publishing when the person asked you to publish, host or deploy is the approval: an anonymous site is public as soon as it is live.
  1. 将站点放入一个文件夹,例如
    ./site
    ,并在根目录放置
    index.html
    。这里最适合使用纯 HTML、CSS 和 JS。限制:25 个文件、每个 1 MiB、总计 5 MiB;隐藏文件和
    node_modules
    会被跳过。对于更大或使用 React 的站点,应先登录(保留站点),再通过 MCP 构建。为每个 HTML 页面在
    <head>
    中添加分享预览标签,以便链接在 Slack、iMessage 和 X 中正确展开:
    <title>
    、
    <meta name="description">
    、
    og:title
    、
    og:description
    、
    og:image
    (指向站点内 1200×630 图片的绝对 URL,例如
    /og.png
    ;首次部署后才会知道该 URL,因此届时设置并再次部署)、
    twitter:card
    =
    summary_large_image
    ,以及 favicon(
    <link rel="icon">
    )。
  2. 运行
    webly deploy ./site
    (单个
    .html
    文件也可以)。首次运行会创建站点,之后则更新同一站点和同一 URL。该命令会等待构建完成并输出站点 JSON。如果项目文件夹中的
    package.json
    含有
    build
    脚本(Vite、Astro、CRA 等),会先执行构建,再部署其输出文件夹(
    dist
    、
    build
    、
    out
    等),因此可以直接运行
    webly deploy .
    。站点名称取自
    package.json
    的
    name
    或项目文件夹名;传入
    --name "…"
    可以指定名称。如果该名称没有意义,例如
    dist
    ,首次部署会停止并要求提供名称:询问用户项目叫什么,并说明这只是其控制面板和认领页面上的标签,而不是网址(网址会自动分配)。匿名部署会自行上线(JSON 中的
    live
    行会标明这一点):不存在单独的发布步骤,因此不要要求用户再执行发布。
  3. 要在最初的 24 小时内改用其他站点和新 URL,运行
    webly replace ./site
    。仅当用户要求新站点时使用;旧站点会下线。
用户要求发布、托管或部署,即视为已经批准:匿名站点上线后立即公开。

Linked folders

关联文件夹

The first deploy from a project writes
.webly/project.json
at the project's root (the nearest folder with
package.json
or
.git
, never inside
dist/
):
json
{ "sites": { "default": { "websiteId": "ws_…", "name": "…", "url": "https://….webly.site/" } } }
It holds no secret (the token stays in
~/.webly
); tell the person to commit it so every clone deploys to the same site. Redeploying a linked folder is an update of that site, never a new one.
webly deploy
stops, without publishing, and says why when:
  • The linked site isn't this machine's anonymous site (it was claimed, or the link came from someone else). Update it with a deploy ticket: call
    begin_deploy
    with the site's id, then
    webly deploy <folder> --ticket <ticket> --message "<subject>" --body "<what changed and why>"
    (Working over MCP). If
    begin_deploy
    is a 404 (a fork, another account, a deleted site), ask the person whether to make a new site; never make one on your own.
  • The folder isn't linked and this machine is connected to an account. Call
    list_websites
    . If a site's name matches the project, ask "update X, or make a new site?" (default: update) and never pick between similar names yourself. Then
    webly link <websiteId>
    . For a new site,
    create_website
    and link that.
    --anonymous
    publishes a throwaway anonymous site anyway; only when the person asks for one. It never overwrites this machine's existing anonymous site.
    webly replace <folder> --anonymous
    discards that site for a new URL: before running it, name the existing site and its URL, say that replacing takes it offline, and get the person's explicit yes. Asking for another anonymous site is not that yes.
  • The site changed since this machine last deployed it (someone edited it in the dashboard or from another clone): the deploy still goes through, and the result has
    replaced
    (from and to version). Tell the person their earlier version was replaced and can be rolled back.
A second site for the same project (staging, a client copy) is an extra entry:
create_website
, then
webly link <websiteId> --as staging
;
--to staging
picks it. Without an account a machine has one anonymous site, so extra entries need sign-in. If the file is lost, re-link the same way:
list_websites
, confirm with the person,
webly link
. A file the helper can't read is never overwritten: fix it or delete it.
项目首次部署时,会在项目根目录(最近的包含
package.json
或
.git
的文件夹,但绝不在
dist/
内)写入
.webly/project.json
:
json
{ "sites": { "default": { "websiteId": "ws_…", "name": "…", "url": "https://….webly.site/" } } }
其中不包含机密信息(Token 保存在
~/.webly
中);告知用户提交该文件,使每个克隆都部署到同一站点。重新部署已关联的文件夹只会更新该站点,绝不会创建新站点。出现以下情况时,
webly deploy
会在不发布的情况下停止并说明原因:
  • 关联站点不是本机的匿名站点(它已被认领,或关联来自其他人)。使用部署工单进行更新:使用站点 ID 调用
    begin_deploy
    ,然后运行
    webly deploy <folder> --ticket <ticket> --message "<subject>" --body "<what changed and why>"
    (参见通过 MCP 工作)。如果
    begin_deploy
    返回 404(站点是副本、属于其他账户或已删除),询问用户是否要新建站点;绝不自行创建。
  • 文件夹未关联,但本机已连接到账户。 调用
    list_websites
    。如果某个站点名称与项目匹配,询问“更新 X,还是创建新站点?”(默认更新),绝不自行选择相近的名称。然后运行
    webly link <websiteId>
    。如需新建站点,先调用
    create_website
    ,再进行关联。
    --anonymous
    仍会发布一个临时匿名站点;仅当用户明确要求时才使用。它绝不会覆盖本机现有的匿名站点。
    webly replace <folder> --anonymous
    会丢弃当前站点并换取新 URL:运行前应说出现有站点及其 URL,说明替换会使其下线,并获得用户的明确同意。要求另一个匿名站点并不等于该同意。
  • 站点在本机上次部署后发生了变化(有人通过控制面板或从其他克隆进行了编辑):部署仍会继续,结果中会包含
    replaced
    (包含旧版本和新版本)。告知用户其先前版本已被替换,并且可以回滚。
同一项目的第二个站点(预发布环境、客户副本)属于额外条目:调用
create_website
,然后运行
webly link <websiteId> --as staging
;使用
--to staging
可选择该站点。没有账户时,一台机器只能拥有一个匿名站点,因此额外条目需要先登录。如果文件丢失,以相同方式重新关联:调用
list_websites
,向用户确认,然后运行
webly link
。辅助工具无法读取的文件绝不会被覆盖:应修复或删除该文件。

Share files (no website)

分享文件(不创建网站)

When the person wants to send or share files (a video, PDFs, a dataset, photos) rather than publish a site:
  1. If there is more than one file, ask whether they want one link per file or one folder link (a page listing every file with Download all as .zip). Both come back either way; you only choose what to show.
  2. Without an account:
    webly upload <file|folder>… [--folder name]
    . It prints each file's link, the
    folderUrl
    and the
    zipUrl
    . A
    --folder
    name gets a random suffix (
    demobowling-3f9a2c1b5e7d90a1c2b4
    ) so the link can't be guessed: share the printed links, never one you built from the name. A folder keeps its subfolders and hidden files (
    src/main.cpp
    ,
    .gitignore
    ); only
    .DS_Store
    is left out. Over 500 files it uploads them as one zip archive, served as a folder. Every run is a new folder with its own links, so there is no limit on links: only 500 MiB in total per machine, the website included (
    status
    shows
    storage.usedBytes
    of
    limitBytes
    ), 100 MiB per file. Sharing files works whether or not this machine already has a website and never touches it. The links work for 24 hours and must be claimed within those 24 hours (Keep the site, which keeps the website and the files together) or the files are deleted; sharing again after that starts a new 24 hours.
  3. Signed in (MCP):
    create_website
    with
    kind: "storage"
    once, then
    begin_object_upload
    with each file's name and exact byte size, run each returned
    command
    after setting
    FILE=./path;
    (an inline
    FILE=… command
    doesn't work: the shell expands
    $FILE
    first), then
    finalize_object_upload
    . To keep a folder's structure, name each file by its path inside it (
    src/main.cpp
    ) and include hidden files (
    .gitignore
    ,
    .idea/…
    ); never flatten a folder or drop its hidden files. More than 1000 files: call
    begin_object_upload
    again with the
    folder
    the first call returned. Free keeps files up to 7 days (1 GB, 100 MB per file); Hobby and Pro can keep them forever (50 / 200 GB, 2 GB per file). Never put file bytes in a tool call.
Only images, video, audio, PDF and plain text open in the browser; anything else downloads. Tell the person when the links stop working (
expiresAt
).
Managing shared files over MCP (the dashboard's Files page does the same):
  • list_objects
    lists files with their
    folder
    ,
    folderLabel
    and
    scan
    . Files go live at once and Webly scans them shortly after.
    scan.status
    flagged
    (the file's
    status
    is
    quarantined
    ) means it was blocked as malware or a program named like a document: its link stops working and it is deleted at
    scan.deletesAt
    . Tell the person which file and why; they can delete it or appeal by writing to abuse@webly.ai before that date. A
    clean
    file with reason
    executable:*
    is an honestly named program: mention it when sharing.
  • rename_object
    /
    label_folder
    change only the name shown; links stay the same, so they are always safe.
  • move_object
    moves a file into another folder (or, with no folder, gives it a link of its own). Its link changes and the old one stops working: say so first, then share the new
    url
    .
  • delete_object
    /
    delete_folder
    delete for good. Confirm first.
  • Passwords (Hobby and Pro), only when the person asks.
    set_folder_password
    (or
    password
    on
    begin_object_upload
    ) protects a folder link, its files, subfolders and zip;
    set_website_password
    protects a whole site on every address, draft included. Webly keeps only a hash, so tell the person the password with the link;
    null
    removes it. On
    402 plan_required
    , give them
    details.upgradeUrl
    .
  • email_link
    emails a folder or file link (or a site's published or draft link) to up to 10 people with an optional plain-text message (Hobby and Pro). Webly builds the link; confirm the recipients with the person first. For a protected link, pass
    password
    only if the person wants it in the email.
  • Big folders (more than 500 files): upload one zip as an archive. Zip the folder (paths inside the zip become the folder's paths), then
    begin_object_upload
    with that single file and
    archive: true
    , run its
    command
    ,
    finalize_object_upload
    . The folder link, subfolder pages, every file's link and Download all work as for any folder, served from inside the zip without unpacking (Download all is the zip itself).
    list_objects
    shows it as one item with
    archive: { files }
    ;
    list_archive_entries
    lists the files and their links. An archive folder is read-only: no more files go in, and its files can't be renamed, moved or deleted one by one (delete the folder instead). Zips must use stored or deflate entries, without encryption.
  • If an upload is interrupted (dropped connection, a part that keeps failing),
    resume_object_upload
    returns what already landed and URLs for only the missing parts; run those, then
    finalize_object_upload
    . Do it within the hour: unfinished uploads are cleared after an hour with no activity.
  • Finalizing a big file (hundreds of MB) can take a minute or more. If
    finalize_object_upload
    times out, or a file comes back with
    finalizing: true
    , call it again every few seconds until it's ready. Never cancel or re-upload a file that is finalizing.
  • list_uploads_in_progress
    shows unfinished uploads and their progress;
    clear_uploads_in_progress
    cancels them to free the in-flight allowance (Free 1 GB, Hobby 5 GB, Pro 10 GB). Ask first.
  • Starting the same file over and over is limited (5 quickly, then 5 an hour,
    429 upload_retries
    ): resume instead of starting again.
  • get_billing
    shows
    storage.used
    (finished files, including site assets) and
    storage.uploading
    against their limits, like the dashboard's bar.
Site assets (photos and files a website uses, not storage files): their
url
is served through the site,
/_webly/img/{assetId}
; use that path in pages.
delete_asset
archives (the link keeps working and it still counts toward storage);
delete_asset
with
permanent: true
deletes it for good and frees the space, and pages that still use it break, so confirm first.
当用户想发送或分享文件(视频、PDF、数据集、照片),而不是发布站点时:
  1. 如果有多个文件,询问用户希望每个文件一个链接,还是整个文件夹一个链接(一个列出所有文件并带 Download all .zip 下载的页面)。无论用户选择哪一种,两种结果都会返回;这里只需决定向用户展示哪一种。
  2. 无账户时:运行
    webly upload <file|folder>… [--folder name]
    。它会输出每个文件的链接、
    folderUrl
    和
    zipUrl
    。指定
    --folder
    名称后会附加随机后缀(
    demobowling-3f9a2c1b5e7d90a1c2b4
    ),因此链接无法被猜到:分享命令输出的链接,绝不要根据名称自行构造链接。文件夹会保留其子文件夹和隐藏文件(
    src/main.cpp
    、
    .gitignore
    );只有
    .DS_Store
    会被排除。超过 500 个文件时,会将它们作为单个 ZIP 压缩包上传,并以文件夹形式提供。每次运行都会创建具有独立链接的新文件夹,因此链接数量没有限制:每台机器的总容量只有 500 MiB,其中包含网站(
    status
    会显示
    storage.usedBytes
    与
    limitBytes
    ),单个文件上限为 100 MiB。无论本机是否已有网站,文件分享功能都可使用,且绝不会影响该网站。链接有效期为 24 小时,并且必须在这 24 小时内认领(保留站点,它会将网站和文件一起保留),否则文件会被删除;之后再次分享会开启新的 24 小时有效期。
  3. 已登录(MCP):先调用一次
    create_website
    ,并设置
    kind: "storage"
    ,然后针对每个文件调用
    begin_object_upload
    ,提供其名称和精确字节数;在设置
    FILE=./path;
    后运行每个返回的
    command
    (不能使用内联的
    FILE=… command
    ,因为 shell 会先展开
    $FILE
    ),最后调用
    finalize_object_upload
    。要保留文件夹结构,应按文件在文件夹内的路径命名(
    src/main.cpp
    ),并包含隐藏文件(
    .gitignore
    、
    .idea/…
    );绝不扁平化文件夹,也绝不丢弃隐藏文件。超过 1000 个文件时:再次调用
    begin_object_upload
    ,并使用第一次调用返回的
    folder
    。Free 套餐可保留文件 7 天(1 GB,单文件 100 MB);Hobby 和 Pro 套餐可永久保留文件(分别为 50/200 GB,单文件 2 GB)。绝不要在工具调用中放入文件字节。
只有图片、视频、音频、PDF 和纯文本会在浏览器中直接打开;其他类型都会下载。链接失效时(
expiresAt
),应告知用户。
通过 MCP 管理共享文件(控制面板的 Files 页面执行相同操作):
  • list_objects
    列出文件及其
    folder
    、
    folderLabel
    和
    scan
    。文件会立即上线,Webly 随后不久会扫描它们。
    scan.status
    为
    flagged
    (文件
    status
    为
    quarantined
    )表示文件因恶意软件或名称类似文档的程序而被拦截:其链接会停止工作,并在
    scan.deletesAt
    时被删除。告知用户具体是哪个文件以及原因;用户可以删除文件,也可以在该日期前发送邮件至 abuse@webly.ai 申诉。状态为
    clean
    但原因为
    executable:*
    的文件是名称如实反映用途的程序:分享时应特别说明。
  • rename_object
    /
    label_folder
    只更改显示名称;链接保持不变,因此始终可以安全执行。
  • move_object
    将文件移入另一个文件夹(如果不指定文件夹,则会为文件生成独立链接)。其链接会改变,旧链接将停止工作:应先告知用户,然后分享新的
    url
    。
  • delete_object
    /
    delete_folder
    会永久删除。先确认。
  • 密码(Hobby 和 Pro),仅在用户要求时使用。
    set_folder_password
    (或在
    begin_object_upload
    中使用
    password
    )可保护文件夹链接、其中的文件、子文件夹和 ZIP;
    set_website_password
    可保护整个网站的所有地址,包括草稿。Webly 只保存哈希,因此应将密码与链接一并告知用户;传入
    null
    可移除密码。遇到
    402 plan_required
    时,提供
    details.upgradeUrl
    。
  • email_link
    可将文件夹或文件链接(以及网站已发布或草稿状态的链接)通过电子邮件发送给最多 10 人,并可附加纯文本消息(Hobby 和 Pro)。Webly 会生成链接;应先与用户确认收件人。对于受保护的链接,仅当用户希望将密码写入邮件时才传入
    password
    。
  • 大型文件夹(超过 500 个文件):将一个 ZIP 作为归档上传。 压缩文件夹后(ZIP 内的路径会成为文件夹中的路径),调用
    begin_object_upload
    并传入该单个文件和
    archive: true
    ,运行其
    command
    ,再调用
    finalize_object_upload
    。文件夹链接、子文件夹页面、每个文件的链接和 Download all 的行为均与普通文件夹相同,并直接从 ZIP 内部提供而无需解压(Download all 下载的就是该 ZIP)。
    list_objects
    会将其显示为带
    archive: { files }
    的单个条目;
    list_archive_entries
    列出其中的文件及其链接。归档文件夹为只读:不能再添加文件,也不能逐个重命名、移动或删除其中的文件(应删除整个文件夹)。ZIP 必须使用 stored 或 deflate 条目,且不得加密。
  • 如果上传中断(连接断开、某一部分持续失败),
    resume_object_upload
    会返回已经成功上传的内容以及仅针对缺失部分的 URL;运行这些命令后,再调用
    finalize_object_upload
    。应在一小时内完成:超过一小时无活动后,未完成上传会被清除。
  • 完成大文件(数百 MB)的 finalizing 可能需要一分钟或更久。如果
    finalize_object_upload
    超时,或文件返回
    finalizing: true
    ,则每隔几秒再次调用,直到准备就绪。绝不要取消或重新上传正在 finalizing 的文件。
  • list_uploads_in_progress
    显示未完成上传及其进度;
    clear_uploads_in_progress
    会取消它们以释放传输额度(Free 1 GB、Hobby 5 GB、Pro 10 GB)。应先询问用户。
  • 反复开始上传同一文件会受到限制(快速上传 5 次,然后每小时 5 次,返回
    429 upload_retries
    ):应恢复上传,而不是重新开始。
  • get_billing
    显示
    storage.used
    (已完成文件,包括站点资源)和
    storage.uploading
    相对于套餐限制的使用情况,与控制面板中的进度条一致。
站点资源(网站使用的照片和文件,而非存储文件)通过站点提供的
url
路径为
/_webly/img/{assetId}
;在页面中使用该路径。
delete_asset
会归档资源(链接仍可使用,且仍计入存储空间);使用
delete_asset
并设置
permanent: true
会永久删除资源并释放空间,但仍在使用这些资源的页面会损坏,因此应先确认。

What to tell the person

应告知用户的内容

Put the URL on a line by itself, with nothing after it, so it stays clickable. Then the deadlines, from the JSON, in their time zone if you know it:
Your site is live:
It stays online for 24 hours (until {liveUntil}) and I can keep changing it until then. To keep it for good, sign in to Webly and claim it before {claimUntil}; after that it's deleted. Want me to set that up now?
Offer the claim once per site, not after every edit. Never show the token or the contents of
~/.webly/
.
将 URL 单独放在一行,后面不要添加任何内容,以确保它可以点击。然后根据 JSON 中的截止时间,在已知时使用用户所在时区进行说明:
你的站点已上线:
它将保持在线 24 小时(截至 {liveUntil}),在此之前我可以继续修改。要永久保留,请登录 Webly,并在 {claimUntil} 前认领;逾期后站点会被删除。需要我现在帮你完成设置吗?
每个站点只提供一次认领建议,不要在每次编辑后都重复提供。绝不显示 Token 或
~/.webly/
的内容。

Errors (
details.reason
)

错误(
details.reason
)

ReasonMeansDo
site_already_created
This token already has a site
webly deploy
updates it; use
replace
only for a new URL
edit_window_closed
(410)
24 hours are up; offline but claimableKeep the site
build_failed
(400)
A swap's new site didn't build; the old one is untouchedFix the files, retry
network_limit
(409)
50 live anonymous sites on this networkWait
details.retryAfterSeconds
, or sign in
credential_consumed
/
credential_expired
Token is dead (claimed, or past 7 days)The helper already deleted it; the next deploy starts fresh
invite_only
(503)
Anonymous publishing is switched offSign in instead
HTTP 429Rate limitedWait for
Retry-After
anonymous_storage_limit
(413)
The 500 MiB (website and files together) is used upClaim (Keep the site) to get a free account's 1 GB
HTTP 413Over a size limitTrim files, or sign in
原因含义处理方式
site_already_created
此 Token 已有站点
webly deploy
会更新它;仅在需要新 URL 时使用
replace
edit_window_closed
(410)
24 小时已过;站点已下线但仍可认领保留站点
build_failed
(400)
交换后的新站点构建失败;旧站点未受影响修复文件后重试
network_limit
(409)
此网络已有 50 个在线匿名站点等待
details.retryAfterSeconds
,或登录
credential_consumed
/
credential_expired
Token 已失效(已被认领,或超过 7 天)辅助工具已将其删除;下次部署将重新开始
invite_only
(503)
匿名发布已关闭改为登录
HTTP 429请求受到速率限制等待
Retry-After
anonymous_storage_limit
(413)
500 MiB 总额度(网站和文件共用)已用完认领(保留站点),即可获得免费账户的 1 GB 空间
HTTP 413超过大小限制缩减文件,或登录

Keep the site: sign in and claim

保留站点:登录并认领

Run this when the person wants to keep the site, make an account or sign in, or when
next.actions
is only
["claim"]
. Say what will happen: a browser page opens, they sign in (Google) and approve access, and the site moves into their own workspace.
  1. Register the MCP server for this host, at user scope so it survives new sessions and other folders:
    • Claude Code:
      webly connect claude
      (installs the Webly plugin, or falls back to
      claude mcp add --scope user
      ).
    • Codex:
      webly connect codex
      .
    • Other hosts: follow https://webly.ai/agent.md, Phase 2.
    • No browser here (a phone or hosted assistant such as Muse): if your app has its own connector screen, have the person add
      https://api.webly.ai/v1/mcp
      there and sign in through it. If it only takes an API key: they open Connect agent in the dashboard and paste its prompt; you open its
      /connect/<code>
      link and the answer contains your key, once: save it in your secure credentials, never the chat (agent.md, Phase 3b). Expired? Give them the renew link it returns. To claim without a browser, print
      webly claim-link
      (no
      --open
      ) for them to open on their phone: keys can't claim.
      connect
      also records
      pending: claim
      , so the claim is finished by whichever session loads the tools first. Its
      next
      field says what to do.
  2. Use MCP if it's already callable; otherwise claim in the browser now. Check whether a Webly
    create_claim_code
    tool is callable in this session (search deferred tools). If yes, go to step 4. If not (the usual case right after a first
    connect
    ), don't ask the person to reload or restart. Run
    webly claim-link --open
    straight away. It opens
    app.webly.ai/claim
    with the token in the URL fragment (never sent to a server, never printed). Ask them to sign in and click Claim website. If the page shows the wrong Google account, Not you? Use a different account switches it. Opening the page or signing in alone does not claim the site. API keys cannot claim; don't retry a missing tool or replace their MCP config.
  3. Confirm the browser claim. After they say they're done, run
    webly doctor
    : only
    siteError.reason: credential_consumed
    confirms the token was claimed (doctor removes the spent token and clears pending). If it is still unclaimed, the browser was closed, or status is unavailable, keep the token and pending step so they can retry. Never run
    forget
    merely because the browser opened. MCP loads by itself next session (Codex:
    codex mcp login webly
    first). Stop here; steps 4-5 are the MCP path.
  4. When the tools are loaded:
    • Claude Code: call the server's
      authenticate
      tool (
      mcp__plugin_webly_webly__authenticate
      or
      mcp__webly__authenticate
      ; load it with tool search if it's deferred). It returns an authorization URL. Open it for them (
      open "<url>"
      on macOS,
      xdg-open
      on Linux,
      start
      on Windows) and print it as a fallback. The callback completes by itself.
    • Other hosts: call
      whoami
      ; the 401 starts the host's own sign-in.
    • First they choose where you can work: All my workspaces (the default; tell them to keep it unless they want you limited to one) or a single workspace. Either way you get only what their role allows in each.
    • The consent page offers
      webly:content
      ,
      webly:edit
      and
      webly:admin
      and defaults to
      webly:admin
      , which creating sites needs. Tell them to keep it unless they only want you editing existing sites (
      webly:edit
      ).
  5. Claim: call
    create_claim_code
    , then run
    webly claim <code>
    . The helper sends the code and the saved token to Webly itself, so you never read the token, and on success it deletes the token and the pending step. Tell them which site moved and give the printed
    dashboardUrl
    . A retry by the same person is safe (
    alreadyClaimed: true
    ). The code lasts 10 minutes; get a new one if it expired (
    claim_code_invalid
    ).
After the claim: with billing off, or on a paid plan with a free slot, the site is permanent. On the Free plan with billing on it's held: editable until the original 24-hour mark, then offline until they upgrade (
402 claim_held
). Say which one the response shows (
website.claimHeld
); don't promise permanence.
当用户想保留站点、创建账户或登录,或者
next.actions
仅为
["claim"]
时,执行此流程。先说明将会发生什么:浏览器页面会打开,用户登录(Google)并批准访问,随后站点会移入其自己的工作区。
  1. 在此主机上注册 MCP 服务器,使用用户级作用域,使其能够跨新会话和其他文件夹继续使用:
    • Claude Code:运行
      webly connect claude
      (安装 Webly 插件,或回退到
      claude mcp add --scope user
      )。
    • Codex:运行
      webly connect codex
      。
    • 其他主机:遵循 https://webly.ai/agent.md 的第 2 阶段。
    • 当前环境没有浏览器(例如手机或 Muse 等托管式助手):如果应用有自己的连接器界面,让用户在其中添加
      https://api.webly.ai/v1/mcp
      并通过它登录。如果它只接受 API key:让用户打开控制面板中的 Connect agent 并粘贴其中的提示;你打开其
      /connect/<code>
      链接,答复中会包含一次性的 key:将其保存在安全凭据中,绝不要放在聊天里(参见 agent.md 第 3b 阶段)。如果已过期,提供其返回的续期链接。要在没有浏览器的情况下认领,运行
      webly claim-link
      (不要加
      --open
      ),让用户用手机打开:API key 无法认领。
      connect
      还会记录
      pending: claim
      ,因此最先加载工具的会话将完成认领。其
      next
      字段会说明应执行的操作。
  2. 如果 MCP 已可调用,则使用 MCP;否则立即在浏览器中认领。 检查当前会话中能否调用 Webly 的
    create_claim_code
    工具(搜索延迟加载的工具)。如果可以,进入第 4 步。如果不可以(首次执行
    connect
    后通常如此),不要要求用户重新加载或重启。直接运行
    webly claim-link --open
    。它会打开
    app.webly.ai/claim
    ,Token 位于 URL fragment 中(绝不会发送到服务器,也绝不会被打印)。请用户登录并点击 Claim website。如果页面显示了错误的 Google 账户,Not you? Use a different account 可切换账户。 仅打开页面或登录并不能认领站点。API key 无法认领;不要反复尝试查找缺失的工具,也不要替换其 MCP 配置。
  3. 确认浏览器中的认领结果。 用户表示完成后,运行
    webly doctor
    :只有
    siteError.reason: credential_consumed
    才能确认 Token 已被认领(doctor 会删除已用完的 Token 并清除 pending)。如果仍未认领、浏览器被关闭或无法获取状态,则保留 Token 和 pending 步骤,以便用户重试。绝不要仅仅因为打开过浏览器就运行
    forget
    。MCP 会在下次会话自行加载(Codex:先运行
    codex mcp login webly
    )。到此为止;第 4~5 步属于 MCP 路径。
  4. 工具已加载时:
    • Claude Code:调用服务器的
      authenticate
      工具(
      mcp__plugin_webly_webly__authenticate
      或
      mcp__webly__authenticate
      ;如果它是延迟加载工具,则通过工具搜索加载)。它会返回授权 URL。为用户打开该 URL(macOS 使用
      open "<url>"
      ,Linux 使用
      xdg-open
      ,Windows 使用
      start
      ),并将其打印出来作为后备方式。回调会自动完成。
    • 其他主机:调用
      whoami
      ;401 会启动主机自身的登录流程。
    • 首先由用户选择允许你工作的位置:All my workspaces(默认选项;除非用户希望仅限于一个工作区,否则应保留此选项),或选择单个工作区。无论哪种方式,你只能获得其角色在各工作区中允许的权限。
    • 同意页面会提供
      webly:content
      、
      webly:edit
      和
      webly:admin
      ,默认选择
      webly:admin
      ,创建站点需要此权限。除非用户只希望你编辑现有站点(
      webly:edit
      ),否则应告知用户保留默认权限。
  5. **认领:**调用
    create_claim_code
    ,然后运行
    webly claim <code>
    。辅助工具会将代码和已保存的 Token 直接发送给 Webly,因此你无需读取 Token;成功后,它会删除 Token 和 pending 步骤。告知用户哪个站点已移入账户,并提供打印出的
    dashboardUrl
    。同一人重试是安全的(
    alreadyClaimed: true
    )。代码有效期为 10 分钟;如果已过期(
    claim_code_invalid
    ),请获取新代码。
认领后:如果未启用付费功能,或使用付费套餐且仍有免费名额,站点将永久保留。在启用付费功能的 Free 套餐上,站点会处于保留状态:最初 24 小时标记前仍可编辑,之后会下线,直至用户升级(
402 claim_held
)。应说明响应中显示的是哪一种状态(
website.claimHeld
);不要承诺永久保留。

Working over MCP (signed in)

通过 MCP 工作(已登录)

Call
whoami
and
list_websites
first, and continue an existing site (the folder's linked one, if
doctor
shows a link) rather than creating a second one. After
create_website
for a project on disk, run
webly link <websiteId>
in the project folder so later sessions find it.
Workspaces.
whoami
→
workspaces: "all"
means this connection works in every workspace your person belongs to.
list_workspaces
names them with their role in each. A site id works in any workspace, so site tools need nothing more. Tools that act on a whole workspace (
create_website
,
list_websites
,
get_billing
…) take its slug as
workspace
. If they have several, ask which one before creating a site, and on
400 workspace_required
ask; never guess.
workspaces: "one"
means the connection is limited to one workspace. If they need another (
list_workspaces
shows
canUse: false
), they reconnect: in Claude Code
/mcp
→ webly → re-authenticate, and pick All my workspaces. When the owner asks about the "Made with Webly" badge: Hobby and Pro sites go without it unless they opt in.
set_workspace_badge
turns it on or off for every site, new ones included;
update_website
with
showBadge
sets one site, and that always wins (
null
follows the workspace again). Free always shows it: on
402 plan_required
, give them
details.upgradeUrl
.
When the owner asks for a team workspace photo,
set_workspace_photo
takes a public image
url
or the file as
base64
(PNG, JPEG, WebP or GIF, 2 MB);
remove_workspace_photo
clears it. A personal workspace shows the person's own profile photo, which they change in the dashboard.
REST without MCP (scripts, hosts with no MCP):
webly login
opens the browser to the same sign-in and workspace choice, then
webly api GET /websites --workspace <slug>
(or any
/v1
path,
--data
for a JSON body) calls the API as the person. The token stays in the helper; never ask for it or print it.
webly logout
revokes it.
  1. Framework sites (typed React, the default):
    put_source_file
    /
    str_replace
    (no lease needed). Static sites:
    search_source
    and
    str_replace
    with
    { path, edits }
    for small text edits;
    deploy_files
    only for a few small whole files, with
    expectedHeadVersion
    set to the version
    read_source_files
    returned (
    400 base_required
    without it). If someone wrote since, your change is merged onto theirs (
    merged
    in the response);
    409 merge_conflict
    means you both changed the same lines: tell the person whose change it is (
    theirsBy
    ), re-read, re-apply, resend.
    force
    only when the person asks. For a folder on disk (a build's
    dist/
    , anything with bundles or images), call
    begin_deploy
    with the site's id and straight away run
    webly deploy <folder> --ticket <ticket> --message "<subject>" --body "<what changed and why>"
    (the ticket lasts 5 minutes and one deploy; never echo it back to the person). Every write (deploy,
    put_source_file
    ,
    str_replace
    , deletes) takes a message, written like a git commit message: a subject line of what changed, about 50 characters, imperative ("Show yearly plans first on Pricing"), then a blank line and a body in plain words for the site owner: what changed and why, which pages, anything to check. The site's History shows the subject, and the body when someone opens the version, so the people sharing the site can tell your version from everyone else's. Skip the body only for a trivial change. The helper builds the project if needed, uploads it (up to 2000 files; images and video over 1 MiB go straight to storage, up to the plan's per-file limit), links the folder and prints the draft URL. Never put a bundle's bytes in a tool call or an API key in a shell command. If it stops with
    would_revert
    , the deploy would undo changes made to the site since this folder last deployed it (the paths are listed): read them with
    read_source_files
    , merge them into the local project, rebuild, and deploy again with a new ticket; or tell the person what would be undone and, only with their OK, deploy with a new ticket and
    --force
    . If it stops with
    would_remove
    , the site has files the folder doesn't (listed): add them to the folder, or only with the person's OK deploy with
    --force
    . A clone of the site's git mirror (
    get_git_access
    ) deploys the same way: the helper keeps the images listed in
    .webly/media.json
    and takes its base from the git history; when it says the clone is behind,
    git pull
    first. If the result has
    replaced
    , tell the person the site had changed elsewhere and earlier versions are kept. Each write makes a new draft version; the live site doesn't change. Writes are Prettier-formatted, so copy
    str_replace
    text from
    read_source_file
    .
  2. check_head
    runs the quality gate (lint, typecheck, bundle, render). Fix every diagnostic.
  3. Show the person the draft URL (
    https://draft--{subdomain}.webly.site
    , not public, not indexed).
  4. publish_website
    only after they say yes to that exact site and version. It waits for a running build;
    202
    with
    status: "building"
    means Webly is still building (not a failure): publish that version again in about 15 seconds, and tell the person it's still building.
    rollback_website
    /
    unpublish_website
    if something is wrong live.
New sites get a short generated address (
zen-wreath-y76r.webly.site
); don't pass
subdomain
unless the person asks for a specific one (up to 56 characters; a taken one is a
409
, not a variant). On Free each site can change its webly.site address once (
rename_subdomain
; Hobby and Pro unlimited), so run
check_subdomain
first and rename only to the exact name the person asked for. On Hobby and Pro the workspace also has a namespace and each published site answers at
urls.vanity
(
https://fall-out-boy.kev.webly.site
, the label from the site's name, unique only within the namespace). Share
urls.primary
: the primary address (a custom domain when one is live, else the vanity, else the flat address, unless the owner chose a webly.site address as primary);
urls.all
lists every address the site answers at.
rename_vanity
changes a site's label;
get_namespace
/
check_namespace
/
rename_namespace
handle the namespace. Renames are scarce (Hobby 5, Pro 10, lifetime), so rename only to the exact name the person asked for, and tell them old vanity addresses stop working. The new addresses need about a minute for HTTPS: check
get_namespace
until
certificate
is
active
, then tell them they're live. On
402
, give them
details.upgradeUrl
.
A team workspace has one owner (
whoami
→
owner
). Ownership of the workspace itself (not moving a website) changes only in the dashboard's People page, by the owner; you can't do it, so send them there. The card and subscription stay with the workspace.
New content, including blog posts and repeating content (products, team, FAQs), goes in the site's source files; don't create collections or blog posts, the CMS is deprecated. A site that already reads collections or a managed blog keeps using those tools for that content until the owner asks to move it. Forms post with
formAction('name')
, never
mailto:
, and never ask for card numbers, passwords, ID numbers or health details (submissions are plain text). If the owner wants an email per submission, turn it on with
set_form_notifications
(off by default). Emails go out on Hobby and Pro; on Free the choice is saved: give the owner
upgradeUrl
. Name the email field
email
so replying to an alert answers the visitor. Each workspace takes 1,000 submissions a month on Free (10,000 Hobby, 100,000 Pro); past that they're held: hidden, no alerts, and deleted at the monthly reset unless the owner upgrades. When
list_forms
shows
quota.held
, tell the owner and give them
upgradeUrl
. Details are in llms.txt.
403
names the missing capability in
details.capability
: the grant was narrower than the task, so tell them which access level covers it.
401
/
invalid_token
: call a Webly tool again to re-trigger sign-in; don't start a second attempt while one is waiting. Other people and agents may edit the same site at once, and people may edit text, styles, layout, sections, new elements and images, pages and brand colours, and component props in the dashboard, on static sites too (History shows them as Editor), so re-read a file before editing it. On a static site the editor's classes compile into
/webly.css
, linked from each page that uses them: keep that file and its
<link>
. Prefer
str_replace
for small edits. Send
baseVersion
(the
version
your read returned) with
put_source_file
/
delete_source_file
: their edits to other lines are merged with yours;
409 merge_conflict
means you both changed the same lines — read the file again, re-apply your change keeping theirs, resend with the new version.
wait_for_changes
shows what others wrote since a version. Publish with
version
set to the one the person previewed. History is linear, so the versions between the last publish and that one go live with it (newer ones stay unpublished); the response's
alsoPublishes
lists the ones other people or agents wrote (who, app, message). Tell your person what of theirs went live. Publishing an older version puts nothing new live, and
alsoPublishes
is empty. To help someone choose a version:
list_changes
and
diff_source_file
(from the version before it) show what it changed, and
preview_version
gives a private link to how it looked for an hour, changing nothing.
Git:
get_git_access
gives a read-only clone of a signed-in site's source and history (one commit per version). Its token lasts one minute, so run its
clone
(or
pull
inside the clone) straight away as
WEBLY_GIT_TOKEN=<token> <clone>
, never with the token in the URL. Check
headVersion
with
get_website
before asking again. Never
git push
; write through the tools.
首先调用
whoami
和
list_websites
,并继续使用现有站点(如果
doctor
显示文件夹已关联,则使用该关联站点),而不是创建第二个站点。通过
create_website
为磁盘上的项目创建站点后,在项目文件夹中运行
webly link <websiteId>
,以便后续会话找到它。
工作区。
whoami
→
workspaces: "all"
表示此连接可用于用户所属的每个工作区。
list_workspaces
会列出工作区及其在每个工作区中的角色。站点 ID 在任何工作区中都有效,因此站点工具不需要其他信息。对整个工作区执行操作的工具(
create_website
、
list_websites
、
get_billing
等)需要将其 slug 作为
workspace
参数。如果用户有多个工作区,创建站点前应询问使用哪一个;遇到
400 workspace_required
时也应询问,绝不猜测。
workspaces: "one"
表示连接仅限于一个工作区。如果用户需要其他工作区(
list_workspaces
显示
canUse: false
),则需要重新连接:在 Claude Code 中进入
/mcp
→ webly → re-authenticate,并选择 All my workspaces。当网站所有者询问“Made with Webly”徽标时:Hobby 和 Pro 站点默认不显示该徽标,除非用户主动选择启用。
set_workspace_badge
可为所有站点(包括新站点)统一开启或关闭;
update_website
使用
showBadge
可单独设置某个站点,且单独设置始终优先(
null
表示重新遵循工作区设置)。Free 套餐始终显示该徽标:遇到
402 plan_required
时,提供
details.upgradeUrl
。
当网站所有者需要团队工作区照片时,
set_workspace_photo
可接受公开图片的
url
,也可接受以
base64
提供的文件(PNG、JPEG、WebP 或 GIF,最大 2 MB);
remove_workspace_photo
会清除照片。个人工作区显示用户自己的个人资料照片,用户可以在控制面板中修改。
不使用 MCP 的 REST(脚本或没有 MCP 的主机):
webly login
会打开浏览器,进入同一个登录及工作区选择流程;然后
webly api GET /websites --workspace <slug>
(或任何
/v1
路径,使用
--data
提供 JSON 请求体)会以用户身份调用 API。Token 保留在辅助工具中;绝不要索取或打印它。
webly logout
会撤销它。
  1. 框架站点(类型化 React,默认):使用
    put_source_file
    /
    str_replace
    (无需租约)。静态站点:小规模文本编辑使用
    search_source
    和带
    { path, edits }
    的
    str_replace
    ;
    deploy_files
    仅用于少量完整的小文件,并将
    expectedHeadVersion
    设置为
    read_source_files
    返回的版本(缺少该值会返回
    400 base_required
    )。如果期间有人进行了写入,你的更改会与对方的更改合并(响应中显示
    merged
    );
    409 merge_conflict
    表示双方修改了相同行:告知用户其变更是哪一方的(
    theirsBy
    ),重新读取、重新应用并重新发送。只有用户明确要求时才使用
    force
    。对于磁盘上的文件夹(构建生成的
    dist/
    、任何包含 bundle 或图片的目录),使用站点 ID 调用
    begin_deploy
    ,并立即运行
    webly deploy <folder> --ticket <ticket> --message "<subject>" --body "<what changed and why>"
    (工单有效期为 5 分钟且只能使用一次;绝不要将工单回显给用户)。每次写入(部署、
    put_source_file
    、
    str_replace
    、删除)都需要提供一条消息,写法类似 Git 提交消息:先写约 50 个字符的祈使句主题(例如“在定价页优先显示年度套餐”),然后空一行,再用通俗语言写正文,说明改了什么、为什么改、涉及哪些页面以及需要检查什么。站点的 History 会显示主题,用户打开某个版本时还会看到正文,因此共享网站的人可以区分你的版本与其他人的版本。仅在进行微小更改时可以省略正文。辅助工具会按需构建项目并上传(最多 2000 个文件;超过 1 MiB 的图片和视频会直接进入存储,受套餐单文件上限约束),关联文件夹并打印草稿 URL。绝不要在工具调用中放入 bundle 的字节,也不要在 shell 命令中加入 API key。如果命令以
    would_revert
    停止,说明部署会撤销自此文件夹上次部署以来对站点所做的更改(路径会列在输出中):使用
    read_source_files
    读取这些更改,将它们合并到本地项目中,重新构建,再使用新工单部署;或者告知用户哪些内容会被撤销,并在获得用户同意后使用新工单和
    --force
    部署。如果命令以
    would_remove
    停止,说明站点存在文件夹中没有的文件(会列在输出中):将这些文件加入文件夹,或者仅在用户同意后使用
    --force
    部署。已登录站点的 Git 镜像克隆(
    get_git_access
    )也使用相同方式部署:辅助工具会保留
    .webly/media.json
    中列出的图片,并从 Git 历史中采用其基线;当它提示克隆落后时,先运行
    git pull
    。如果结果中包含
    replaced
    ,告知用户该站点在其他位置发生过更改,并且较早版本仍然保留。每次写入都会创建新的草稿版本;线上站点不会改变。写入内容会按 Prettier 格式化,因此应从
    read_source_file
    复制
    str_replace
    所需文本。
  2. check_head
    会运行质量门禁(lint、类型检查、bundle、渲染)。修复所有诊断信息。
  3. 向用户展示草稿 URL(
    https://draft--{subdomain}.webly.site
    ;该地址不公开,也不会被索引)。
  4. 只有当用户明确同意该确切站点和版本后,才调用
    publish_website
    。它会等待正在进行的构建;返回
    202
    且
    status: "building"
    表示 Webly 仍在构建(并非失败):约 15 秒后再次发布该版本,并告知用户它仍在构建。如果线上内容有问题,则使用
    rollback_website
    /
    unpublish_website
    。
新站点会获得一个简短生成的地址(
zen-wreath-y76r.webly.site
);除非用户要求指定地址,否则不要传入
subdomain
(最长 56 个字符;地址已被占用时返回
409
,不会提供变体)。在 Free 套餐上,每个站点的 webly.site 地址可以更改一次(使用
rename_subdomain
;Hobby 和 Pro 不限次数),因此应先运行
check_subdomain
,且只在用户要求的确切名称时执行重命名。在 Hobby 和 Pro 套餐上,工作区还拥有命名空间,每个已发布站点都可通过
urls.vanity
访问(例如
https://fall-out-boy.kev.webly.site
;标签来自站点名称,仅在命名空间内唯一)。应分享
urls.primary
:主地址(自定义域名已上线时为自定义域名,否则为 vanity 地址,否则为扁平地址,除非所有者选择了某个 webly.site 地址作为主地址);
urls.all
列出站点可响应的全部地址。
rename_vanity
更改站点标签;
get_namespace
/
check_namespace
/
rename_namespace
用于管理命名空间。重命名次数很少(Hobby 5 次、Pro 10 次、终身套餐同样有限),因此只在用户要求的确切名称时执行,并告知用户旧的 vanity 地址将停止工作。新地址大约需要一分钟才能启用 HTTPS:检查
get_namespace
,直至
certificate
为
active
,然后告知用户地址已上线。遇到
402
时,提供
details.upgradeUrl
。
团队工作区只有一位所有者(
whoami
→
owner
)。工作区本身的所有权转移(而非移动网站)只能由所有者通过控制面板的 People 页面完成;你无法执行,因此应引导用户前往该页面。工作区卡片和订阅仍归工作区所有。
新内容,包括博客文章和重复性内容(产品、团队、FAQ),应放入站点的源文件中;不要创建 collections 或博客文章,CMS 已弃用。仍在读取 collections 或使用托管博客的站点,应继续对这些内容使用相应工具,直到所有者要求迁移。表单使用
formAction('name')
提交,绝不使用
mailto:
,也绝不要索取卡号、密码、身份证号或健康信息(提交内容为纯文本)。如果所有者希望每次提交都发送邮件,则开启
set_form_notifications
(默认关闭)。邮件功能仅在 Hobby 和 Pro 套餐上可用;在 Free 套餐上会保存该选择:向所有者提供
upgradeUrl
。将电子邮件字段命名为
email
,这样回复提醒时可直接答复访客。每个工作区每月可接收 1,000 次提交(Free;Hobby 为 10,000 次,Pro 为 100,000 次);超出后,提交会被保留:隐藏、不发送提醒,并在月度重置时删除,除非所有者升级。当
list_forms
显示
quota.held
时,告知所有者并提供
upgradeUrl
。
详细信息见 llms.txt。
403
会在
details.capability
中指出缺少的能力:授权范围比任务所需更窄,因此告知用户哪种访问级别能够满足要求。遇到
401
/
invalid_token
:再次调用 Webly 工具以重新触发登录;不要在一次登录等待期间发起第二次尝试。其他人和其他 Agent 可能同时编辑同一站点;用户也可以在控制面板中编辑静态站点的文字、样式、布局、区块、新元素和图片、页面与品牌色,以及组件属性(History 会显示 Editor)。因此编辑前应重新读取文件。在静态站点上,编辑器的 class 会编译到
/webly.css
,使用这些 class 的每个页面都通过
<link>
引用该文件:应保留该文件及其
<link>
。小规模编辑优先使用
str_replace
。调用
put_source_file
/
delete_source_file
时应传入
baseVersion
(读取时返回的
version
):对方对其他行的编辑会与你的编辑合并;
409 merge_conflict
表示双方修改了相同行——重新读取文件,在保留对方更改的同时重新应用自己的更改,然后使用新版本重新发送。
wait_for_changes
显示自某个版本以来其他人写入的内容。发布时,将
version
设置为用户预览过的那个版本。History 是线性的,因此从上次发布到该版本之间的版本会随它一起上线(更新的版本仍保持未发布状态);响应中的
alsoPublishes
会列出其他人或其他 Agent 写入的版本(人员、应用、消息)。告知用户他们自己的哪些内容已经上线。发布较早版本不会让任何新内容上线,
alsoPublishes
也为空。为帮助用户选择版本:
list_changes
和
diff_source_file
(与前一版本比较)会显示发生的更改;
preview_version
会提供一个为期一小时的私密预览链接,不会更改任何内容。
Git:
get_git_access
会提供已登录站点源文件和历史的只读克隆(每个版本对应一次提交)。其 Token 仅一分钟有效,因此应立即以
WEBLY_GIT_TOKEN=<token> <clone>
的形式运行
clone
(或在克隆中运行
pull
),绝不要把 Token 放入 URL。再次询问用户之前,使用
get_website
检查
headVersion
。绝不要运行
git push
;应通过工具进行写入。

Turn a static site into a React site (or back)

将静态站点转换为 React 站点(或反向转换)

Create a new site of the other kind and port the pages yourself: components, and React state for what scripts did (or plain HTML and small scripts the other way). Leave the original untouched until your person is happy with the new one.
创建另一个类型的新站点,并自行迁移页面:迁移组件,以及原本由脚本实现的 React state(反向转换时则改为纯 HTML 和小型脚本)。在用户对新站点满意之前,保持原站点不变。

Duplicate or move a site

复制或移动站点

Hobby and Pro, in both workspaces (
402 plan_required
otherwise: give the person
details.upgradeUrl
).
duplicate_website
copies a site 1:1: every version, media, CMS, form submissions and settings, passwords; it is published if the original is (
publish.status: "building"
means a bigger site is still building and goes live by itself: tell your person it is still working), gets its own addresses, and custom domains stay with the original.
move_website
moves a site into another workspace your person admins, at once: everything comes along, including its webly.site address and custom domains, except form email alerts: their recipients are cleared, so set them again there (
set_form_notifications
). Its vanity address changes to the new workspace's and links to the old one stop working, so confirm first and share
urls.primary
.
list_move_destinations
lists the workspaces your person admins and whether the site fits (
reason
:
site_limit
,
storage_limit
,
plan_required
); ask which one. Both need a signed-in person (OAuth) to reach another workspace. To give it to someone else, ask for their email and call
start_website_transfer { toEmail }
: they're emailed and it waits on their Transfers page, where they accept or decline it (or their agent:
list_incoming_transfers
,
accept_website_transfer { transferId }
,
decline_website_transfer
). There are no transfer codes.
Hobby 和 Pro 套餐支持此操作,在两个工作区中均可使用(否则返回
402 plan_required
:向用户提供
details.upgradeUrl
)。
duplicate_website
会以 1:1 比例复制站点:所有版本、媒体、CMS、表单提交和设置、密码都会复制;如果原站点已发布,副本也会发布(
publish.status: "building"
表示较大的站点仍在构建,并会自动上线:告知用户它仍在正常工作),副本会获得自己的地址,而自定义域名仍归原站点所有。
move_website
会将站点立即移入用户拥有管理员权限的另一个工作区:所有内容都会一并移动,包括其 webly.site 地址和自定义域名,但表单邮件提醒的收件人会被清空,需要在目标工作区重新设置(
set_form_notifications
)。其 vanity 地址会变为新工作区的地址,旧地址将停止工作,因此应先确认并分享
urls.primary
。
list_move_destinations
会列出用户拥有管理员权限的工作区,以及站点是否适合移动(
reason
:
site_limit
、
storage_limit
、
plan_required
);如有多个选项,应询问用户。两个操作都需要已登录用户(OAuth)才能访问另一个工作区。若要将站点交给他人,询问其电子邮件地址并调用
start_website_transfer { toEmail }
:系统会向该地址发送邮件,用户需在其 Transfers 页面中接受或拒绝(也可由其 Agent 调用
list_incoming_transfers
、
accept_website_transfer { transferId }
或
decline_website_transfer
)。不存在转移代码。

Custom domains

自定义域名

Needs a signed-in account (MCP) on Hobby (5 domains) or Pro (25). On Free,
add_domain
is
402 domain_limit
: give the owner
details.upgradeUrl
. "Connect example.com to my site":
  1. Pick the site with
    list_websites
    . Never guess it from the hostname.
  2. For a bare domain, ask first:
    • www.example.com
      (recommended).
      It works with every DNS provider. The person then forwards
      example.com
      to it at their registrar, which is free and takes a minute, but usually http-only (see
      apexForward
      below).
    • example.com
      directly.
      Only if their DNS provider supports CNAME flattening or ALIAS at the root (Cloudflare, Namecheap, Porkbun…). For a subdomain such as
      shop.example.com
      , just add it.
  3. Call
    add_domain
    , then
    connect_domain
    . If it returns a
    url
    , give the person that link first: they sign in at their DNS provider (Cloudflare for any hostname; GoDaddy and others for www once they support it) and approve, and the records are set for them. They open it in the browser where they use Webly. With Cloudflare (
    method: "oauth"
    ) Webly also forwards the bare domain of a www domain if they allow redirects on Cloudflare's screen and nothing is served there yet (if
    apexForward
    isn't ok after verifying, give it to them). If records of theirs are in the way, nothing is replaced until they approve the exact changes shown after signing in; approving switches the hostname at once, so for a site live today offer the manual records (TXT first) to move without downtime. When you
    remove_domain
    and the response has
    dnsCleanup
    , ask whether to delete the records Webly added too, and if yes give them
    dnsCleanup.url
    . Otherwise (name.com, Squarespace, Google and most other providers), or as the fallback, give every required
    dns.records
    entry exactly as returned, as a Type / Name / Value table: the CNAME and the
    _acme-challenge
    TXT records. The TXT issues the HTTPS (SSL) certificate and is always needed; without it HTTPS can take hours. If it isn't in
    dns.records
    yet, call
    verify_domain
    a few seconds later and give it then. For a www domain, also give the
    apexForward
    forwarding rule (URL forwarding at their registrar makes the bare domain work too, usually over plain http only; for
    https://
    links, a provider with ALIAS can add the bare domain as a second domain on the site: TXT records first, the ALIAS once it's active). Check it with
    verify_domain
    (
    apexForward.ok
    ,
    apexForward.https
    ), not in a browser: Chrome quietly retries a bare domain with
    www
    . Provider tips:
    • Type only the Name shown (
      www
      , or
      @
      for the root). GoDaddy and Namecheap add the domain themselves.
    • On Cloudflare, set the record to "DNS only" (grey cloud).
    • Moving a domain that is live elsewhere? Keep its current record and add only the TXT records (the certificate ones and the optional ownership one). Then:
      1. Poll
        verify_domain
        until the domain is
        active
        . That means ownership is verified and the certificate is deployed. Step 2 isn't enough.
        domain-watch
        can't show this yet, because the old host still answers.
      2. Ask the person to switch the CNAME.
      3. Run
        webly domain-watch <hostname>
        to confirm traffic now reaches Webly.
  4. Start watching in the background right away. Don't wait for the person to say they're done:
    webly domain-watch <hostname>
    as a background task. It prints
    dns
    ,
    https
    and
    live
    as each happens and exits once the domain is live. Without a shell, call
    verify_domain
    every
    next.checkAgainSeconds
    . Every domain response has
    next
    with the step (1 DNS record, 2 HTTPS certificate, 3 live) and what to do. Tell the person when each step completes.
  5. Once live: confirm
    https://<hostname>
    loads. The first domain to go live on a site becomes its primary address by itself (
    isPrimary
    ), unless a primary was already chosen (another domain, or a webly.site address picked with
    set_primary_address
    ); every other address redirects to the primary. If another domain is already primary, offer
    set_primary_domain
    to switch, or
    set_primary_address
    if they want a webly.site address to be the primary (their custom domains then redirect to it; say so). If it's
    failed
    , relay
    failureMessage
    , have them fix the record, then call
    verify_domain
    again. If the domain is active but their browser says the server "could not be found" right after removing and re-adding it, their DNS cached the gap: it clears within the zone's negative-cache time (30 minutes by default on Cloudflare), or sooner if they flush their DNS cache and the stale answer was cached on their device (not by their router or ISP).
Adding a domain publishes nothing and takes nothing offline. The
*.webly.site
address keeps working.
此功能需要已通过 MCP 登录的账户,并需要 Hobby(5 个域名)或 Pro(25 个域名)套餐。在 Free 套餐上,
add_domain
会返回
402 domain_limit
:向所有者提供
details.upgradeUrl
。
“将 example.com 连接到我的站点”:
  1. 使用
    list_websites
    选择站点。绝不要根据主机名猜测站点。
  2. 对于裸域名,应先询问:
    • www.example.com
      (推荐)。
      它适用于所有 DNS 提供商。用户随后可在注册商处将
      example.com
      转发到该地址;此操作免费且约需一分钟,但通常仅支持 HTTP(参见下文的
      apexForward
      )。
    • 直接使用
      example.com
      。
      仅当其 DNS 提供商支持根域名的 CNAME flattening 或 ALIAS 时使用(Cloudflare、Namecheap、Porkbun 等)。 对于
      shop.example.com
      等子域名,直接添加即可。
  3. 调用
    add_domain
    ,然后调用
    connect_domain
    。如果返回
    url
    ,应先把该链接提供给用户:用户需在其 DNS 提供商处登录(任何主机名均可使用 Cloudflare;GoDaddy 等提供商在支持 www 后也可使用),并批准相关设置,记录将自动完成。随后,用户需在使用 Webly 的浏览器中打开该链接。对于 Cloudflare(
    method: "oauth"
    ),如果用户允许在 Cloudflare 页面重定向,且该裸域名尚未提供任何内容,Webly 还会转发 www 域名的裸域名(如果验证后
    apexForward
    状态不正确,则将链接提供给用户)。如果用户自己的记录造成冲突,在用户登录并批准登录后显示的确切更改之前,不会替换任何内容;批准后会立即切换主机名。因此,对于当前已上线的站点,应提供手动记录(先配置 TXT)以实现无停机迁移。当调用
    remove_domain
    且响应包含
    dnsCleanup
    时,询问用户是否也要删除 Webly 添加的记录;如果同意,则提供
    dnsCleanup.url
    。 其他提供商(name.com、Squarespace、Google 和大多数其他提供商)或作为后备方案时,应将每个必需的
    dns.records
    条目完全按返回结果提供,并整理为 Type / Name / Value 表:其中必须同时包含 CNAME 和
    _acme-challenge
    TXT 记录。TXT 记录用于签发 HTTPS(SSL)证书,始终必需;缺少该记录时,HTTPS 可能需要数小时才能完成。如果
    dns.records
    中暂时还没有这些内容,请在几秒后调用
    verify_domain
    ,届时再提供给用户。对于 www 域名,还应提供
    apexForward
    转发规则(在注册商处进行 URL 转发通常也能让裸域名生效,但一般仅支持纯 HTTP;对于
    https://
    链接,支持 ALIAS 的提供商可以将裸域名作为站点的第二个域名添加:先配置 TXT 记录,ALIAS 生效后再添加)。使用
    verify_domain
    检查
    apexForward.ok
    和
    apexForward.https
    ,不要只在浏览器中检查:Chrome 会在静默重试 www 域名的裸域名时忽略此问题。提供商提示:
    • Type 只填写显示的 Name(
      www
      ,根域名则为
      @
      )。GoDaddy 和 Namecheap 会自行添加域名。
    • 在 Cloudflare 中,将记录设置为“DNS only”(灰色云朵)。
    • 正在迁移已在其他位置上线的域名?保留其当前记录,只添加 TXT 记录(证书记录和可选的所有权记录)。然后:
      1. 轮询
        verify_domain
        ,直至域名为
        active
        。这意味着所有权已验证且证书已部署,仅完成第 2 步并不足够。由于旧主机仍在响应,此时
        domain-watch
        还无法显示结果。
      2. 请用户切换 CNAME。
      3. 运行
        webly domain-watch <hostname>
        ,确认流量现已到达 Webly。
  4. 立即在后台开始监视,不要等待用户表示已经完成: 将
    webly domain-watch <hostname>
    作为后台任务运行。它会依次打印
    dns
    、
    https
    和
    live
    ,并在域名上线后退出。如果没有 shell,则每隔
    next.checkAgainSeconds
    调用一次
    verify_domain
    。每个域名响应都包含
    next
    ,其中会指明步骤(1 DNS 记录、2 HTTPS 证书、3 上线)和应执行的操作。每一步完成时都应告知用户。
  5. 上线后:确认
    https://<hostname>
    能够加载。站点上第一个成功上线的域名会自动成为主地址(
    isPrimary
    ),除非已经选定主地址(另一个域名,或通过
    set_primary_address
    选定的 webly.site 地址);其他所有地址都会重定向到主地址。如果另一个域名已经是主地址,可提供
    set_primary_domain
    进行切换;如果用户希望 webly.site 地址成为主地址,则使用
    set_primary_address
    (此时自定义域名会重定向到该地址,应明确告知)。如果状态为
    failed
    ,传达
    failureMessage
    ,请用户修复记录,然后再次调用
    verify_domain
    。如果域名处于 active 状态,但用户在移除并重新添加域名后,浏览器却提示“找不到服务器”,则其 DNS 缓存了这段空档:在 Cloudflare 中,默认会在该区域的负缓存时间后清除(通常为 30 分钟);如果过期答案缓存在用户设备上,清除其 DNS 缓存后可能更快恢复(问题不在路由器或 ISP 上)。
添加域名不会发布任何内容,也不会使任何内容下线。
*.webly.site
地址会继续有效。

Rules

规则

  • The token is a secret that proves ownership. Never print it, log it, commit it, or put it in a URL other than through
    webly claim-link
    .
  • Only state URLs, sites and counts that a command or tool actually returned.
  • Don't set up MCP for someone who only wants a quick link; offer it when they want to keep or grow the site.
  • One anonymous site per machine. If they want a second site kept, claim the first, then create the second over MCP and
    webly link
    it.
  • A folder belongs to the site in its
    .webly/project.json
    . Never deploy it to, or claim, a different site unless the person asks.
  • Token 是证明所有权的机密信息。绝不打印、记录或提交它,也不要将其放入
    webly claim-link
    以外的 URL。
  • 只陈述命令或工具实际返回的 URL、站点和数量。
  • 不要为只需要临时链接的用户配置 MCP;当用户想保留或扩展站点时再提供。
  • 每台机器只能拥有一个匿名站点。如果用户想永久保留第二个站点,应先认领第一个,再通过 MCP 创建第二个并运行
    webly link
    。
  • 文件夹归属于其
    .webly/project.json
    中指定的站点。除非用户明确要求,否则绝不将该文件夹部署到其他站点,也绝不认领其他站点。