进程与 Shell：

• Bun.spawn(cmd) / Bun.spawnSync(cmd) - 子进程生成
• Bun.$\command`` - 使用模板字面量进行跨平台 Shell 脚本编写
• 内置命令：ls, cd, rm, cat, echo, pwd, mkdir, touch, which, mv

数据与存储：

• bun:sqlite - 内置 SQLite3 驱动（比 better-sqlite3 快 3-6 倍）
• Bun.sql - 用于 PostgreSQL、MySQL、SQLite 的统一 SQL API
• Bun.S3Client / Bun.s3 - 原生 S3 兼容存储（比 AWS SDK 快 5 倍）
• Bun.redis - 内置 Redis 客户端

实用工具：

• Bun.password.hash() / Bun.password.verify() - Argon2 密码哈希
• Bun.hash(data) - 快速哈希（xxhash, murmur）
• Bun.Glob - 原生 glob 模式匹配
• Bun.semver - Semver 比较工具
• Bun.sleep(ms) / Bun.sleepSync(ms) - 休眠函数
• Bun.deepEquals(a, b) - 深度比较
• Bun.escapeHTML() - HTML 净化
• Bun.YAML.parse() / Bun.YAML.stringify() - 原生 YAML 支持
• HTMLRewriter - HTML 流式转换

高级功能：

• bun:ffi - 外部函数接口（比 Node.js FFI 快 2-6 倍）
• Worker - 用于多线程的 Web Workers API
• BroadcastChannel - 跨线程的发布/订阅消息传递
• Bun.Transpiler - JavaScript/TypeScript 转译 API
• Bun.build() - 支持编译的打包工具 API

2. 包管理器命令

核心命令：

bun install              # 安装所有依赖项
bun install --frozen-lockfile  # CI/CD 锁文件验证
bun add <pkg>            # 添加依赖项
bun add -d <pkg>         # 添加开发依赖项
bun remove <pkg>         # 移除依赖项
bun update               # 更新过时的包
bun ci                   # CI 优化的安装（--frozen-lockfile）
bunx <pkg>               # 无需安装即可执行包（比 npx 快 100 倍）

工作区支持：

{
  "workspaces": ["packages/*", "apps/*"],
  "dependencies": {
    "shared-pkg": "workspace:*"
  }
}

包管理：

bun pm trust <pkg>       # 允许生命周期脚本
bun pm untrusted         # 查看被阻止的脚本
bun why <pkg>            # 解释为何安装此包
bun outdated             # 显示过时的包
bun audit                # 安全检查漏洞
bun patch <pkg>          # 准备要打补丁的包
bun link                 # 链接本地包

锁文件： Bun 使用 bun.lock（基于文本的 JSONC 格式）- 人类可读，支持 git diff。自动从 package-lock.json、yarn.lock 或 pnpm-lock.yaml 迁移。

3. 测试运行器 (bun:test)

测试语法：

import { describe, test, expect, beforeAll, afterEach, mock, spyOn } from "bun:test";

describe("feature", () => {
  beforeAll(() => { /* setup */ });
  afterEach(() => { mock.restore(); });

  test("basic assertion", () => {
    expect(2 + 2).toBe(4);
  });

  test("async operation", async () => {
    const result = await fetchData();
    expect(result).toMatchObject({ status: "ok" });
  });

  test.each([[1, 2, 3], [2, 3, 5]])("adds %i + %i = %i", (a, b, expected) => {
    expect(a + b).toBe(expected);
  });
});

测试修饰符：

• test.skip() - 跳过测试
• test.only() - 仅运行此测试（配合 --only 标志）
• test.todo() - 标记为待办
• test.if(condition) / test.skipIf(condition) - 条件执行
• test.failing() - 预期会失败
• test.concurrent - 并发运行
• test.retry(n) - 重试失败的测试

关键匹配器：

• .toBe(), .toEqual(), .toStrictEqual() - 相等性
• .toContain(), .toHaveLength(), .toMatch() - 字符串/数组
• .toHaveProperty(), .toMatchObject() - 对象
• .toThrow(), .rejects.toThrow() - 错误
• .toMatchSnapshot(), .toMatchInlineSnapshot() - 快照
• .toHaveBeenCalled(), .toHaveBeenCalledWith() - 模拟

