┌─────────────────────────────────────────────────────────────┐
│                  OpenClaw / 你的代碼                          │
│                       │ tool calls                           │
│                       ▼                                      │
│              Plugin Entry (index.ts)                         │
│              ┌────────┼────────┐                             │
│              ▼        ▼        ▼                             │
│        SessionManager  Proxy   HTTP Server                   │
│        ┌──┬──┬──┬──┐  Handler  (:18796)                     │
│        ▼  ▼  ▼  ▼  ▼    │                                   │
│     Claude Codex Gemini  │  Anthropic ? OpenAI               │
│     Engine Engine Engine │  格式轉(zhuǎn)換                          │
│        │     │     │     ▼                                   │
│     Council  Inbox  Ultraplan                                │
│     (git worktree per agent)                                 │
└─────────────────────────────────────────────────────────────┘

index.ts                     → Plugin entry：27 個工具 + proxy 路由
models.ts                    → 集中式模型注冊表：定價、別名、引擎
types.ts                     → 共享類型、ISession 接口
constants.ts                 → 共享常量：超時、限制、閾值
logger.ts                    → 結(jié)構(gòu)化 Logger 接口
base-oneshot-session.ts      → 一次性引擎的抽象基類
persistent-session.ts        → Claude Code 引擎
persistent-codex-session.ts  → Codex 引擎
persistent-gemini-session.ts → Gemini 引擎
persistent-cursor-session.ts → Cursor Agent 引擎
persistent-custom-session.ts → 自定義引擎
session-manager.ts           → 多會話編排 + Council 管理
circuit-breaker.ts           → 引擎故障跟蹤 + 指數(shù)退避
inbox-manager.ts             → 跨會話消息傳遞

# 1. Node.js 22+（必須）
node -v
# 期望輸出: v22.x.x 或更高
# 2. Claude Code CLI（核心依賴）
npm install -g @anthropic-ai/claude-code
claude --version
# 3. OpenClaw（如果使用插件模式）
openclaw --version
# 4. 配置 Anthropic API Key
export ANTHROPIC_API_KEY=sk-ant-xxxxx

curl -fsSL https://raw.githubusercontent.com/Enderfga/openclaw-claude-code/main/install.sh | bash

# 全局安裝
npm install -g @enderfga/openclaw-claude-code
# 啟動獨立服務(wù)（暴露 OpenAI 兼容 API）
claude-code-skill serve

