Tio Boot Docs

Appearance

函数库与调用接口 ​

函数库保存用户自己写的 Python 函数，并提供调试、语法检查、执行、导出导入和图标管理。执行环境与执行器实现分别见隔离 Python 执行环境配置和隔离 Python 执行器。

Java MossKB 的函数库与前端界面是同一套契约：列表分页、参数定义、初始化参数、内置模板、导出导入都在这一层对齐，官方前端的函数库页面可以整体复用。

函数库列表：创建、导入、搜索、启用开关与更多操作

一、存储 ​

迁移脚本 scripts/012-function-lib-fields.sql 补齐函数类型、图标和模板来源三个字段，scripts/013-function-lib-templates.sql 写入内置函数模板。两个脚本都可以重复执行，已有数据保留：

powershell
.\scripts\Initialize-Database.ps1 -PostgresBin '<PostgreSQL安装目录>\bin'
sql
BEGIN;

ALTER TABLE moss_kb_function_lib ADD COLUMN IF NOT EXISTS function_type VARCHAR(16) NOT NULL DEFAULT 'PUBLIC';
ALTER TABLE moss_kb_function_lib ADD COLUMN IF NOT EXISTS icon VARCHAR(256) NOT NULL DEFAULT '/ui/favicon.ico';
ALTER TABLE moss_kb_function_lib ADD COLUMN IF NOT EXISTS template_id BIGINT;

DO $$
BEGIN
  IF NOT EXISTS (SELECT 1 FROM pg_constraint WHERE conname = 'moss_kb_function_lib_function_type_check') THEN
    ALTER TABLE moss_kb_function_lib
      ADD CONSTRAINT moss_kb_function_lib_function_type_check CHECK (function_type IN ('PUBLIC', 'INTERNAL'));
  END IF;
END $$;

CREATE INDEX IF NOT EXISTS idx_function_type ON moss_kb_function_lib(function_type) WHERE deleted = false;

COMMIT;
字段含义
id雪花 ID，内置模板用 1001 到 1005 这类固定编号
user_id归属用户；内置模板归系统管理员，只用来标记来源
name / desc名称与描述
code函数源码
input_field_list调用参数定义（名称、类型、是否必填、来源）
init_field_list初始化参数定义，结构交给动态表单渲染
init_params初始化参数值，按函数保存
permission_typePRIVATE 或 PUBLIC
function_typePUBLIC 是用户函数，INTERNAL 是内置模板
icon图标路径，默认 /ui/favicon.ico
template_id从哪个内置模板复制而来，自己创建的函数为空
is_active是否启用
deleted软删除标记

删除是软删除（deleted=true），同时清掉 template_id；已保存的函数可以随时重新启用。

列表和详情都按同一条可见性规则筛选，SQL 直接写成一段文本块，参数按占位符顺序绑定：

java
import java.util.ArrayList;
import java.util.List;

/** 列表和详情共用的查询条件：自己的函数加上别人公开的函数。 */
private static final String VISIBLE_WHERE = """
    from moss_kb_function_lib
     where deleted = false
       and (user_id = ? or permission_type = 'PUBLIC')
    """;

/** 查询条件按占位符顺序累积，分页和列表共用。 */
private static final class Query {
  private String where;
  private final List<Object> params = new ArrayList<>();

  private Query(String where) {
    this.where = where;
  }
}

二、接口 ​

接口都要求登录，并且只允许操作自己的函数；别人的公开函数只能读、复制、执行：

方法与路径功能
GET /api/function_lib函数列表，最多 100 条
GET /api/function_lib/{page}/{size}分页函数列表，size 上限 100
POST /api/function_lib创建函数，新建后默认停用
GET /api/function_lib/{id}查看函数
PUT /api/function_lib/{id}修改自己的函数
DELETE /api/function_lib/{id}软删除自己的函数
POST /api/function_lib/debug调试尚未保存的代码
POST /api/function_lib/pylint语法检查，返回行列诊断
POST /api/function_lib/{id}/execute执行自己保存且已启用的函数
POST /api/function_lib/{id}/add_internal_fun把内置模板复制成自己的函数
GET /api/function_lib/{id}/export导出 .fx 文件
POST /api/function_lib/import导入 .fx 文件
PUT /api/function_lib/{id}/edit_icon上传图标
GET /api/function_lib/icon/{name}读取图标，不要求登录

列表接口支持三个查询参数，可以组合使用：