模拟：

import { mock, spyOn } from "bun:test";

const mockFn = mock(() => 42);
mockFn.mockImplementation(() => 100);
mockFn.mockReturnValue(200);

const spy = spyOn(object, "method");
spy.mockResolvedValue({ data: "test" });

// 模块模拟
mock.module("./api", () => ({
  fetchUser: mock(() => ({ id: 1, name: "Test" }))
}));

CLI 命令：

bun test                 # 运行所有测试
bun test --watch         # 监视模式
bun test --coverage      # 启用覆盖率
bun test -t "pattern"    # 按测试名称过滤
bun test --timeout=5000  # 设置超时
bun test --bail          # 首次失败时停止
bun test --update-snapshots  # 更新快照

4. 打包工具配置

JavaScript API：

const result = await Bun.build({
  entrypoints: ["./src/index.tsx"],
  outdir: "./dist",
  target: "browser",  // "browser" | "bun" | "node"
  format: "esm",      // "esm" | "cjs" | "iife"
  minify: true,
  sourcemap: "external",
  splitting: true,    // 代码分割
  external: ["react", "react-dom"],
  define: {
    "process.env.NODE_ENV": '"production"'
  },
  loader: {
    ".png": "dataurl",
    ".svg": "text"
  },
  plugins: [myPlugin],
  naming: {
    entry: "[dir]/[name].[ext]",
    chunk: "[name]-[hash].[ext]"
  }
});

if (!result.success) {
  console.error(result.logs);
}

CLI：

bun build ./src/index.tsx --outdir ./dist --minify --sourcemap=external
bun build ./src/index.ts --compile --outfile myapp  # 单文件可执行程序

插件系统：

const myPlugin: BunPlugin = {
  name: "yaml-loader",
  setup(build) {
    build.onLoad({ filter: /\.yaml$/ }, async (args) => {
      const text = await Bun.file(args.path).text();
      return {
        contents: `export default ${JSON.stringify(YAML.parse(text))}`,
        loader: "js"
      };
    });
  }
};

5. TypeScript 集成

Bun 原生执行 TypeScript，无需转译配置：

bun run index.ts      # 直接运行
bun run index.tsx     # 支持 JSX

推荐的 tsconfig.json：

{
  "compilerOptions": {
    "lib": ["ESNext"],
    "target": "ESNext",
    "module": "ESNext",
    "moduleDetection": "force",
    "moduleResolution": "bundler",
    "allowImportingTsExtensions": true,
    "verbatimModuleSyntax": true,
    "noEmit": true,
    "strict": true,
    "skipLibCheck": true,
    "types": ["bun-types"]
  }
}

类型检查（独立步骤）：

bunx tsc --noEmit

6. 配置 (bunfig.toml)

# 运行时
preload = ["./setup.ts"]
smol = true                    # 减少内存模式

# JSX
[jsx]
runtime = "automatic"
importSource = "react"

# 包安装
[install]
optional = false
lockfile.save = true

[install.scopes]
"@myorg" = { url = "https://npm.myorg.com", token = "$NPM_TOKEN" }

# 测试运行器
[test]
preload = ["./test-setup.ts"]
coverage = true
coverageThreshold = { lines = 0.8, functions = 0.8 }

7. CLI 标志参考

执行：

• --watch - 文件更改时自动重启
• --hot - 热模块替换
• --smol - 减少内存模式
• --inspect / --inspect-brk - 调试器

模块解析：

• --preload / -r - 预加载模块
• --install=auto|fallback|force - 自动安装行为

转译：

• --define / -d - 编译时常量
• --drop=console - 移除函数调用
• --loader - 自定义文件加载器

环境：

• --env-file - 加载特定的 .env 文件
• --cwd - 设置工作目录
• --bun / -b - 强制使用 Bun 运行时

Node.js 迁移指南

快速迁移步骤

1. 安装 Bun： curl -fsSL https://bun.sh/install | bash
2. 替换包管理器：

# 删除 node_modules 和锁文件

