@w-xuefeng/cfib 0.0.1

package/.editorconfig

@@ -0,0 +1,13 @@
+root = true
+
+[*]
+charset = utf-8
+indent_size = 2
+indent_style = space
+insert_final_newline = true
+trim_trailing_whitespace = true
+end_of_line = lf
+
+
+[*.md]
+trim_trailing_whitespace = false

package/README.md

@@ -0,0 +1,102 @@
+# CFIB - Cloudflare Image Bed CLI & Agent Skills
+
+> 💡 **特别说明与致敬**
+> 
+> 本项目是对优秀的开源图床解决方案 **[CloudFlare-ImgBed](https://github.com/MarSeventh/CloudFlare-ImgBed)** 的生态扩展。十分感谢作者为大家提供如此出色的服务级支持！在此对原项目致以最诚挚的敬意。
+
+**CFIB** 是原项目 **[CloudFlare-ImgBed](https://github.com/MarSeventh/CloudFlare-ImgBed)** 的一个由 [Bun](https://bun.sh/) 驱动的高效命令行工具实现，并且提供了 AI Agent Skills 集合，用于管理和操作搭建在 Cloudflare 上的图床资源。
+
+通过此项目，你可以在终端中快速实现图片的上传、远程文件的删除、随机图片的获取，同时它还在 `skills/` 目录下提供了标准化的 Agent Skills 描述文件，方便外部 AI Agent 直接学习并接入这些能力。
+
+## 📦 安装与使用
+
+确保您的环境中已安装 [Bun](https://bun.sh/) 运行时。
+
+你可以通过以下两种方式之一来使用本项目：
+
+### 选项 A：全局安装 (推荐)
+
+一键全局安装，方便你在系统的任意位置直接使用 `cfib` 唤起命令：
+
+```bash
+bun install @w-xuefeng/cfib -g
+```
+
+安装成功后即可通过 `cfib -h` 查看帮助菜单。
+
+### 选项 B：免安装立即调用 (bunx)
+
+如果你不想进行全局安装，也可以利用 `bunx` 直接动态执行：
+
+```bash
+bunx @w-xuefeng/cfib -h
+```
+
+### 3. 环境配置
+
+所有底层服务调用均需绑定目标图床地址和对应的凭证密钥。你可以通过创建 `.env` 文件或在每次使用命令时直接通过长参数（配合环境变量）覆盖。
+
+**支持的全局参数（同时支持对应的环境变量）：**
+- `--origin` | `IB_ORIGIN` **(必配)**：图床服务的根 URL。
+- `--upload-auth-code` | `IB_UPLOAD_AUTH_CODE` **(上传/删除 必配)**：访问及调用特权的身份验证 Cookie / Header 码。
+- `--upload-token` | `IB_UPLOAD_TOKEN`：上传文件专用的 Token。
+- `--delete-token` | `IB_DELETE_TOKEN`：删除远端资源的 Token。
+- `--trace`：自定义日志与跨服务追踪的 `Trace-Id`。
+- `--lang`：请求支持的 `Accept-Language`。
+- `--log` / `--runtime-path` / `--log-root`：本地日志存储的路径设定。
+
+## 🛠 功能介绍
+
+获取详细介绍，通过执行：
+```bash
+cfib -h
+```
+
+### 1. 图片上传 (`upload`)
+
+将本地文件流式上传至服务并直接从云端返回可用地址。支持定义高级上传设置如服务器压缩状态、存储频道（例如 telegram, S3 等）。
+
+**用法：**
+```bash
+cfib upload <file> [options]
+```
+**示例：**
+```bash
+cfib upload ./my-picture.png --origin "https://example.com" --upload-auth-code "xxxxxxxx"
+```
+
+### 2. 资源删除 (`remove`)
+
+移除图床中已保存的文件，或者配合 `--folder` 直接移除指定的文件夹。
+
+**用法：**
+```bash
+cfib remove <path> [options]
+```
+**示例：**
+```bash
+cfib remove "images/delete_this.png" --origin "https://example.com" --upload-auth-code "xxxxxxxx"
+```
+
+### 3. 获取随机图 (`random`)
+
+自图床中抽取一张随机媒体。既可以返回其对应的元数据（JSON），也可以通过 `--type img` 开启流响应将二进制内容直接落盘成你指定的本地实体图片：
+
+**用法：**
+```bash
+cfib random [dest] [options]
+```
+**示例（直接下载）：**
+```bash
+cfib random output.jpg --type img --origin "https://example.com"
+```
+
+## 🤖 关于 AI Agent Skills
+
+在项目的 `skills/` 文件夹下包含了可以直接被 AI Agent（例如 Claude, AutoGPT 工具链）解析吸收的能力配置清单（`SKILL.md`）。
+
+这些说明文档内置了完整的调用说明，AI 助手在读取这些配置后便能安全、无障碍地为你执行上述所列的图床业务。
+
+- `skills/upload/SKILL.md`
+- `skills/remove/SKILL.md`
+- `skills/random/SKILL.md`

package/bun.lock

@@ -0,0 +1,40 @@
+{
+  "lockfileVersion": 1,
+  "configVersion": 1,
+  "workspaces": {
+    "": {
+      "name": "cloudflare-image-bed-skills",
+      "dependencies": {
+        "@w-xuefeng/bkit": "^0.0.5",
+      },
+      "devDependencies": {
+        "@types/bun": "latest",
+        "local-diamond": "^0.0.3",
+      },
+      "peerDependencies": {
+        "typescript": "^5",
+      },
+    },
+  },
+  "packages": {
+    "@types/bun": ["@types/bun@1.3.11", "", { "dependencies": { "bun-types": "1.3.11" } }, "sha512-5vPne5QvtpjGpsGYXiFyycfpDF2ECyPcTSsFBMa0fraoxiQyMJ3SmuQIGhzPg2WJuWxVBoxWJ2kClYTcw/4fAg=="],
+
+    "@types/node": ["@types/node@25.5.0", "", { "dependencies": { "undici-types": "~7.18.0" } }, "sha512-jp2P3tQMSxWugkCUKLRPVUpGaL5MVFwF8RDuSRztfwgN1wmqJeMSbKlnEtQqU8UrhTmzEmZdu2I6v2dpp7XIxw=="],
+
+    "@w-xuefeng/bkit": ["@w-xuefeng/bkit@0.0.5", "", { "dependencies": { "js-base64": "^3.7.8" }, "peerDependencies": { "typescript": "^5" } }, "sha512-r34CUMKuCHMeSqVVZWN0lKBeuAGXvftPk3JMfqtBPgumNkXYXx50xdNhE9JpcF5FXcLMXi1hUEUlBOgIxuml3A=="],
+
+    "bun-types": ["bun-types@1.3.11", "", { "dependencies": { "@types/node": "*" } }, "sha512-1KGPpoxQWl9f6wcZh57LvrPIInQMn2TQ7jsgxqpRzg+l0QPOFvJVH7HmvHo/AiPgwXy+/Thf6Ov3EdVn1vOabg=="],
+
+    "commander": ["commander@14.0.3", "", {}, "sha512-H+y0Jo/T1RZ9qPP4Eh1pkcQcLRglraJaSLoyOtHxu6AapkjWVCy2Sit1QQ4x3Dng8qDlSsZEet7g5Pq06MvTgw=="],
+
+    "hono": ["hono@4.12.9", "", {}, "sha512-wy3T8Zm2bsEvxKZM5w21VdHDDcwVS1yUFFY6i8UobSsKfFceT7TOwhbhfKsDyx7tYQlmRM5FLpIuYvNFyjctiA=="],
+
+    "js-base64": ["js-base64@3.7.8", "", {}, "sha512-hNngCeKxIUQiEUN3GPJOkz4wF/YvdUdbNL9hsBcMQTkKzboD7T/q3OYOuuPZLUE6dBxSGpwhk5mwuDud7JVAow=="],
+
+    "local-diamond": ["local-diamond@0.0.3", "", { "dependencies": { "commander": "^14.0.3", "hono": "^4.12.2" }, "peerDependencies": { "typescript": "^5" }, "bin": { "lod": "src/bin.ts" } }, "sha512-xqia8ihwisnyRyxkQHekaS8xVElqYn7Pxb87s7OVexxb3EzmfIHxWflEC1ZwP7bvYkP01H5q8N2318W0e1s5pA=="],
+
+    "typescript": ["typescript@5.9.3", "", { "bin": { "tsc": "bin/tsc", "tsserver": "bin/tsserver" } }, "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw=="],
+
+    "undici-types": ["undici-types@7.18.2", "", {}, "sha512-AsuCzffGHJybSaRrmr5eHr81mwJU3kjw6M+uprWvCXiNeN9SOGwQ3Jn8jb8m3Z6izVgknn1R0FTCEAP2QrLY/w=="],
+  }
+}

package/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "@w-xuefeng/cfib",
+  "description": "cloudflare-image-bed CLI tools and Agent Skills",
+  "version": "0.0.1",
+  "module": "src/index.ts",
+  "type": "module",
+  "bin": {
+    "cfib": "src/index.ts"
+  },
+  "scripts": {
+    "test": "bun test/index.test.ts"
+  },
+  "devDependencies": {
+    "@types/bun": "latest",
+    "local-diamond": "^0.0.3"
+  },
+  "peerDependencies": {
+    "typescript": "^5"
+  },
+  "dependencies": {
+    "@w-xuefeng/bkit": "^0.0.5"
+  }
+}

package/skills/random/SKILL.md

@@ -0,0 +1,48 @@
+---
+description: Get a random image from the Cloudflare Image Bed
+---
+
+# Random Image Skill
+
+This tool fetches a random file or image from the Cloudflare Image Bed server. It can either return the JSON metadata or download the actual file.
+
+## Usage
+
+Use the `run_command` tool to execute the cfib script. If the package is installed globally, you can use `cfib`. Otherwise, use `bunx cfib` or `npx cfib`:
+
+```bash
+cfib random [options] [local_save_path]
+# OR
+bunx @w-xuefeng/cfib random [options] [local_save_path]
+```
+
+### Options (All Optional):
+- `[local_save_path]`: If you specify `--type img`, you must provide a local filepath to save the binary image data (defaults to `random-image.jpg`).
+- `--type <path|img>`: (default: path) If set to `img`, returns and saves the file directly. If set to `path`, returns JSON info.
+- `--content <image|video>`: (default: image) The type of content to filter.
+- `--form <json|text>`: (default: json) The response data format.
+- `--dir <path>`: Filter random files only within a specific server directory.
+- `--orientation <landscape|portrait|square|auto>`: Filter by image orientation.
+
+### Global Required Options:
+- `--origin <url>`: The origin URL of the image bed server.
+
+### Global Optional Options:
+- `--trace <id>`: Set an explicit Trace-Id.
+- `--lang <language>`: Set an explicit Accept-Language.
+- `--log <true|false>`: Enable or disable logging.
+
+## Examples
+
+Get JSON metadata of a random image:
+```bash
+cfib random --origin "https://my-image-bed.com"
+```
+
+Download a random image directly to `test.jpg`:
+```bash
+cfib random test.jpg --type img --origin "https://my-image-bed.com"
+```
+
+## Success Criteria
+Normally outputs JSON metadata of the file. If `--type img` is used, the image is saved to the provided local path and outputs `Image saved to <path>`.

package/skills/remove/SKILL.md

@@ -0,0 +1,48 @@
+---
+description: Remove an image or folder from the Cloudflare Image Bed
+---
+
+# Remove Image or Folder Skill
+
+This tool allows you to delete an existing file or directory from the Cloudflare Image Bed server.
+
+## Usage
+
+Use the `run_command` tool to execute the cfib script. If the package is installed globally, you can use `cfib`. Otherwise, use `bunx cfib` or `npx cfib`:
+
+```bash
+cfib remove <remote_path> [options]
+# OR
+bunx @w-xuefeng/cfib remove <remote_path> [options]
+```
+
+### Required Arguments:
+- `<remote_path>`: The path on the server referencing the file or folder.
+
+### Global Required Options:
+- `--origin <url>`: The origin URL of the image bed server.
+- `--upload-auth-code <code>`: The auth code cookie value.
+
+### Global Optional Options:
+- `--delete-token <token>`: The authorization token required for deletion.
+- `--trace <id>`: Set an explicit Trace-Id.
+- `--lang <language>`: Set an explicit Accept-Language.
+- `--log <true|false>`: Enable or disable logging.
+
+### Options (All Optional):
+- `--folder`: Pass this flag if the `<remote_path>` is a folder and you want to delete the whole folder instead of a target file.
+
+## Example
+
+Delete a single file:
+```bash
+cfib remove "12345.png" --origin "https://my-image-bed.com" --upload-auth-code "my-auth-code" --delete-token "my-secret-token"
+```
+
+Delete a full folder:
+```bash
+cfib remove "my_folder_name" --folder --origin "https://my-image-bed.com" --upload-auth-code "my-auth-code"
+```
+
+## Success Criteria
+The command outputs a JSON response with `success: true` when the file or folder is successfully deleted.

package/skills/upload/SKILL.md

@@ -0,0 +1,45 @@
+---
+description: Upload a local image to the Cloudflare Image Bed
+---
+
+# Upload Image Skill
+
+This tool allows you to upload a local generic file or image to a Cloudflare Image Bed instance.
+
+## Usage
+
+Use the `run_command` tool to execute the cfib script. If the package is installed globally, you can use `cfib`. Otherwise, use `bunx cfib` or `npx cfib`:
+
+```bash
+cfib upload <local_filepath> [options]
+# OR
+bunx @w-xuefeng/cfib upload <local_filepath> [options]
+```
+
+### Required Arguments:
+- `<local_filepath>`: The absolute or relative path to the local file you wish to upload.
+
+### Global Required Options:
+- `--origin <url>`: The origin URL of the image bed server.
+- `--upload-auth-code <code>`: The auth code cookie value to bypass authentication.
+
+### Global Optional Environment & Tracing Options:
+- `--upload-token <token>`: The authorization token for uploading.
+- `--trace <id>`: Set an explicit Trace-Id.
+- `--lang <language>`: Set an explicit Accept-Language.
+- `--log <true|false>`: Enable or disable logging.
+
+### Upload Specific Options (All Optional):
+- `--server-compress <true|false>`: Whether the server should compress the image.
+- `--upload-channel <channel>`: The channel to use (telegram, cfr2, s3, discord, huggingface).
+- `--upload-folder <folder>`: A specific folder on the server to upload the file to.
+- `--auth-code <code>`: Specific authCode for upload.
+
+## Example
+
+```bash
+cfib upload /path/to/my/image.png --origin "https://my-image-bed.com" --upload-auth-code "my-auth-code" --upload-token "my-token"
+```
+
+## Success Criteria
+The command outputs a JSON response. A successful upload will contain a `success: true` and the `data.src` / `data.url` pointing to the uploaded file.

package/src/image-bed.ts

@@ -0,0 +1,194 @@
+import { pathJoin, R } from "@w-xuefeng/bkit";
+import { type Context, filterEmptyField, logger } from "./utils";
+
+export interface IBUploadOptions {
+  authCode?: string;
+  serverCompress?: "true" | "false";
+  uploadChannel?: "telegram" | "cfr2" | "s3" | "discord" | "huggingface";
+  channelName?: string;
+  autoRetry?: "true" | "false";
+  uploadNameType?: "default" | "index" | "origin" | "short";
+  returnFormat?: "default" | "full";
+  uploadFolder?: string;
+}
+
+export interface IBRandomOptions {
+  /**
+   * @default "image"
+   * 文件类型过滤，可选值有 [image, video]，多个使用 , 分隔
+   */
+  content?: "image" | "vidoe" | "image, video";
+  /**
+   * @default "path"
+   * 返回内容类型，设为 img 时直接返回图片（此时 form 不生效），设为 url 时返回完整 url 链接
+   */
+  type?: "path" | "img";
+  /**
+   * @default "json"
+   * 响应格式，设为 text 时直接返回文本
+   */
+  form?: "json" | "text";
+  /**
+   * 指定目录，使用相对路径，例如 img/test 会返回该目录以及所有子目录下的文件
+   */
+  dir?: string;
+  /**
+   * 图片方向筛选，可选值：landscape（横图）、portrait（竖图）、square（方图）、auto（自适应设备方向）
+   */
+  orientation?: "landscape" | "portrait" | "square" | "auto";
+}
+
+type IBUploadResponse = { src: string }[];
+
+interface IBDeleteSingleFileResponse {
+  success: true;
+  fileId: string;
+}
+
+interface IBDeleteFolderResponse {
+  success: true;
+  deleted: string[];
+  failed: string[];
+}
+
+interface IBDeleteFolderErrorResponse {
+  success: false;
+  error: string;
+}
+
+type IBDeleteResponse =
+  | IBDeleteSingleFileResponse
+  | IBDeleteFolderResponse
+  | IBDeleteFolderErrorResponse;
+
+export function upload(c: Context, file: File, options?: IBUploadOptions) {
+  const traceId = c.headers.get("Trace-Id");
+  const formData = new FormData();
+  formData.append("file", file);
+  const searchParams = new URLSearchParams(filterEmptyField({
+    uploadChannel: "telegram",
+    serverCompress: "true",
+    uploadNameType: "default",
+    returnFormat: "default",
+    autoRetry: "false",
+    ...options,
+  }));
+  const url = `${Bun.env.IB_ORIGIN}/upload?${searchParams.toString()}`;
+  logger.info(
+    `[trace-id: ${traceId}][image-bed upload params]: POST ${url} formData::[file:${file.name} ${file.size} ${file.type}]`,
+  );
+  return fetch(
+    url,
+    {
+      method: "POST",
+      body: formData,
+      headers: {
+        cookie: `authCode=${String(Bun.env.IB_UPLOAD_AUTH_CODE)}`,
+        authCode: String(Bun.env.IB_UPLOAD_AUTH_CODE),
+        referer: String(Bun.env.IB_ORIGIN),
+        Authorization: `Bearer ${Bun.env.IB_UPLOAD_TOKEN}`,
+      },
+    },
+  ).then((rs) => rs.json()).then((rs) => {
+    logger.info(
+      `[trace-id: ${traceId}][image-bed upload result]: ${JSON.stringify(rs)}`,
+    );
+    if (
+      !rs || !(rs as IBUploadResponse).length ||
+      !(rs as IBUploadResponse)[0]?.src
+    ) {
+      return R.unifail("FILE_UPLOAD_FAIL", rs, c.headers);
+    }
+    return R.unisuccess({
+      src: (rs as IBUploadResponse)[0]!.src,
+      url: pathJoin(
+        String(Bun.env.IB_ORIGIN),
+        (rs as IBUploadResponse)[0]!.src,
+      ),
+    }, c.headers);
+  }, (error) => {
+    logger.error(
+      `[trace-id: ${traceId}][image-bed upload error]: ${
+        JSON.stringify(error)
+      }`,
+    );
+    return R.unifail("SERVER_ERROR", error, c.headers);
+  });
+}
+
+export function remove(c: Context, path: string, folder: boolean = false) {
+  const traceId = c.headers?.get("Trace-Id");
+  if (path.startsWith(`${Bun.env.IB_ORIGIN}/`)) {
+    path = path.replace(`${Bun.env.IB_ORIGIN}/`, "");
+  }
+  if (path.startsWith("file/")) {
+    path = path.replace("file/", "");
+  }
+  if (path.startsWith("/file/")) {
+    path = path.replace("/file/", "");
+  }
+  return fetch(
+    `${Bun.env.IB_ORIGIN}/api/manage/delete/${path}${
+      folder ? "?folder=true" : ""
+    }`,
+    {
+      method: "DELETE",
+      headers: {
+        cookie: `authCode=${String(Bun.env.IB_UPLOAD_AUTH_CODE)}`,
+        authCode: String(Bun.env.IB_UPLOAD_AUTH_CODE),
+        referer: String(Bun.env.IB_ORIGIN),
+        Authorization: `Bearer ${Bun.env.IB_DELETE_TOKEN}`,
+      },
+    },
+  ).then((rs) => rs.json()).then((rs) => {
+    logger.info(
+      `[trace-id: ${traceId}][image-bed remove result]: ${JSON.stringify(rs)}`,
+    );
+    if (!rs || !(rs as IBDeleteResponse).success) {
+      return R.unifail("REQ_EXCEPTION", rs, c.headers);
+    }
+    return R.unisuccess(rs as IBDeleteResponse, c.headers);
+  }, (error) => {
+    logger.error(
+      `[trace-id: ${traceId}][image-bed remove error]: ${
+        JSON.stringify(error)
+      }`,
+    );
+    return R.unifail("SERVER_ERROR", error, c.headers);
+  });
+}
+
+export function random(c: Context, options?: IBRandomOptions) {
+  const traceId = c.headers.get("Trace-Id");
+  const searchParams = new URLSearchParams(filterEmptyField({
+    content: "image",
+    type: "path",
+    form: "json",
+    ...options,
+  }));
+  const url = `${Bun.env.IB_ORIGIN}/random?${searchParams.toString()}`;
+  logger.info(
+    `[trace-id: ${traceId}][image-bed random params]: GET ${url}`,
+  );
+  return fetch(url, {
+    method: "GET",
+    headers: {
+      referer: String(Bun.env.IB_ORIGIN),
+    },
+  }).then((rs) => {
+    if (options?.type === "img") {
+      return rs.blob();
+    }
+    if (options?.form === "text") {
+      return rs.text();
+    }
+    return rs.json();
+  }).catch((error) => {
+    logger.error(
+      `[trace-id: ${traceId}][image-bed random error]: ${
+        JSON.stringify(error)
+      }`,
+    );
+    return R.unifail("SERVER_ERROR", error, c.headers);
+  });
+}

package/src/index.ts

@@ -0,0 +1,216 @@
+#!/usr/bin/env bun
+
+import { parseArgs } from "node:util";
+import { Context, initEvn, logger } from "./utils";
+import {
+  type IBRandomOptions,
+  type IBUploadOptions,
+  random,
+  remove,
+  upload,
+} from "./image-bed";
+
+async function main() {
+  const args = process.argv.slice(2);
+  const { values, positionals } = parseArgs({
+    args,
+    options: {
+      origin: { type: "string" },
+      log: { type: "string" },
+      "runtime-path": { type: "string" },
+      "log-root": { type: "string" },
+      "upload-token": { type: "string" },
+      "delete-token": { type: "string" },
+      "upload-auth-code": { type: "string" },
+      trace: { type: "string" },
+      lang: { type: "string" },
+
+      // Upload Options
+      "auth-code": { type: "string" },
+      "server-compress": { type: "string" },
+      "upload-channel": { type: "string" },
+      "channel-name": { type: "string" },
+      "auto-retry": { type: "string" },
+      "upload-name-type": { type: "string" },
+      "return-format": { type: "string" },
+      "upload-folder": { type: "string" },
+
+      // Remove Options
+      folder: { type: "boolean" },
+
+      // Random Options
+      content: { type: "string" },
+      type: { type: "string" },
+      form: { type: "string" },
+      dir: { type: "string" },
+      orientation: { type: "string" },
+
+      help: { type: "boolean", short: "h" },
+    },
+    strict: false,
+    allowPositionals: true,
+  });
+
+  if (values.help || positionals.length === 0) {
+    console.log(`
+Usage: cfib <command> [args] [options...]
+
+Commands:
+  upload <file>     (Required <file>) Upload a local file
+  remove <path>     (Required <path>) Remove a remote file or folder
+  random [dest]     (Optional [dest]) Get a random image and save it to [dest] if --type is img
+
+Global Options:
+  --origin <url>             (Required) Set IB_ORIGIN
+  --log <true|false>         Set IB_LOG
+  --runtime-path <path>      Set IB_RUNTIME_PATH
+  --log-root <path>          Set IB_LOG_ROOT
+  --upload-token <token>     Set IB_UPLOAD_TOKEN
+  --delete-token <token>     Set IB_DELETE_TOKEN
+  --upload-auth-code <code>  (Required for upload/remove) Set IB_UPLOAD_AUTH_CODE
+  --trace <id>               Set Trace-Id
+  --lang <language>          Set Accept-Language
+
+Upload Options (All Optional):
+  --auth-code <code>                 Provide authCode for upload
+  --server-compress <true|false>     Whether to compress image on server
+  --upload-channel <channel>         Upload channel (telegram|cfr2|s3|discord|huggingface)
+  --channel-name <name>              Channel target name
+  --auto-retry <true|false>          Whether to auto-retry
+  --upload-name-type <type>          Name type (default|index|origin|short)
+  --return-format <format>           Return format (default|full)
+  --upload-folder <folder>           Target upload folder
+
+Remove Options (All Optional):
+  --folder                           Remove a folder instead of a single file
+
+Random Options (All Optional):
+  --content <image|video>            Filter content type
+  --type <path|img>                  Return type, use 'img' to return raw binary and save to local
+  --form <json|text>                 Response format
+  --dir <path>                       Filter by specific directory
+  --orientation <direction>          Orientation (landscape|portrait|square|auto)
+    `.trim());
+    process.exit(0);
+  }
+
+  // Initialize env
+  initEvn({
+    IB_ORIGIN: values.origin as string | undefined,
+    IB_LOG: values.log as "true" | "false" | undefined,
+    IB_RUNTIME_PATH: values["runtime-path"] as string | undefined,
+    IB_LOG_ROOT: values["log-root"] as string | undefined,
+    IB_UPLOAD_TOKEN: values["upload-token"] as string | undefined,
+    IB_DELETE_TOKEN: values["delete-token"] as string | undefined,
+    IB_UPLOAD_AUTH_CODE: values["upload-auth-code"] as string | undefined,
+  });
+
+  if (!Bun.env.IB_ORIGIN) {
+    console.error(
+      "Error: Missing required global configuration: --origin. Please provide it via CLI or environment variables.",
+    );
+    process.exit(1);
+  }
+
+  const command = positionals[0];
+  if (
+    (command === "upload" || command === "remove") &&
+    !Bun.env.IB_UPLOAD_AUTH_CODE
+  ) {
+    console.error(
+      `Error: Missing required configuration: --upload-auth-code for the '${command}' command.`,
+    );
+    process.exit(1);
+  }
+  const c = new Context(
+    values.trace as string | undefined,
+    values.lang as string | undefined,
+  );
+
+  try {
+    if (command === "upload") {
+      const filepath = positionals[1];
+      if (!filepath) {
+        console.error("Error: Please provide a filepath to upload.");
+        process.exit(1);
+      }
+      const bunFile = Bun.file(filepath);
+      if (!(await bunFile.exists())) {
+        console.error(`Error: File not found at ${filepath}`);
+        process.exit(1);
+      }
+
+      const options: IBUploadOptions = {
+        authCode: values["auth-code"] as string | undefined,
+        serverCompress:
+          values["server-compress"] as IBUploadOptions["serverCompress"],
+        uploadChannel:
+          values["upload-channel"] as IBUploadOptions["uploadChannel"],
+        channelName: values["channel-name"] as string | undefined,
+        autoRetry: values["auto-retry"] as IBUploadOptions["autoRetry"],
+        uploadNameType:
+          values["upload-name-type"] as IBUploadOptions["uploadNameType"],
+        returnFormat:
+          values["return-format"] as IBUploadOptions["returnFormat"],
+        uploadFolder: values["upload-folder"] as string | undefined,
+      };
+
+      const result = await upload(c, bunFile as unknown as File, options);
+      if (result.success === false) {
+        console.error(JSON.stringify(result, null, 2));
+        process.exit(1);
+      }
+      console.log(JSON.stringify(result, null, 2));
+    } else if (command === "remove") {
+      const pathToRemove = positionals[1];
+      if (!pathToRemove) {
+        console.error("Error: Please provide a path to remove.");
+        process.exit(1);
+      }
+
+      const isFolder = Boolean(values.folder);
+      const result = await remove(c, pathToRemove, isFolder);
+      if (result.success === false) {
+        console.error(JSON.stringify(result, null, 2));
+        process.exit(1);
+      }
+      console.log(JSON.stringify(result, null, 2));
+    } else if (command === "random") {
+      const options: IBRandomOptions = {
+        content: values.content as IBRandomOptions["content"],
+        type: values.type as IBRandomOptions["type"],
+        form: values.form as IBRandomOptions["form"],
+        dir: values.dir as string | undefined,
+        orientation: values.orientation as IBRandomOptions["orientation"],
+      };
+
+      const result = await random(c, options);
+      if (options.type === "img") {
+        const dest = positionals[1] || "random-image.jpg";
+        if (result instanceof Blob) {
+          await Bun.write(dest, result);
+          console.log(`Image saved to ${dest}`);
+        } else {
+          console.error("Error: Expected Blob, got", result);
+          process.exit(1);
+        }
+      } else if (options.form === "text") {
+        console.log(result);
+      } else {
+        if (result && (result as any).success === false) {
+          console.error(JSON.stringify(result, null, 2));
+          process.exit(1);
+        }
+        console.log(JSON.stringify(result, null, 2));
+      }
+    } else {
+      console.error(`Error: Unknown command "${command}"`);
+      process.exit(1);
+    }
+  } catch (err: any) {
+    console.error("Execution error:", err.message || err);
+    process.exit(1);
+  }
+}
+
+main();

package/src/utils.ts

@@ -0,0 +1,83 @@
+import { Logger, pathJoin } from "@w-xuefeng/bkit";
+
+interface IBEnv {
+  IB_ORIGIN: string;
+  IB_LOG: "true" | "false";
+  IB_RUNTIME_PATH: string;
+  IB_LOG_ROOT: string;
+  IB_UPLOAD_TOKEN: string;
+  IB_DELETE_TOKEN: string;
+  IB_UPLOAD_AUTH_CODE: string;
+}
+
+const IB_RUNTIME_PATH = Bun.env.IB_RUNTIME_PATH || "runtime";
+const IB_LOG_ROOT = Bun.env.IB_LOG_ROOT || "logs";
+
+const getLogConfig = () => {
+  return {
+    enabled: Bun.env.IB_LOG === "true",
+    type: "both" as const,
+    root: pathJoin(IB_RUNTIME_PATH, IB_LOG_ROOT),
+  };
+};
+
+export const logger = new Logger(getLogConfig());
+const initLogger = () => {
+  const loggerConfig = getLogConfig();
+  logger.enabled = loggerConfig.enabled;
+  logger.root = loggerConfig.root;
+};
+
+export function initEvn(env?: Partial<IBEnv>) {
+  Bun.env.IB_ORIGIN = Bun.env.IB_ORIGIN || env?.IB_ORIGIN;
+  Bun.env.IB_LOG = Bun.env.IB_LOG || env?.IB_LOG;
+  Bun.env.IB_RUNTIME_PATH = Bun.env.IB_RUNTIME_PATH || env?.IB_RUNTIME_PATH;
+  Bun.env.IB_LOG_ROOT = Bun.env.IB_LOG_ROOT || env?.IB_LOG_ROOT;
+  Bun.env.IB_UPLOAD_TOKEN = Bun.env.IB_UPLOAD_TOKEN || env?.IB_UPLOAD_TOKEN;
+  Bun.env.IB_DELETE_TOKEN = Bun.env.IB_DELETE_TOKEN || env?.IB_DELETE_TOKEN;
+  Bun.env.IB_UPLOAD_AUTH_CODE = Bun.env.IB_UPLOAD_AUTH_CODE ||
+    env?.IB_UPLOAD_AUTH_CODE;
+  initLogger();
+}
+
+export class Context {
+  headers: Headers;
+  constructor(traceId?: string, acceptLanguage = "en") {
+    this.headers = new Headers();
+    this.headers.set("Trace-Id", traceId || Bun.randomUUIDv7());
+    this.headers.set("Accept-Language", acceptLanguage);
+  }
+  setLanguage(lang: string) {
+    this.headers.set("Accept-Language", lang);
+    return this;
+  }
+  setTraceId(traceId?: string) {
+    this.headers.set("Trace-Id", traceId || Bun.randomUUIDv7());
+    return this;
+  }
+  setHeaders(headers: Headers) {
+    this.headers = headers;
+    return this;
+  }
+}
+
+export function filterEmptyField<T extends Record<string, any>>(
+  data?: Record<string, any>,
+  deep = false,
+  emptyArray = ["", void 0, null],
+) {
+  if (!data) {
+    return {} as T;
+  }
+  return Object.keys(data).reduce((res, key) => {
+    if (
+      data[key] && typeof data[key] === "object" && !Array.isArray(data[key]) &&
+      deep
+    ) {
+      res[key as keyof T] = filterEmptyField(data[key]);
+    } else if (!emptyArray.includes(data[key])) {
+      res[key as keyof T] = data[key];
+    }
+    return res;
+  }, {} as T);
+}

package/test/index.test.ts

@@ -0,0 +1,82 @@
+import { beforeAll, describe, expect, it } from "bun:test";
+import { random, remove, upload } from "../src/image-bed";
+import { Context, initEvn } from "../src/utils";
+
+/**
+ * 在执行本测试脚本之前，
+ * 请确保您本地安装了 local-diamond，并且使用下列命令配置好了环境变量
+ * lod set cfib/origin <origin>
+ * lod set cfib/upload-auth-code <upload-auth-code>
+ * lod set cfib/upload-token <upload-token>
+ * lod set cfib/delete-token <delete-token>
+ */
+
+function getLodConfig(key: string): string {
+  const proc = Bun.spawnSync(["bunx", "lod", "get", key]);
+  if (!proc.success) {
+    throw new Error(
+      `Failed to fetch ${key} from lod. Make sure local-diamond is configured properly.`,
+    );
+  }
+  return proc.stdout.toString().trim();
+}
+
+describe("Cloudflare Image Bed API Tests", () => {
+  let c: Context;
+  let testImagePath = "";
+
+  beforeAll(() => {
+    const origin = getLodConfig("cfib/origin");
+    const uploadAuthCode = getLodConfig("cfib/upload-auth-code");
+    const uploadToken = getLodConfig("cfib/upload-token");
+    const deleteToken = getLodConfig("cfib/delete-token");
+
+    initEvn({
+      IB_ORIGIN: origin,
+      IB_UPLOAD_AUTH_CODE: uploadAuthCode,
+      IB_UPLOAD_TOKEN: uploadToken,
+      IB_DELETE_TOKEN: deleteToken,
+      IB_LOG: "true",
+    });
+
+    c = new Context();
+  });
+
+  it("should upload a local image", async () => {
+    const file = Bun.file(`${import.meta.dir}/banner.png`);
+    expect(await file.exists()).toBe(true);
+    const buffer = await file.arrayBuffer();
+    const webFile = new File([buffer], "banner.png", { type: file.type });
+    const result = await upload(c, webFile, { uploadFolder: "wallpaper/test" });
+
+    if (!result.success) {
+      console.error(
+        "Upload failed with result:",
+        JSON.stringify(result, null, 2),
+      );
+    }
+
+    expect(result.success).toBe(true);
+    expect(result.data).toBeDefined();
+    expect(result.data?.src).toBeDefined();
+    expect(result.data?.url).toBeDefined();
+    expect(typeof result.data?.src).toBe("string");
+    expect(typeof result.data?.url).toBe("string");
+
+    testImagePath = result.data!.url;
+  });
+
+  it("should remove the uploaded image", async () => {
+    expect(testImagePath).not.toBe("");
+    const result = await remove(c, testImagePath, false);
+    expect(result.success).toBe(true);
+  });
+
+  it("should get a random image", async () => {
+    const result = await random(c, { type: "path", dir: "wallpaper" });
+    expect(result).toBeDefined();
+    if ((result as any).success !== undefined) {
+      expect((result as any).success).toBe(true);
+    }
+  });
+});

package/tsconfig.json

@@ -0,0 +1,24 @@
+{
+  "compilerOptions": {
+    "lib": [
+      "ESNext"
+    ],
+    "target": "ESNext",
+    "module": "Preserve",
+    "moduleDetection": "force",
+    "jsx": "react-jsx",
+    "allowJs": true,
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true,
+    "noEmit": true,
+    "strict": true,
+    "skipLibCheck": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedIndexedAccess": true,
+    "noImplicitOverride": true,
+    "noUnusedLocals": false,
+    "noUnusedParameters": false,
+    "noPropertyAccessFromIndexSignature": false
+  }
+}