参数含义
name按名称模糊匹配（ilike）
function_typePUBLIC 或 INTERNAL，界面上的两个页签就是靠它区分
select_user_id只看某个用户的函数

pylint 只在执行环境里做语法检查，返回前端可用的行列信息，不等同于完整 Pylint 规则集。保存函数时也接受部分字段：只提交 is_active、只提交 permission_type 或只提交 init_params 时，其余字段沿用库里的原值，界面上的启用开关和权限弹窗就是这么用的。

三、参数 ​

调试请求 ​

编辑器里的"调试"按钮打开的是一个独立抽屉：上面按 init_field_list 渲染启动参数，下面按 input_field_list 渲染输入参数，点"运行"就调一次调试接口，结果直接显示返回值或原始异常。

函数调试：填 2 和 40，运行成功并返回 42

POST /api/function_lib/debug 的请求体沿用原版前端的字段结构：

json
{
  "code": "def add(a, b):\n    return a + b",
  "entrypoint": "add",
  "init_params": { "a": 1, "b": 1 },
  "input_field_list": [
    { "name": "a", "type": "int", "is_required": true },
    { "name": "b", "type": "int", "is_required": true }
  ],
  "debug_field_list": [
    { "name": "a", "value": "2" },
    { "name": "b", "value": "40" }
  ]
}

init_params 是保存函数时带下来的初始值；debug_field_list 是这次调试输入的值，按字段名覆盖初始值；input_field_list 决定字段类型和必填校验。上例返回 42。

合并规则在 Java 侧完成，必填校验也放在这里，缺参数时根本不会启动执行环境：

java
import com.alibaba.fastjson2.JSONArray;
import com.alibaba.fastjson2.JSONObject;

/** 调试未保存的代码：先合并参数，再交给执行器，异常信息直接返回给界面。 */
public Object debug(JSONObject input) {
  JSONObject params = input.getJSONObject("init_params");
  params = params == null ? new JSONObject() : new JSONObject(params);
  JSONObject debug = new JSONObject();
  JSONArray values = input.getJSONArray("debug_field_list");
  if (values != null) {
    for (Object item : values) {
      JSONObject field = (JSONObject) item;
      debug.put(field.getString("name"), field.get("value"));
    }
  }
  JSONArray fields = input.getJSONArray("input_field_list");
  if (fields != null) {
    for (Object item : fields) {
      JSONObject field = (JSONObject) item;
      String name = field.getString("name");
      Object value = debug.get(name);
      if (value instanceof String text && text.isBlank()) {
        value = null;
      }
      if (value == null) {
        if (field.getBooleanValue("is_required")) {
          throw new IllegalArgumentException("缺少函数参数：" + name);
        }
        params.remove(name);
        continue;
      }
      params.put(name, convert(value, field.getString("type")));
    }
  }
  return Aop.get(IsolatedPythonExecutor.class).execute(input.getString("code"), params, input.getString("entrypoint"), false);
}

类型与合并规则 ​

支持 string、int、float、dict、array 五种类型，转换在 Java 侧完成：

类型转换结果
intLong
floatDouble
dictJSON 对象
arrayJSON 数组
其它/string字符串
java
static Object convert(Object value, String type) {
  if (value == null) {
    return null;
  }
  return switch (type == null ? "string" : type) {
    case "int" -> Long.valueOf(value.toString().trim());
    case "float" -> Double.valueOf(value.toString().trim());
    case "dict" -> JSON.parseObject(value.toString());
    case "array" -> JSON.parseArray(value.toString());
    default -> value.toString();
  };
}

保存函数的初始化参数与调用参数合并后一起传入 Python，调用参数优先。必填字段缺失时直接拒绝，返回 缺少函数参数：<名称>，不会进入执行环境。公开函数的列表接口不会向其他用户返回 init_params 的值。

入口函数规则：请求里给了 entrypoint 就用它，否则取源码中最后一个顶层函数；两者都取不到时返回"代码需要至少一个顶层函数"。

参数来源与校验 ​

调用参数除了名称、类型、是否必填，还有 source 字段：custom 表示调用时手填，reference 表示由上游节点传入。保存前的校验集中在 validate 里，返回 null 表示通过：