rm -rf node_modules package-lock.json yarn.lock pnpm-lock.yaml
bun install

3. 更新 package.json 中的脚本：

{
  "scripts": {
    "dev": "bun run --watch src/index.ts",
    "test": "bun test",
    "build": "bun build src/index.ts --outdir dist"
  }
}

4. 更新 TypeScript 类型：

bun add -d @types/bun
# 或在 tsconfig.json 中："types": ["bun-types"]

API 兼容性

完全兼容：

• node:assert, node:buffer, node:events, node:path, node:url
• node:fs (92%), node:http, node:https, node:stream, node:zlib
• node:crypto, node:net, node:dns, node:os

部分兼容：

• node:child_process - 缺少 proc.gid, proc.uid；IPC 仅限于 JSON
• node:cluster - 仅限 Linux 的 SO_REUSEPORT 用于负载均衡
• node:http2 - 95% 兼容；缺少 pushStream
• node:worker_threads - 缺少 stdin, stdout, stderr 选项
• node:async_hooks - AsyncLocalStorage 有效；缺少 v8 promise hooks

未实现：

• node:inspector, node:repl, node:trace_events

常见迁移陷阱

1. 原生模块： 使用 node-gyp 的包（如 bcrypt, sharp）可能失败
   • 解决方案：使用纯 JS 替代品（用 bcryptjs 代替 bcrypt）
2. 生命周期脚本： Bun 默认阻止 postinstall（出于安全考虑）
   • 解决方案：bun pm trust <package> 或添加到 trustedDependencies
3. 模块系统： 一些依赖 Node.js 内部机制的包可能失败
   • Module._nodeModulePaths 在 Bun 中不存在
4. 文件系统差异： 大量并发文件读取可能导致内存问题
   • 解决方案：使用 graceful-fs 包装器
5. TypeScript 入口点： 为 Bun 更新 "main" 字段：

{

  "main": "src/index.ts"  // 而不是 "build/index.js"
}

渐进式迁移策略

阶段 1： 仅使用包管理器（bun install） 阶段 2： 开发工具链（bun run, bun test） 阶段 3： 选择性运行时迁移（影子部署） 阶段 4： 完全生产迁移

最佳实践

性能优化

// 使用 Bun 的原生 API 进行 I/O 操作
const file = Bun.file("large.txt");  // 零拷贝
const content = await file.text();
await Bun.write("output.txt", processedData);

// 使用 Promise.all 进行并发操作
const [users, posts] = await Promise.all([
  db.query("SELECT * FROM users"),
  db.query("SELECT * FROM posts")
]);

// 使用 Bun.serve() 静态路由
Bun.serve({
  static: {
    "/": homepage,
    "/about": aboutPage
  },
  fetch(req) { /* dynamic routes */ }
});

// 使用 bun:sqlite 处理本地数据
import { Database } from "bun:sqlite";
const db = new Database(":memory:");
const stmt = db.prepare("SELECT * FROM users WHERE id = ?");

错误处理

// HTTP 服务器错误处理
Bun.serve({
  fetch(req) {
    try {
      return handleRequest(req);
    } catch (error) {
      console.error(error);
      return new Response("Internal Error", { status: 500 });
    }
  },
  error(error) {
    return new Response(`Error: ${error.message}`, { status: 500 });
  }
});

// 进程级错误处理
process.on("uncaughtException", (error) => {
  console.error("Uncaught:", error);
  process.exit(1);
});

安全最佳实践

1. 生命周期脚本： 保持 trustedDependencies 最小化
2. 环境变量： 使用 .env.local 存储密钥（不提交到版本控制）
3. 输入验证： 净化所有用户输入
4. 依赖项： 定期运行 bun audit
5. 生产环境： 使用 --production 标志跳过 devDependencies

项目结构

my-bun-project/
├── src/
│   ├── index.ts        # 入口点
│   ├── server.ts       # HTTP 服务器
│   └── lib/            # 工具函数
├── test/
│   └── *.test.ts       # 测试文件
├── bunfig.toml         # Bun 配置
├── tsconfig.json       # TypeScript 配置
├── package.json
└── .env.local          # 本地密钥（被 git 忽略）

