vefaas

This skill guides you to use

@volcengine/vefaas-cli

to operate Volcano Engine veFaaS, including operations available on the Volcano Engine Function Compute console such as application deployment, function management, sandbox management, environment variables, configuration, diagnosis, as well as OpenAPI calls.

Prerequisites

CRITICAL — Before performing any veFaaS operations, MUST confirm that the local
vefaas
CLI version >= 0.2.7.

bash

vefaas --version
vefaas update --check

If the command does not exist, or the version is lower than

0.2.7

, you must upgrade first; if

vefaas update --check

finds an available update, prompt the user to upgrade before continuing:

bash

npm i -g @volcengine/vefaas-cli@latest
vefaas --version

Document Retrieval Capability (No Login Required) —

vefaas doc

allows you to search Volcano Engine veFaaS official documents in the terminal, no login required, read-only, no charges. This is the authoritative knowledge source for this skill to answer questions about veFaaS concepts/capabilities/selection/billing/SDK usage, and to write SDK/OpenAPI code. See the "doc-first Protocol" below for details. Run

vefaas doc --help

to confirm availability; if unavailable, upgrade the CLI via

vefaas update

first.

Applicable Scenarios

Use this skill when:

You want to deploy local projects, websites, API services, Node.js services, Python services or static sites to Volcano Engine veFaaS.
You want to create serverless applications based on templates, or connect existing projects to veFaaS.
You want to view console overview, online access addresses, release records, logs or resource usage.
You want to configure environment variables, adjust build commands, startup commands, ports or resource configurations, or delete existing applications.
You want to manage online functions: create, view, publish, rollback, call, logs, instances, tasks, scaling policies, triggers, dependencies, WebShell.
You want to pull cloud function code, push local modifications or redeploy.
You want to manage sandbox applications, sandbox instances, sandbox images, sandbox logs, sandbox WebShell.
You want to troubleshoot issues such as deployment failures, authentication failures, framework detection errors, missing gateways, configuration inconsistencies or OpenAPI call failures.
You explicitly need to call veFaaS OpenAPI actions, or high-level commands cannot cover the target operation.
You are exposed to veFaaS for the first time, don't know what it is or how to get started, and need landing guidance (can start without logging in first).
You ask questions about veFaaS concepts, capability boundaries, resource selection, billing, quotas, triggers, etc., and need accurate answers based on official documents.
You want to access veFaaS SDK (Go/Python/Node) or call OpenAPI in your own code, and need to refer to official examples for assisted development.

Resource Mental Model

Functions are the core resources of veFaaS (Function Compute), carrying code/images, versions, instances, logs, resource specifications and scaling policies; function instances are usually dynamically scaled by the platform according to traffic and policies.
Applications are product forms after orchestrating application-level logic based on functions, including overall version management, APIG trigger association, Git repository automatic trigger deployment, etc., to help users publish and access applications more conveniently.
Sandboxes are special/customized functions, with Function, Revision, Instance models similar to functions, but must be created based on pre-warmed images, suitable for scenarios such as code sandboxes, model evaluation that require second-level startup of isolated environments; sandbox instances need to be actively created, and support pause, resume, shutdown and adjustment of expiration time.
For more detailed resource relationships, ID usage rules or CLI target mappings, read CLI and Version.

CRITICAL Workflow Diversion

CRITICAL — First determine whether the user's intention is "knowledge-based" or "execution-based", then divert:

Knowledge-based (asking about concepts/capabilities/selection/billing/quotas; first-time use, need landing guidance; need to write SDK/OpenAPI integration code) → Follow the "doc-first Workflow": First use
vefaas doc
to search official documents, answer or write code based on documents, usually no login required. MUST read Document Retrieval and doc-first before proceeding.
Execution-based (real resource operations such as deployment, release, rollback, call, management of functions/applications/sandboxes/gateways, etc.) → Follow the corresponding execution workflow below.
Hybrid (e.g., "Help me deploy this project, and explain the billing by the way") → First use doc-first to answer questions, then follow the execution workflow.

The diversion rules for execution-based workflows are as follows:

CRITICAL — When the user says "deploy project / website launch / API launch / serverless application / view access address", default to the application workflow, do not directly create functions.

The application workflow uses

vefaas init

vefaas inspect

vefaas link

vefaas deploy

vefaas domains

vefaas env

vefaas config

vefaas app

vefaas overview

vefaas resource

. MUST read Application Workflow before proceeding.

CRITICAL — Only follow the function workflow when the user provides an existing function ID/name, or explicitly says "function / fn / pull function code / release function / rollback function / function logs".

The function workflow uses

vefaas fn ...

vefaas pull

vefaas push

vefaas deploy --funcId

. MUST read Function Management before proceeding.

CRITICAL — Follow the sandbox workflow when the user says "sandbox / sandbox instance / temporary instance / instance pause resume kill / sandbox image".

The sandbox workflow must distinguish between sandbox application and sandbox instance; application ID and instance name cannot be used interchangeably. MUST read Sandbox Management before proceeding.

CRITICAL — Do not directly use
vefaas api
when high-level commands can complete the task.

Only use the OpenAPI workflow when high-level commands are missing, the user explicitly requests OpenAPI, or underlying action fields are required. MUST read OpenAPI Calls before proceeding, and first execute

vefaas api <Action> --help

to view the parameter structure.

Required Reference Protocol

Before performing corresponding tasks, MUST read the corresponding reference; do not execute complex operations only based on the quick reference commands in this document.