java
/** 保存前的字段校验，返回 null 表示通过。 */
static String validate(JSONObject data) {
  String name = data.getString("name");
  if (name == null || name.isBlank() || name.trim().length() > MAX_NAME_LENGTH) {
    return "函数名称不能为空且不能超过 64 个字符";
  }
  String code = data.getString("code");
  if (code == null || code.isBlank()) {
    return "函数代码不能为空";
  }
  if (code.getBytes(java.nio.charset.StandardCharsets.UTF_8).length > MAX_CODE_LENGTH) {
    return "函数代码不能超过 64 KiB";
  }
  JSONArray fields = data.getJSONArray("input_field_list");
  if (fields != null) {
    for (Object item : fields) {
      if (!(item instanceof JSONObject field)) {
        return "调用参数格式无效";
      }
      String type = field.getString("type");
      String source = field.getString("source");
      if (type != null && !FIELD_TYPES.contains(type)) {
        return "参数类型只支持 string、int、float、dict、array";
      }
      if (source != null && !FIELD_SOURCES.contains(source)) {
        return "参数来源只支持 custom、reference";
      }
    }
  }
  return null;
}
限制项取值
函数名称最长 64 个字符
函数描述最长 128 个字符
函数代码最长 64 KiB（按 UTF-8 字节数）
参数类型string、int、float、dict、array
参数来源custom、reference
权限类型PRIVATE、PUBLIC
图标不超过 10 MB，支持 png、jpg、gif、webp、bmp

初始化参数的保护 ​

初始化参数里经常放 API Key 和数据库口令，所以界面拿到的密码类字段是打过码的，只保留首尾片段：

java
/** 保留前 2 位和后 4 位，中间用固定长度的星号占位。 */
static String mask(String secret) {
  String prefix = secret.substring(0, Math.min(2, secret.length()));
  String suffix = secret.length() > 4 ? secret.substring(secret.length() - 4) : "";
  return prefix + "********" + suffix;
}

详情里的打码值会被界面原样回传（例如只切换启用开关、只改权限时）。提交值和当前值的打码结果一致，说明用户没有改动，继续沿用库里的真实值，不会把星号写回库：

java
/**
 * 详情里的密码类初始化参数是打过码的，界面原样回传时不能把星号写回库。
 *
 * <p>提交值和当前值的打码结果一致，说明用户没有改动，继续沿用库里的原值。
 */
private void restoreMaskedSecrets(Row existing, JSONObject data) {
  if (!(data.get("init_params") instanceof JSONObject submitted) || submitted.isEmpty()) {
    return;
  }
  JSONObject current = parseObject(existing.getObject("init_params"));
  for (String key : submitted.keySet()) {
    Object value = submitted.get(key);
    Object stored = current.get(key);
    if (stored != null && value != null && mask(stored.toString()).equals(value.toString())) {
      submitted.put(key, stored);
    }
  }
}

初始化字段被删掉后，库里残留的同名值不会再传给 Python：

java
/** 初始化参数只保留仍在初始化字段列表里的键。 */
static JSONObject normalizeInitParams(JSONObject data, String initFieldsJson) {
  JSONObject params = data.getJSONObject("init_params");
  params = params == null ? new JSONObject() : new JSONObject(params);
  JSONArray fields = JSON.parseArray(initFieldsJson);
  List<String> keys = new ArrayList<>();
  for (Object item : fields) {
    if (item instanceof JSONObject field && field.getString("field") != null) {
      keys.add(field.getString("field"));
    }
  }
  params.keySet().removeIf(key -> !keys.contains(key));
  return params;
}

四、执行 ​

POST /api/function_lib/{id}/execute 执行自己保存且启用的函数，请求体是调用参数对象，内部合并该函数的 init_params 后交给执行器。函数不存在、已停用或不属于当前用户时直接拒绝。

java
/**
 * 执行自己保存且启用的函数，请求体是调用参数，内部会合并函数自己的初始化参数。
 *
 * <p>同时作为 Java 侧工作流函数节点的共享入口。
 */
public Object execute(Long user, Long id, JSONObject arguments) {
  Row row = Db.findFirst("select * from moss_kb_function_lib where id=? and user_id=? and deleted=false", id, user);
  if (row == null || !Boolean.TRUE.equals(row.getBoolean("is_active"))) {
    throw new IllegalArgumentException("函数不存在、已停用或无权执行");
  }
  JSONObject params = parseObject(row.getObject("init_params"));
  if (arguments != null) {
    params.putAll(arguments);
  }
  return Aop.get(IsolatedPythonExecutor.class).execute(row.getStr("code"), params, null, false);
}

请求体就是调用参数本身，没有外层包装：

json
{ "a": 2, "b": 40 }

返回 {"code":200,"data":42}。

调试与执行的区别 ​