调试

Web 调试器：

bun --inspect server.ts         # 启动调试器
bun --inspect-brk server.ts     # 在第一行中断
bun --inspect-wait server.ts    # 等待连接

打开 https://debug.bun.sh 或使用 VSCode Bun 扩展。

详细 Fetch 日志记录：

BUN_CONFIG_VERBOSE_FETCH=curl bun run server.ts

示例

带 WebSocket 的 HTTP 服务器

Bun.serve({
  port: 3000,
  fetch(req, server) {
    if (server.upgrade(req)) return;
    return new Response("Hello Bun!");
  },
  websocket: {
    open(ws) { console.log("Connected"); },
    message(ws, message) { ws.send(`Echo: ${message}`); },
    close(ws) { console.log("Disconnected"); }
  }
});

文件服务器

Bun.serve({
  async fetch(req) {
    const path = new URL(req.url).pathname;
    const file = Bun.file(`./public${path}`);
    if (await file.exists()) {
      return new Response(file);
    }
    return new Response("Not Found", { status: 404 });
  }
});

使用 SQLite 的数据库

import { Database } from "bun:sqlite";

const db = new Database("app.db");
db.run(`CREATE TABLE IF NOT EXISTS users (
  id INTEGER PRIMARY KEY AUTOINCREMENT,
  name TEXT NOT NULL,
  email TEXT UNIQUE
)`);

const insert = db.prepare("INSERT INTO users (name, email) VALUES (?, ?)");
const getAll = db.prepare("SELECT * FROM users");

insert.run("Alice", "alice@example.com");
const users = getAll.all();

此技能何时激活

此技能在以下情况自动激活：

• 在 Bun 项目中处理 .ts、.tsx、.js、.jsx 文件时
• 创建或修改 bunfig.toml 或 bun.lock 时
• 使用 bun:test、bun:sqlite、bun:ffi 导入时
• 讨论 Bun API（Bun.serve, Bun.file, Bun.build）时
• 从 Node.js 迁移到 Bun 时
• 编写或调试 Bun 测试时
• 配置 Bun 打包工具时

每周安装次数

103

仓库

lammesen/skills

首次出现

2026 年 1 月 23 日

安全审计

Gen Agent Trust HubFailSocketPassSnykWarn

安装于

opencode84

codex76

gemini-cli75

claude-code68

github-copilot65

antigravity55

Process & Shell:

• Bun.spawn(cmd) / Bun.spawnSync(cmd) - Child process spawning
• Bun.$\command`` - Cross-platform shell scripting with template literals
• Built-in commands: ls, cd, rm, cat, echo, pwd, mkdir, touch, which, mv

Data & Storage:

• bun:sqlite - Built-in SQLite3 driver (3-6x faster than better-sqlite3)
• Bun.sql - Unified SQL API for PostgreSQL, MySQL, SQLite
• Bun.S3Client / Bun.s3 - Native S3-compatible storage (5x faster than AWS SDK)
• Bun.redis - Built-in Redis client

Utilities:

• Bun.password.hash() / Bun.password.verify() - Argon2 password hashing
• Bun.hash(data) - Fast hashing (xxhash, murmur)
• Bun.Glob - Native glob pattern matching
• Bun.semver - Semver comparison utilities
• Bun.sleep(ms) / Bun.sleepSync(ms) - Sleep functions
• Bun.deepEquals(a, b) - Deep comparison
• Bun.escapeHTML() - HTML sanitization
• Bun.YAML.parse() / Bun.YAML.stringify() - Native YAML support
• HTMLRewriter - HTML streaming transformations

Advanced Features:

• bun:ffi - Foreign Function Interface (2-6x faster than Node.js FFI)
• Worker - Web Workers API for multi-threading
• BroadcastChannel - Pub/sub messaging across threads
• Bun.Transpiler - JavaScript/TypeScript transpilation API
• Bun.build() - Bundler API with compile support

2. Package Manager Commands

Core Commands:

bun install              # Install all dependencies
bun install --frozen-lockfile  # CI/CD lockfile validation
bun add <pkg>            # Add dependency
bun add -d <pkg>         # Add devDependency
bun remove <pkg>         # Remove dependency
bun update               # Update outdated packages
bun ci                   # CI-optimized install (--frozen-lockfile)
bunx <pkg>               # Execute package without installing (100x faster than npx)

Workspace Support:

{
  "workspaces": ["packages/*", "apps/*"],
  "dependencies": {
    "shared-pkg": "workspace:*"
  }
}

Package Management:

bun pm trust <pkg>       # Allow lifecycle scripts
bun pm untrusted         # View blocked scripts
bun why <pkg>            # Explain why package installed
bun outdated             # Show outdated packages
bun audit                # Security vulnerability check
bun patch <pkg>          # Prepare package for patching
bun link                 # Link local packages

Lockfile: Bun uses bun.lock (text-based JSONC format) - human-readable, git-diffable. Automatically migrates from package-lock.json, yarn.lock, or pnpm-lock.yaml.

3. Test Runner (bun:test)

Test Syntax:

import { describe, test, expect, beforeAll, afterEach, mock, spyOn } from "bun:test";

describe("feature", () => {
  beforeAll(() => { /* setup */ });
  afterEach(() => { mock.restore(); });

  test("basic assertion", () => {
    expect(2 + 2).toBe(4);
  });

  test("async operation", async () => {
    const result = await fetchData();
    expect(result).toMatchObject({ status: "ok" });
  });

  test.each([[1, 2, 3], [2, 3, 5]])("adds %i + %i = %i", (a, b, expected) => {
    expect(a + b).toBe(expected);
  });
});

Test Modifiers:

• test.skip() - Skip test
• test.only() - Run only this test (with --only flag)
• test.todo() - Mark as todo
• test.if(condition) / test.skipIf(condition) - Conditional execution
• test.failing() - Expected to fail
• test.concurrent - Run concurrently
• test.retry(n) - Retry failed tests

Key Matchers:

• .toBe(), .toEqual(), .toStrictEqual() - Equality
• .toContain(), .toHaveLength(), .toMatch() - String/Array
• .toHaveProperty(), .toMatchObject() - Objects
• .toThrow(), .rejects.toThrow() - Errors
• .toMatchSnapshot(), .toMatchInlineSnapshot() - Snapshots
• .toHaveBeenCalled(), .toHaveBeenCalledWith() - Mocks

Mocking:

import { mock, spyOn } from "bun:test";

const mockFn = mock(() => 42);
mockFn.mockImplementation(() => 100);
mockFn.mockReturnValue(200);

const spy = spyOn(object, "method");
spy.mockResolvedValue({ data: "test" });

// Module mocking
mock.module("./api", () => ({
  fetchUser: mock(() => ({ id: 1, name: "Test" }))
}));

CLI Commands:

bun test                 # Run all tests
bun test --watch         # Watch mode
bun test --coverage      # Enable coverage
bun test -t "pattern"    # Filter by test name
bun test --timeout=5000  # Set timeout
bun test --bail          # Stop on first failure
bun test --update-snapshots  # Update snapshots

4. Bundler Configuration

JavaScript API:

const result = await Bun.build({
  entrypoints: ["./src/index.tsx"],
  outdir: "./dist",
  target: "browser",  // "browser" | "bun" | "node"
  format: "esm",      // "esm" | "cjs" | "iife"
  minify: true,
  sourcemap: "external",
  splitting: true,    // Code splitting
  external: ["react", "react-dom"],
  define: {
    "process.env.NODE_ENV": '"production"'
  },
  loader: {
    ".png": "dataurl",
    ".svg": "text"
  },
  plugins: [myPlugin],
  naming: {
    entry: "[dir]/[name].[ext]",
    chunk: "[name]-[hash].[ext]"
  }
});

if (!result.success) {
  console.error(result.logs);
}

CLI:

bun build ./src/index.tsx --outdir ./dist --minify --sourcemap=external
bun build ./src/index.ts --compile --outfile myapp  # Single executable

Plugin System:

const myPlugin: BunPlugin = {
  name: "yaml-loader",
  setup(build) {
    build.onLoad({ filter: /\.yaml$/ }, async (args) => {
      const text = await Bun.file(args.path).text();
      return {
        contents: `export default ${JSON.stringify(YAML.parse(text))}`,
        loader: "js"
      };
    });
  }
};

5. TypeScript Integration

Bun executes TypeScript natively without transpilation configuration:

bun run index.ts      # Just works
bun run index.tsx     # JSX supported

Recommended tsconfig.json:

{
  "compilerOptions": {
    "lib": ["ESNext"],
    "target": "ESNext",
    "module": "ESNext",
    "moduleDetection": "force",
    "moduleResolution": "bundler",
    "allowImportingTsExtensions": true,
    "verbatimModuleSyntax": true,
    "noEmit": true,
    "strict": true,
    "skipLibCheck": true,
    "types": ["bun-types"]
  }
}

Type checking (separate step):

bunx tsc --noEmit

6. Configuration (bunfig.toml)

# Runtime
preload = ["./setup.ts"]
smol = true                    # Reduced memory mode

# JSX
[jsx]
runtime = "automatic"
importSource = "react"

# Package installation
[install]
optional = false
lockfile.save = true

[install.scopes]
"@myorg" = { url = "https://npm.myorg.com", token = "$NPM_TOKEN" }

# Test runner
[test]
preload = ["./test-setup.ts"]
coverage = true
coverageThreshold = { lines = 0.8, functions = 0.8 }

7. CLI Flags Reference

Execution:

• --watch - Auto-restart on file changes
• --hot - Hot module replacement
• --smol - Reduced memory mode
• --inspect / --inspect-brk - Debugger

Module Resolution:

• --preload / -r - Preload modules
• --install=auto|fallback|force - Auto-install behavior

Transpilation:

• --define / -d - Compile-time constants
• --drop=console - Remove function calls
• --loader - Custom file loaders

Environment:

• --env-file - Load specific .env files
• --cwd - Set working directory
• --bun / -b - Force Bun runtime

Node.js Migration Guidance

Quick Migration Steps

1. Install Bun: curl -fsSL https://bun.sh/install | bash
2. Replace package manager:

# Delete node_modules and lockfile

rm -rf node_modules package-lock.json yarn.lock pnpm-lock.yaml
bun install

3. Update scripts in package.json:

{
  "scripts": {
    "dev": "bun run --watch src/index.ts",
    "test": "bun test",
    "build": "bun build src/index.ts --outdir dist"
  }
}

4. Update TypeScript types:

bun add -d @types/bun
# Or in tsconfig.json: "types": ["bun-types"]

API Compatibility

Fully Compatible:

• node:assert, node:buffer, node:events, node:path, node:url
• node:fs (92%), node:http, node:https, node:stream, node:zlib
• node:crypto, node:net, node:dns, node:os

Partially Compatible:

• node:child_process - Missing proc.gid, proc.uid; IPC limited to JSON
• node:cluster - Linux-only SO_REUSEPORT for load balancing
• node:http2 - 95% compatible; missing pushStream
• node:worker_threads - Missing stdin, stdout, stderr options
• node:async_hooks - AsyncLocalStorage works; v8 promise hooks missing

Not Implemented:

• node:inspector, node:repl, node:trace_events

Common Migration Gotchas

1. Native Modules: Packages using node-gyp (bcrypt, sharp) may fail
   • Solution: Use pure JS alternatives (bcryptjs instead of bcrypt)
2. Lifecycle Scripts: Bun blocks postinstall by default (security)
   • Solution: bun pm trust <package> or add to trustedDependencies
3. Module System: Some packages relying on Node.js internals may fail
   • Module._nodeModulePaths doesn't exist in Bun
4. File System Differences: Heavy concurrent file reads can cause memory issues
   • Solution: Use graceful-fs wrapper
5. TypeScript Entry Points: Update "main" field for Bun:

{

  "main": "src/index.ts"  // Not "build/index.js"
}

Gradual Migration Strategy

Phase 1: Package manager only (bun install) Phase 2: Development tooling (bun run, bun test) Phase 3: Selective runtime migration (shadow deploy) Phase 4: Full production migration