Scenario	Required Document
Q&A, landing guidance, checking official documents, writing SDK/OpenAPI integration code	Document Retrieval and doc-first
Installation, upgrade, confirming CLI version	CLI and Version
Login, checking credentials, restoring authentication	Authentication and Credentials
Initializing templates, deploying applications, link, inspect, domains, application env/config	Application Workflow
Managing functions, code, release, rollback, logs, calls, configuration, scaling	Function Management
Function APIG triggers, sandbox gateway route configuration, APIG route binding and editing	Triggers and APIG Route
Managing sandbox application / instance	Sandbox Management
Directly calling veFaaS OpenAPI	OpenAPI Calls
Troubleshooting failures, diagnosing environment	Troubleshooting

Global Execution Rules

In non-interactive AI/CI scenarios, prioritize adding
```
--yes
```
when the target is clear.
When parsing output is needed, prioritize using
```
--output json
```
, then cooperate with
```
--jq
```
,
```
--fields
```
,
```
--limit
```
.
When unsure about commands or flags, first run
```
vefaas <command> --help
```
, do not guess parameters.
When encountering issues with credentials, project configuration, local environment or OpenAPI connectivity, prioritize executing
```
vefaas doctor
```
.
```
--debug
```
is only used for diagnosis; debug output and
```
~/.vefaas/logs/
```
may contain sensitive request/response information.
Do not echo Access Key ID, Secret Access Key, session token, OAuth/OIDC token, database connection strings,
```
.env
```
values in plaintext to users.
The
```
vefaas doc
```
series is read-only, no login required, no charges, can be called freely multiple times, and is not restricted by the "High-Risk Operation Protocol" below. When the agent uses documents internally, always add
```
-o json
```
and read
```
data.markdown
```
(body) or
```
data.results[]
```
(search results); only use the default text mode when rendering documents for human viewing.

doc-first Protocol

When involving veFaaS concepts, capabilities, selection, billing, quotas, SDK usage, OpenAPI parameters, MUST first use
vefaas doc
to search official documents, then answer or write code; it is forbidden to directly answer these specific facts from memory.

Use built-in aliases to directly access high-frequency topics:
```
intro
```
(product introduction),
```
quickstart
```
(quick start),
```
cli
```
,
```
sdk
```
(SDK overview),
```
api
```
. For SDKs in various languages, use the subcommand
```
vefaas doc sdk go|python|node -o json
```
.
For long-tail questions (billing, quotas, triggers, gateways, a specific function), first run
```
vefaas doc search <keywords> -o json
```
, select the most matching leaf document from
```
data.results[]
```
by
```
title
```
+
```
path
```
(breadcrumbs), get its
```
documentId
```
, then run
```
vefaas doc --id <id> -o json
```
to read
```
data.markdown
```
.
Q&A: The answer must not exceed
```
data.markdown
```
; billing/quotas/quotas must quote the original values from the document; attach the source
```
data.url
```
and update time
```
data.updatedTime
```
at the end of the answer.
Writing SDK/OpenAPI code: First take the official example (
```
vefaas doc sdk go|python|node -o json
```
) as the skeleton; use
```
vefaas doc sdk methods <Action> -o json
```
to check the request fields (type + description + nesting) of the Action, and add
```
--lang
```
to get the request example. It is forbidden to generate SDK calls from memory.
If
```
vefaas doc --id
```
hits a directory node, it will report not-found (directory nodes have no body) → Go back to the search results and choose a deeper leaf document.
If no results are found in search, use
```
vefaas doc tree -o json
```
to browse the directory; if still not found, truthfully state that the official document does not cover it, do not fabricate.

Complete workflows for three types of scenarios (landing / Q&A / SDK access) can be found in Document Retrieval and doc-first.

High-Risk Operation Protocol

The following operations will affect online behavior or destroy resources, and must confirm the target resources and user intentions before execution:

Delete applications, delete functions, delete sandbox applications, delete sandbox images.
kill / pause / resume sandbox instance.
Rollback functions or sandboxes.
Modify production environment triggers, etc.

Processing Rules:

First display the resource identifier (app/function/sandbox ID or name) and action to be operated.
If the target is not unique or only comes from the user's oral name, first use list/info to disambiguate.
Execute only after the user explicitly confirms; do not silently add
```
--yes
```
to bypass confirmation.
Stop if the user refuses or the target is unclear, do not guess alternative targets on your own.

Special Rules for Application Deletion: Before deleting a veFaaS Application, first execute

vefaas app delete --id <app-id> --check -o json

for pre-check. If the check finds shared or potentially continuously billed resources such as APIG/NAT/EIP, in non-interactive scenarios, you must explicitly pass

--ack-shared-resources

; do not use the global

--yes

instead of such risk confirmation. Only when the user explicitly accepts skipping the pre-block, use

--force --yes

, and explain that associated resources may not be automatically cleaned up.

Target Disambiguation Rules

App name, function name, sandbox name may not be unique; prioritize using ID for write operations.
If only the name is available without ID, first use
```
list
```
/
```
info
```
/
```
config list
```
/
```
config pull
```
to obtain real resource information.
Gateway name is required for new application deployment; first execute
```
vefaas gateway list --first
```
. If no result is returned, stop and ask the user to provide an existing gateway or create one first.
The existence of
```
.vefaas/config.json
```
in the current directory does not necessarily mean it is the target the user wants to operate; confirm via
```
vefaas config list
```
before performing online write operations.
Sandbox application ID and sandbox instance name cannot be interchanged; before instance operations, first execute
```
vefaas sandbox instance list --id <sandbox-application-id>
```
.

vefaas

NPX Install

Tags

SKILL.md Content (Chinese)

vefaas

Prerequisites

Applicable Scenarios

Resource Mental Model

CRITICAL Workflow Diversion

Required Reference Protocol

Global Execution Rules

doc-first Protocol

High-Risk Operation Protocol

Target Disambiguation Rules