两条路径共用同一个执行器，但入口参数不同，出错时的文案来源也不同：

调试接口执行接口
代码来源请求体里的 code库里保存的 code
必填校验Java 侧校验，缺失直接拒绝不校验，缺参数由 Python 抛 TypeError
初始化参数请求体的 init_params库里保存的 init_params
启用状态不要求必须启用
权限只要求登录只允许函数归属用户
入口函数请求体的 entrypoint，缺省取最后一个顶层函数始终取最后一个顶层函数

调试路径的必填校验更严格，是为了让编辑者在界面上立刻看到"缺少函数参数：a"；执行路径面向已经配好的函数，直接把 Python 的原生异常信息透出来更有助于排查（实测缺 b 时返回 add() missing 1 required positional argument: 'b'）。

Java 侧调用 ​

保存的函数也可以被后续工作流节点复用：共享入口是 PythonFunctionService.execute，由节点传入应用侧参数。节点实现里按 id 取函数、把上游节点的输出组装成 arguments 即可，不需要再走 HTTP：

java
import com.alibaba.fastjson2.JSONObject;
import nexus.io.jfinal.aop.Aop;
import nexus.io.mosskb.service.kb.PythonFunctionService;

/** 把上游节点的输出当作调用参数，直接调函数。 */
JSONObject arguments = new JSONObject();
arguments.put("query", upstreamNode.getStr("query"));
Object result = Aop.get(PythonFunctionService.class).execute(userId, functionId, arguments);

这只是一个可复用的执行入口，不代表任意原版工作流节点都已经兼容；已经保存的函数需要先启用（is_active=true），否则会直接拒绝。

这个接口目前只面向 Java 侧调用方，前端界面没有对应入口（编辑器走的是调试与语法检查两条路径）。

五、内置函数模板 ​

内置模板是 function_type=INTERNAL 的公开只读函数，界面上的"内置函数"页签读的就是它们。模板本身不允许改动，界面上的"添加"会调用 POST /api/function_lib/{id}/add_internal_fun，把它复制成自己的私有函数，再按需改代码和参数：

内置函数：博查搜索、Google Search、LangSearch、MySQL 与 PostgreSQL 查询

java
/**
 * 内置函数模板复制一份给自己的函数。
 *
 * <p>复制出来的函数只有名字是新的，代码和参数沿用模板，模板 id 记下来后界面会把它当成模板来源。
 */
public ResultVo addInternal(Long user, Long templateId, String name) {
  String trimmed = name == null ? null : name.trim();
  if (trimmed == null || trimmed.isBlank() || trimmed.length() > MAX_NAME_LENGTH) {
    return ResultVo.fail("函数名称格式无效");
  }
  Row source = Db.findFirst("select * from moss_kb_function_lib where id=? and deleted=false", templateId);
  if (source == null || !"INTERNAL".equals(source.getStr("function_type"))) {
    return ResultVo.fail("函数模板不存在");
  }
  long id = SnowflakeIdUtils.id();
  Db.update("""
      insert into moss_kb_function_lib(id,user_id,name,"desc",code,input_field_list,init_field_list,init_params,
        permission_type,is_active,icon,function_type,template_id)
      values(?,?,?,?,?,?::jsonb,?::jsonb,'{}'::jsonb,'PRIVATE',false,?,'PUBLIC',?)
      """, id, user, trimmed, source.getStr("desc"), source.getStr("code"),
      Objects.toString(source.getObject("input_field_list"), "[]"),
      Objects.toString(source.getObject("init_field_list"), "[]"), source.getStr("icon"), templateId);
  return get(user, id);
}
模板初始化参数作用
博查搜索apikey调用博查搜索接口，返回网页结果
Google Searchapikey、cx调用 Google 自定义搜索
LangSearchapikey调用 LangSearch 网页搜索
MySQL 查询host、port、user、password、database连接 MySQL 执行 SQL，结果转成 JSON
PostgreSQL 查询host、port、user、password、database连接 PostgreSQL 执行 SQL，结果转成 JSON

复制出来的函数默认是私有、停用的。停用状态下界面会提示先补全初始化参数，填完再启用，避免把没配好密钥的函数暴露给其他用户。

模板里的调用参数沿用上游写法：source 是 reference，表示由上游节点传入查询语句或 SQL，调用方不用手填。

内置模板需要 requests、pymysql、psycopg2 之类的第三方包，是否可用取决于执行镜像；默认镜像只有 Python 标准环境，需要这些模板时要按隔离 Python 执行环境配置准备一个预装依赖的镜像。