# Step 1: 創(chuàng)建目標(biāo)目錄
mkdir -p ~/.openclaw/extensions/openclaw-claude-code
# Step 2: 下載并解壓插件包
cd /tmp
npm pack @enderfga/openclaw-claude-code
tar -xzf enderfga-openclaw-claude-code-*.tgz
cp -r package/* ~/.openclaw/extensions/openclaw-claude-code/
# Step 3: 進(jìn)入插件目錄安裝依賴
cd ~/.openclaw/extensions/openclaw-claude-code
npm install --production --ignore-scripts
# Step 4: 驗證文件結(jié)構(gòu)
ls -la ~/.openclaw/extensions/openclaw-claude-code/

{
  "plugins": {
    "allow": [
      "openclaw-claude-code"
    ],
    "entries": {
      "openclaw-claude-code": {
        "enabled": true
      }
    }
  }
}

# 重啟 Gateway
openclaw gateway restart
# 驗證插件加載
openclaw plugins list | grep -i claude
# 運行診斷
openclaw plugins doctor

curl http://127.0.0.1:18796/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-sonnet-4-6",
    "messages": [{"role": "user", "content": "Hello!"}],
    "stream": true
  }'

import { SessionManager } from '@enderfga/openclaw-claude-code';
const manager = new SessionManager();
// 1. 啟動會話——指定引擎、模型和思考深度
await manager.startSession({
  name: 'my-task',
  cwd: '/home/ubuntu/projects/my-app',
  engine: 'claude',       // claude | codex | gemini | cursor | custom
  model: 'sonnet',        // 模型別名，插件內(nèi)部映射到完整名稱
  effort: 'high',         // low | medium | high | max
});
// 2. 發(fā)送消息——effort 可以每條消息單獨設(shè)置
const result = await manager.sendMessage('my-task', 'Fix the failing tests', {
  effort: 'max',          // 這條消息用最深度的思考
});
// 3. 查詢狀態(tài)——實時了解 Token 消耗和成本
const status = manager.getSessionStatus('my-task');
console.log(`Tokens: ${status.tokens}, Cost: $${status.cost}`);
// 4. 恢復(fù)會話并熱切換模型——不中斷上下文
await manager.resumeSession('my-task', {
  model: 'opus',          // 從 Sonnet 熱切換到 Opus
});

// 定向通信——讓 planner 給 coder 發(fā)需求
await manager.sessionSendTo('planner', 'coder',
  'The auth module needs rate limiting');
// 廣播——monitor 向所有會話發(fā)警報
await manager.sessionSendTo('monitor', '*', 'Build failed!');

// 先規(guī)劃，再執(zhí)行
const plan = manager.ultraplanStart(
  'Add OAuth2 support with Google and GitHub providers',
  { cwd: '/path/to/project', model: 'opus', timeout: 1800000 }
);
// 每 30 秒輪詢
let planStatus;
do {
  await new Promise(r => setTimeout(r, 30000));
  planStatus = manager.ultraplanStatus(plan.id);
} while (planStatus?.status !== 'completed');
console.log('Plan ready:', planStatus.plan);
// 然后把 plan 傳給 Council 去執(zhí)行

┌─────────────────────────────────────────────────┐
│                 Council 啟動                      │
│                     │                            │
│    ┌────────────────┼────────────────┐           │
│    ▼                ▼                ▼           │
│ ??? Architect     ?? Engineer      ?? Reviewer   │
│ (git worktree A) (git worktree B) (git worktree C)│
│    │                │                │           │
│    ▼                ▼                ▼           │
│  Round 1: 各自獨立工作                             │
│    │                │                │           │
│    └────────────────┼────────────────┘           │
│                     ▼                            │
│              共識投票 [CONSENSUS: YES/NO]          │
│                     │                            │
│           ┌─────────┴─────────┐                  │
│           ▼                   ▼                  │
│     達(dá)成共識 → 完成       未達(dá)成 → Round 2...      │
│                                                  │
│  最終: council_review → council_accept/reject     │
└─────────────────────────────────────────────────┘

{
  "tool": "council_start",
  "args": {
    "task": "Build a REST API with authentication and rate limiting",
    "projectDir": "/tmp/my-api-project",
    "maxRounds": 10
  }
}

const manager = new SessionManager();
const council = manager.councilStart(
  'Build a REST API with authentication',
  {
    agents: [
      {
        name: 'Architect',
        emoji: '???',
        persona: 'System architect focused on scalability',
        engine: 'claude',
        model: 'opus'
      },
      {
        name: 'Engineer',
        emoji: '??',
        persona: 'Implementation engineer focused on code quality',
        engine: 'claude',
        model: 'sonnet'
      },
      {
        name: 'Reviewer',
        emoji: '??',
        persona: 'Code reviewer focused on bugs and security',
        engine: 'claude',
        model: 'sonnet'
      },
    ],
    maxRounds: 10,
    projectDir: '/tmp/my-api-project',
  }
);

const council = manager.councilStart('Build a REST API with auth', {
  agents: [
    {
      name: 'Planner',
      emoji: '??',
      persona: 'Requirements & architecture',
      engine: 'claude',     // Claude 做規(guī)劃
      model: 'opus'
    },
    {
      name: 'Generator',
      emoji: '??',
      persona: 'Implementation per plan',
      engine: 'codex',      // Codex 做實現(xiàn)
      model: 'o4-mini'
    },
    {
      name: 'Evaluator',
      emoji: '??',
      persona: 'Independent verification',
      engine: 'claude',     // Claude 做審查
      model: 'sonnet'
    },
  ],
  maxRounds: 10,
  projectDir: '/tmp/api-project',
});

// 1. 啟動
const council = manager.councilStart('任務(wù)描述', config);
// 2. 輪詢狀態(tài)——每 60 秒檢查一次
let councilStatus;
do {
  await new Promise(r => setTimeout(r, 60000));
  councilStatus = manager.councilStatus(council.id);
  console.log(`Round ${councilStatus.currentRound}, ` +
              `Consensus: ${councilStatus.consensus}`);
} while (!councilStatus?.completed);
// 3. 中途注入指導(dǎo)（可選但強大）
manager.councilInject(council.id,
  'Please also add input validation');
// 4. 審查結(jié)果——看變更文件、分支、計劃、摘要
const review = manager.councilReview(council.id);
console.log('Changed files:', review.changedFiles);
console.log('Branches:', review.branches);
// 5a. 滿意 → 接受（清理 worktree、分支、plan.md）
manager.councilAccept(council.id);
// 5b. 不滿意 → 拒絕（附帶反饋，Council 可重試）
manager.councilReject(council.id,
  'Need better error handling');

council_start({
  task: "設(shè)計和實現(xiàn)一個功能完整的 CLI 密碼生成器，包括密碼學(xué)安全隨機數(shù)、" +
        "自定義字符類型、相似字符排除、強度評估和完整的測試覆蓋",
  projectDir: "~/projects/password-generator",
  agents: [
    {
      name: "ProductManager",
      emoji: "??",
      persona: "產(chǎn)品經(jīng)理。從用戶角度分析需求，定義 MVP 功能和驗收標(biāo)準(zhǔn)。",
      engine: "claude",
      model: "claude-sonnet-4.5"
    },
    {
      name: "Architect",
      emoji: "???",
      persona: "軟件架構(gòu)師。設(shè)計模塊化架構(gòu)，確保密碼學(xué)安全性。",
      engine: "claude",
      model: "claude-opus-4.5"
    },
    {
      name: "Developer",
      emoji: "??",
      persona: "Node.js 開發(fā)專家。實現(xiàn)高質(zhì)量代碼，使用 crypto 模塊。",
      engine: "claude",
      model: "claude-sonnet-4.5"
    },
    {
      name: "QA_Engineer",
      emoji: "??",
      persona: "測試工程師。編寫全面的單元測試，覆蓋率 > 80%。",
      engine: "claude",
      model: "claude-sonnet-4.5"
    },
    {
      name: "TechWriter",
      emoji: "??",
      persona: "技術(shù)文檔專家。編寫清晰完整的 README 和使用示例。",
      engine: "claude",
      model: "claude-haiku-4.5"
    }
  ],
  maxRounds: 15,
  agentTimeoutMs: 1800000,
  maxTurnsPerAgent: 30,
  maxBudgetUsd: 8.0,
  defaultPermissionMode: "bypassPermissions"
});

用戶故事：
1. 作為用戶，我想快速生成安全的隨機密碼
2. 作為用戶，我想自定義密碼長度（4-128 字符）
3. 作為用戶，我想選擇字符類型（大小寫、數(shù)字、符號）
4. 作為用戶，我想排除容易混淆的字符（如 i, l, 1, o, 0, O）
MVP 功能（P0 優(yōu)先級）：
? 生成隨機密碼
? 自定義長度
? 選擇字符類型
? 排除相似字符
? 密碼強度評估
驗收標(biāo)準(zhǔn)：
- 使用密碼學(xué)安全的隨機數(shù)生成器（不用 Math.random()）
- 支持命令行參數(shù)
- 彩色輸出
- 完整的單元測試（覆蓋率 > 80%）

技術(shù)選型：
- CLI 框架: Commander.js（成熟、零配置）
- 彩色輸出: Chalk v4（CommonJS 兼容）
- 核心邏輯: Node.js crypto.randomBytes()（密碼學(xué)安全）
模塊劃分：
src/
├── index.js          # CLI 入口，Commander.js 參數(shù)解析
└── generator.js      # 核心密碼生成邏輯
    ├── generatePassword()     # 主函數(shù)
    ├── estimateStrength()     # 強度評估
    ├── getRandomInt()         # 安全隨機數(shù)
    └── ensureCharacterTypes() # 確保字符類型完整性
核心設(shè)計原則：
1. 密碼學(xué)安全：使用 crypto.randomBytes()，禁用 Math.random()
2. 拒絕采樣：避免隨機數(shù)偏差（模數(shù)偏差問題）
3. 可測試性：所有函數(shù)可獨立單元測試

測試覆蓋規(guī)劃（28 個用例）：
- generatePassword: 12 個（默認(rèn)/自定義/邊界/唯一性/類型確保）
- estimateStrength: 7 個（結(jié)構(gòu)/弱/中/強/熵值/長度/混合）
- 字符集驗證: 5 個
- 相似字符排除: 4 個

// src/generator.js — 核心邏輯
const crypto = require('crypto');
// 字符集定義
const CHAR_SETS = {
  lowercase: 'abcdefghijklmnopqrstuvwxyz',
  uppercase: 'ABCDEFGHIJKLMNOPQRSTUVWXYZ',
  numbers: '0123456789',
  symbols: '!@#$%^&*()_+-=[]{}|;:,.<>?'
};
// 容易混淆的相似字符
const SIMILAR_CHARS = {
  lowercase: 'ilo',
  uppercase: 'IO',
  numbers: '01'
};
function generatePassword(options = {}) {
  const {
    length = 16,
    lowercase = true,
    uppercase = true,
    numbers = true,
    symbols = true,
    excludeSimilar = false
  } = options;
  // 驗證長度邊界
  if (length < 4) throw new Error('Password length must be at least 4');
  if (length > 128) throw new Error('Password length cannot exceed 128');
  // 構(gòu)建字符池——如果啟用了排除相似字符，過濾掉
  let charPool = '';
  if (lowercase) {
    let chars = CHAR_SETS.lowercase;
    if (excludeSimilar) {
      chars = chars.split('')
        .filter(c => !SIMILAR_CHARS.lowercase.includes(c)).join('');
    }
    charPool += chars;
  }
  // uppercase, numbers, symbols 同理...
  if (charPool.length === 0) {
    throw new Error('At least one character type must be selected');
  }
  // 使用 crypto 生成安全隨機密碼
  const password = Array.from({ length }, () => {
    const randomIndex = getRandomInt(0, charPool.length);
    return charPool[randomIndex];
  }).join('');
  // 確保密碼包含每種選中的字符類型
  return ensureCharacterTypes(password, options);
}

function getRandomInt(min, max) {
  const range = max - min;
  const bytesNeeded = Math.ceil(Math.log2(range) / 8);
  const cutoff = Math.floor((256 ** bytesNeeded) / range) * range;
  const bytes = crypto.randomBytes(bytesNeeded);
  let value = 0;
  for (let i = 0; i < bytesNeeded; i++) {
    value = (value << 8) + bytes[i];
  }
  // 關(guān)鍵：拒絕采樣避免模數(shù)偏差
  // 如果隨機值落在 cutoff 之外，重新生成
  if (value >= cutoff) {
    return getRandomInt(min, max);
  }
  return min + (value % range);
}

function estimateStrength(password) {
  let score = 0;
  const length = password.length;
  // 長度評分（≥8: +1, ≥12: +1, ≥16: +1）
  if (length >= 8) score += 1;
  if (length >= 12) score += 1;
  if (length >= 16) score += 1;
  // 字符類型評分（每種 +1）
  if (/[a-z]/.test(password)) score += 1;
  if (/[A-Z]/.test(password)) score += 1;
  if (/[0-9]/.test(password)) score += 1;
  if (/[^a-zA-Z0-9]/.test(password)) score += 1;
  // 計算熵值 = log2(字符集大小 ^ 長度)
  const charsetSize =
    (/[a-z]/.test(password) ? 26 : 0) +
    (/[A-Z]/.test(password) ? 26 : 0) +
    (/[0-9]/.test(password) ? 10 : 0) +
    (/[^a-zA-Z0-9]/.test(password) ? 32 : 0);
  const entropy = Math.floor(Math.log2(charsetSize ** length));
  // 評級：≤3 Weak(紅), ≤5 Medium(黃), >5 Strong(綠)
  let level, color;
  if (score <= 3) { level = 'Weak'; color = 'red'; }
  else if (score <= 5) { level = 'Medium'; color = 'yellow'; }
  else { level = 'Strong'; color = 'green'; }
  return { score, level, color, entropy };
}

#!/usr/bin/env node
const { Command } = require('commander');
const chalk = require('chalk');
const { generatePassword, estimateStrength } = require('./generator');
const program = new Command();
program
  .name('passgen')
  .description('Generate secure random passwords')
  .version('1.0.0')
  .argument('[length]', 'Password length (default: 16)', '16')
  .option('-x, --exclude-similar', 'Exclude similar chars (i,l,1,o,0,O)')
  .option('-c, --count <number>', 'Generate multiple passwords', '1')
  .option('--no-symbols', 'Disable symbols')
  .action((length, options) => {
    const genOptions = {
      length: parseInt(length, 10),
      lowercase: options.lowercase,
      uppercase: options.uppercase,
      numbers: options.numbers,
      symbols: options.symbols,
      excludeSimilar: options.excludeSimilar
    };
    // 顯示配置面板
    displayConfig(genOptions, parseInt(options.count, 10));
    // 生成并顯示密碼
    for (let i = 0; i < parseInt(options.count, 10); i++) {
      const password = generatePassword(genOptions);
      const strength = estimateStrength(password);
      displayPassword(password, strength, i + 1, parseInt(options.count, 10));
    }
  });
program.parse();

$ npm test
Test Suites: 1 passed, 1 total
Tests:       28 passed, 28 total
Snapshots:   0 total
Time:        0.856 s
Coverage:    > 80% ?

describe('Password Generator', () => {
  describe('generatePassword', () => {
    test('generates password with default options', () => {
      const password = generatePassword();
      expect(password).toHaveLength(16);
    });
    test('respects custom length', () => {
      const password = generatePassword({ length: 24 });
      expect(password).toHaveLength(24);
    });
    test('throws on length < 4', () => {
      expect(() => generatePassword({ length: 2 })).toThrow();
    });
    test('excludes similar characters when option is set', () => {
      const password = generatePassword({
        length: 100,  // 長密碼增加覆蓋
        excludeSimilar: true
      });
      expect(password).not.toMatch(/[iloIO01]/);
    });
    test('ensures all selected character types are present', () => {
      // 多次生成驗證
      for (let i = 0; i < 50; i++) {
        const password = generatePassword({ length: 8 });
        expect(password).toMatch(/[a-z]/);
        expect(password).toMatch(/[A-Z]/);
        expect(password).toMatch(/[0-9]/);
      }
    });
  });
  describe('estimateStrength', () => {
    test('rates short password as Weak', () => {
      const result = estimateStrength('abc');
      expect(result.level).toBe('Weak');
    });
    test('rates long complex password as Strong', () => {
      const result = estimateStrength('aB3$xY7!kL9@mN2#');
      expect(result.level).toBe('Strong');
    });
    test('calculates entropy correctly', () => {
      const result = estimateStrength('abcd1234');
      expect(result.entropy).toBeGreaterThan(0);
    });
  });
});

password-generator/
├── src/
│   ├── index.js           # CLI 入口 (4716 字節(jié))
│   └── generator.js       # 核心邏輯 (5128 字節(jié))
├── tests/
│   └── generator.test.js  # 測試套件 (7033 字節(jié))
├── package.json           # 項目配置
├── jest.config.js         # Jest 配置
├── .eslintrc.js          # ESLint 配置
├── .gitignore
└── README.md             # 完整文檔 (5189 字節(jié))