Best Practices

Performance Optimization

// Use Bun's native APIs for I/O
const file = Bun.file("large.txt");  // Zero-copy
const content = await file.text();
await Bun.write("output.txt", processedData);

// Use Promise.all for concurrent operations
const [users, posts] = await Promise.all([
  db.query("SELECT * FROM users"),
  db.query("SELECT * FROM posts")
]);

// Use Bun.serve() static routes
Bun.serve({
  static: {
    "/": homepage,
    "/about": aboutPage
  },
  fetch(req) { /* dynamic routes */ }
});

// Use bun:sqlite for local data
import { Database } from "bun:sqlite";
const db = new Database(":memory:");
const stmt = db.prepare("SELECT * FROM users WHERE id = ?");

Error Handling

// HTTP server error handling
Bun.serve({
  fetch(req) {
    try {
      return handleRequest(req);
    } catch (error) {
      console.error(error);
      return new Response("Internal Error", { status: 500 });
    }
  },
  error(error) {
    return new Response(`Error: ${error.message}`, { status: 500 });
  }
});

// Process-level error handling
process.on("uncaughtException", (error) => {
  console.error("Uncaught:", error);
  process.exit(1);
});

Security Best Practices

1. Lifecycle Scripts: Keep trustedDependencies minimal
2. Environment Variables: Use .env.local for secrets (not committed)
3. Input Validation: Sanitize all user inputs
4. Dependencies: Run bun audit regularly
5. Production: Use --production flag to skip devDependencies

Project Structure

my-bun-project/
├── src/
│   ├── index.ts        # Entry point
│   ├── server.ts       # HTTP server
│   └── lib/            # Utilities
├── test/
│   └── *.test.ts       # Test files
├── bunfig.toml         # Bun configuration
├── tsconfig.json       # TypeScript config
├── package.json
└── .env.local          # Local secrets (gitignored)

Debugging

Web Debugger:

bun --inspect server.ts         # Start debugger
bun --inspect-brk server.ts     # Break at first line
bun --inspect-wait server.ts    # Wait for connection

Open https://debug.bun.sh or use VSCode Bun extension.

Verbose Fetch Logging:

BUN_CONFIG_VERBOSE_FETCH=curl bun run server.ts

Examples

HTTP Server with WebSocket

Bun.serve({
  port: 3000,
  fetch(req, server) {
    if (server.upgrade(req)) return;
    return new Response("Hello Bun!");
  },
  websocket: {
    open(ws) { console.log("Connected"); },
    message(ws, message) { ws.send(`Echo: ${message}`); },
    close(ws) { console.log("Disconnected"); }
  }
});

File Server

Bun.serve({
  async fetch(req) {
    const path = new URL(req.url).pathname;
    const file = Bun.file(`./public${path}`);
    if (await file.exists()) {
      return new Response(file);
    }
    return new Response("Not Found", { status: 404 });
  }
});

Database with SQLite

import { Database } from "bun:sqlite";

const db = new Database("app.db");
db.run(`CREATE TABLE IF NOT EXISTS users (
  id INTEGER PRIMARY KEY AUTOINCREMENT,
  name TEXT NOT NULL,
  email TEXT UNIQUE
)`);

const insert = db.prepare("INSERT INTO users (name, email) VALUES (?, ?)");
const getAll = db.prepare("SELECT * FROM users");

insert.run("Alice", "alice@example.com");
const users = getAll.all();

When This Skill Activates

This skill automatically activates when:

• Working with .ts, .tsx, .js, .jsx files in a Bun project
• Creating or modifying bunfig.toml or bun.lock
• Using bun:test, bun:sqlite, bun:ffi imports
• Discussing Bun APIs (Bun.serve, Bun.file, Bun.build)
• Migrating from Node.js to Bun
• Writing or debugging Bun tests
• Configuring the Bun bundler

Weekly Installs

103

Repository

lammesen/skills

First Seen

Jan 23, 2026

Security Audits

Gen Agent Trust HubFailSocketPassSnykWarn

Installed on

opencode84

codex76

gemini-cli75

claude-code68

github-copilot65

antigravity55