六、导出与导入 ​

导出走 GET /api/function_lib/{id}/export，下载一个 .fx 文件，文件名取自函数名。文件里只带函数本身，不带归属、启用状态和图标：

json
{
  "version": "v1",
  "name": "add",
  "desc": "两数相加",
  "code": "def add(a, b):\n    return a + b",
  "input_field_list": [{ "name": "a", "type": "int", "is_required": true }],
  "init_field_list": []
}

导入走 POST /api/function_lib/import，multipart 的 file 字段带 .fx 文件。导入结果是自己的私有函数，默认停用：

java
/** 导入 .fx 文件，导入结果是自己的私有函数，默认停用。 */
public ResultVo importFunction(Long user, UploadFile file) {
  if (file == null || file.getData() == null || file.getData().length == 0) {
    return ResultVo.fail("请选择要导入的文件");
  }
  JSONObject payload;
  try {
    payload = JSON.parseObject(new String(file.getData(), java.nio.charset.StandardCharsets.UTF_8));
  } catch (RuntimeException e) {
    return ResultVo.fail("不支持的文件格式");
  }
  if (payload == null || !EXPORT_VERSION.equals(payload.getString("version"))) {
    return ResultVo.fail("不支持的文件格式");
  }
  JSONObject input = new JSONObject();
  input.put("name", payload.getString("name"));
  input.put("desc", payload.getOrDefault("desc", ""));
  input.put("code", payload.getString("code"));
  input.put("input_field_list", payload.getOrDefault("input_field_list", new JSONArray()));
  input.put("init_field_list", payload.getOrDefault("init_field_list", new JSONArray()));
  input.put("permission_type", "PRIVATE");
  input.put("is_active", false);
  return save(user, null, input);
}

导入时会先校验 version 和必需字段，版本不认识或内容不是合法 JSON 时返回"不支持的文件格式"，不会写入半条记录。

七、图标 ​

PUT /api/function_lib/{id}/edit_icon 接收 multipart 的 file 字段，图片落到静态资源目录，库里只存访问路径：

java
/**
 * 保存上传的图标并返回可访问路径。
 *
 * @return 形如 {@code /api/function_lib/icon/<文件名>} 的路径
 */
public String save(UploadFile file) {
  if (file == null || file.getData() == null || file.getData().length == 0) {
    throw new IllegalArgumentException("请选择要上传的图片");
  }
  if (file.getData().length > MAX_ICON_BYTES) {
    throw new IllegalArgumentException("图标不能超过 10 MB");
  }
  String suffix = suffix(file.getName());
  if (!ALLOWED_SUFFIX.contains(suffix)) {
    throw new IllegalArgumentException("图标只支持 png、jpg、gif、webp 格式");
  }
  String name = UUID.randomUUID().toString().replace("-", "") + "." + suffix;
  try {
    Path directory = Paths.get(STATIC_LOCATION, ICON_DIR);
    Files.createDirectories(directory);
    Files.write(directory.resolve(name), file.getData());
  } catch (IOException e) {
    throw new IllegalStateException("图标保存失败：" + e.getMessage(), e);
  }
  return "/api/function_lib/icon/" + name;
}

读取图标走 GET /api/function_lib/icon/{name}，不要求登录：图标要出现在函数列表、工作流节点和第三方嵌入页里，登录态不能成为渲染前提。文件名是随机串，读取前先按规则校验，目录穿越和任意文件读取都会被挡掉：

java
/** 文件名规则：随机十六进制串加白名单后缀，读取时用它挡住目录穿越。 */
private static final String FILE_NAME = "[0-9a-f]{32}\\.(png|jpg|jpeg|gif|webp|bmp)";

/**
 * 读取图标内容。
 *
 * @return 文件不存在或名称不合法时返回 null
 */
public byte[] read(String name) {
  if (name == null || !name.matches(FILE_NAME)) {
    return null;
  }
  Path path = Paths.get(STATIC_LOCATION, ICON_DIR, name);
  try {
    return Files.exists(path) ? Files.readAllBytes(path) : null;
  } catch (IOException e) {
    return null;
  }
}

静态资源目录由 server.resources.static-locations 指定，图标存在它的 ui/fx/upload 子目录下。内置模板的图标是前端自带的 /ui/fx/<模板名>/icon.png，两者都按普通图片路径使用，不需要额外接口。

八、返回与错误 ​

调试接口返回函数返回值本身，执行单元内部的异常会作为失败信息返回，便于前端直接展示：

情况返回
正常返回{"code":200,"data":<返回值>}
函数内异常division by zero 之类的原始信息
缺少必填参数缺少函数参数：a
没有顶层函数代码需要至少一个顶层函数
入口函数不存在入口函数不存在
返回值超过 256 KiB函数返回结果超过 256 KiB
代码超过 64 KiBPython 代码不能为空且不能超过 64 KiB
语法检查命中错误行列诊断列表（不是失败响应）
情况返回
函数不存在或无权访问函数不存在或无权访问
修改别人的函数函数不存在或无权修改
执行停用或不存在的函数函数不存在、已停用或无权执行
名称或代码格式无效函数名称不能为空且不能超过 64 个字符 / 函数代码不能为空
参数类型或来源不支持参数类型只支持 string、int、float、dict、array / 参数来源只支持 custom、reference
权限类型不支持无效的函数权限类型
模板不存在函数模板不存在
导入文件格式不对不支持的文件格式
图标格式或大小不对图标只支持 png、jpg、gif、webp 格式 / 图标不能超过 10 MB

执行环境不可用时的错误文案见隔离 Python 执行器第五节。

九、前端适配 ​

函数库页面直接复用官方前端，只有两处按 Java 侧的数据结构做了调整：

  • 复制出来的函数可以正常编辑。 从内置模板复制来的函数带 template_id，官方前端会把它当成"模板转换来的、不可编辑"，自己的函数反而看不到图标和编辑入口。现在按 user_id 判断归属：自己的函数一律可编辑，别人的公开函数是只读，菜单里只留复制。
  • 开发态代理补上静态资源目录。 知识库原文件由后端静态服务按"目录名加相对路径"提供，开发态的 Vite 配置里补了 /pages 代理；生产部署时由反向代理转发同名路径。函数图标走的是 /api/function_lib/icon/，已经在 /api 代理覆盖范围内，不需要额外配置。

函数编辑抽屉：初始化参数、调用参数、代码与调试入口

十、验证 ​

powershell
mvn '-Dtest=PythonFunctionServiceTest' '-Dsurefire.failIfNoSpecifiedTests=false' '-Dmaven.javadoc.skip=true' '-Dgpg.skip=true' test

PythonFunctionServiceTest 覆盖参数类型转换、上游遗留的字段写法还原、初始化参数裁剪、保存前校验和密码打码共 5 项；IsolatedPythonExecutorTest 的 19 项覆盖执行器的隔离、限制与失败路径。

接口层已在运行实例上核对过：按上面的字段结构调试 2 + 40 得到 42；缺少必填参数返回"缺少函数参数"；函数内 1/0 返回 division by zero；返回 300000 字符的字符串被拒绝；pylint 对语法错误返回行列信息；无顶层函数被拒绝；执行结束后远程引擎上没有残留的执行容器。这些结果与隔离 Python 执行器记录的失败语义一致。

本轮另外核对了函数库自身的接口：

操作观察结果
GET /api/function_lib?function_type=INTERNAL返回 5 个内置模板，图标与初始化字段数量正确
GET /api/function_lib?function_type=PUBLIC只返回用户函数，且列表里没有 init_params
GET /api/function_lib/{id}详情带 init_params，密码类字段已打码
POST /api/function_lib/{id}/add_internal_fun复制出私有、停用的函数，template_id 指向模板
PUT /api/function_lib/{id}保存初始化参数后启用成功，再次提交打码值不会覆盖真实口令
POST /api/function_lib/pylint正确代码返回空诊断；漏写冒号返回 {"line":1,"column":13,"endLine":1,"endColumn":15,"message":"expected ':'","type":"error"}
POST /api/function_lib/{id}/execute{"a":2,"b":40} 返回 42；缺 b 时返回 add() missing 1 required positional argument: 'b'
GET /api/function_lib/{id}/export200，响应头为 attachment 且文件名按 UTF-8 百分号编码，正文为 v1 结构
POST /api/function_lib/import导入得到私有、停用的函数
PUT /api/function_lib/{id}/edit_icon上传 png 成功，返回 /api/function_lib/icon/<文件名>
GET /api/function_lib/icon/{name}不带令牌也能取到图片，类型为 image/png
界面核对"内置函数"页签显示 5 个模板，图标与"添加"按钮均正常；调试抽屉填 2 和 40 返回 42

相关章节 ​

MIT Licensed

Copyright © 2023-present litongjava