@jonnyhoo/ccs 1.1.1 → 1.1.3

package/scripts/background-redis-bridge.js

@@ -0,0 +1,320 @@
+#!/usr/bin/env node
+
+/**
+ * Bridge CCS background Claude execution to Redis Streams.
+ *
+ * Required env:
+ * - CCS_BG_TASK_ID
+ * - CCS_BG_REDIS_URL
+ * - CCS_BG_STREAM_KEY
+ * - CCS_BG_CLAUDE_CLI
+ * - CCS_BG_CLAUDE_ARGS_B64 (base64 JSON array)
+ *
+ * Optional env:
+ * - CCS_BG_CWD
+ * - CCS_BG_TTL_SECONDS (default: 86400)
+ */
+
+const net = require('node:net');
+const tls = require('node:tls');
+const { spawn } = require('node:child_process');
+
+const taskId = process.env.CCS_BG_TASK_ID;
+const redisUrl = process.env.CCS_BG_REDIS_URL;
+const streamKey = process.env.CCS_BG_STREAM_KEY;
+const claudeCli = process.env.CCS_BG_CLAUDE_CLI;
+const argsB64 = process.env.CCS_BG_CLAUDE_ARGS_B64;
+const cwd = process.env.CCS_BG_CWD || process.cwd();
+const ttlSeconds = parseInt(process.env.CCS_BG_TTL_SECONDS || '86400', 10);
+
+if (!taskId || !redisUrl || !streamKey || !claudeCli || !argsB64) {
+  process.exit(1);
+}
+
+let claudeArgs = [];
+try {
+  const decoded = Buffer.from(argsB64, 'base64').toString('utf8');
+  const parsed = JSON.parse(decoded);
+  claudeArgs = Array.isArray(parsed) ? parsed.map(String) : [];
+} catch {
+  process.exit(1);
+}
+
+function encodeBulk(value) {
+  const str = String(value);
+  return `$${Buffer.byteLength(str, 'utf8')}\r\n${str}\r\n`;
+}
+
+function encodeArray(parts) {
+  let out = `*${parts.length}\r\n`;
+  for (const part of parts) {
+    out += encodeBulk(part);
+  }
+  return out;
+}
+
+function parseRedisUrl(input) {
+  const u = new URL(input);
+  const secure = u.protocol === 'rediss:';
+  if (u.protocol !== 'redis:' && u.protocol !== 'rediss:') {
+    throw new Error('Unsupported Redis protocol');
+  }
+
+  const db = u.pathname && u.pathname !== '/' ? parseInt(u.pathname.slice(1), 10) : 0;
+  return {
+    host: u.hostname || '127.0.0.1',
+    port: u.port ? parseInt(u.port, 10) : 6379,
+    secure,
+    username: decodeURIComponent(u.username || ''),
+    password: decodeURIComponent(u.password || ''),
+    db: Number.isFinite(db) ? db : 0,
+  };
+}
+
+class RedisClient {
+  constructor(config) {
+    this.config = config;
+    this.socket = null;
+    this.buffer = '';
+    this.pending = [];
+  }
+
+  connect() {
+    return new Promise((resolve, reject) => {
+      const options = { host: this.config.host, port: this.config.port };
+      const onConnect = async () => {
+        try {
+          await this._authAndSelect();
+          resolve();
+        } catch (err) {
+          reject(err);
+        }
+      };
+
+      this.socket = this.config.secure
+        ? tls.connect({ ...options, servername: this.config.host }, onConnect)
+        : net.createConnection(options, onConnect);
+
+      this.socket.setEncoding('utf8');
+      this.socket.on('data', (chunk) => this._onData(chunk));
+      this.socket.on('error', (err) => {
+        while (this.pending.length > 0) {
+          const p = this.pending.shift();
+          p.reject(err);
+        }
+      });
+      this.socket.on('close', () => {
+        while (this.pending.length > 0) {
+          const p = this.pending.shift();
+          p.reject(new Error('Redis connection closed'));
+        }
+      });
+    });
+  }
+
+  async _authAndSelect() {
+    if (this.config.password) {
+      if (this.config.username) {
+        await this.command('AUTH', this.config.username, this.config.password);
+      } else {
+        await this.command('AUTH', this.config.password);
+      }
+    }
+    if (this.config.db > 0) {
+      await this.command('SELECT', String(this.config.db));
+    }
+  }
+
+  command(...parts) {
+    return new Promise((resolve, reject) => {
+      const payload = encodeArray(parts);
+      this.pending.push({ resolve, reject });
+      this.socket.write(payload);
+    });
+  }
+
+  async xadd(fields) {
+    const payload = ['XADD', streamKey, '*'];
+    for (const [k, v] of Object.entries(fields)) {
+      payload.push(k, v == null ? '' : String(v));
+    }
+    await this.command(...payload);
+  }
+
+  async expire(seconds) {
+    await this.command('EXPIRE', streamKey, String(seconds));
+  }
+
+  _onData(chunk) {
+    this.buffer += chunk;
+    while (this.buffer.length > 0 && this.pending.length > 0) {
+      const parsed = this._readOne(this.buffer);
+      if (!parsed) {
+        return;
+      }
+      this.buffer = parsed.rest;
+      const pending = this.pending.shift();
+      if (parsed.type === 'error') {
+        pending.reject(new Error(parsed.value));
+      } else {
+        pending.resolve(parsed.value);
+      }
+    }
+  }
+
+  _readOne(input) {
+    if (!input.length) return null;
+    const marker = input[0];
+
+    if (marker === '+' || marker === '-' || marker === ':') {
+      const idx = input.indexOf('\r\n');
+      if (idx === -1) return null;
+      const value = input.slice(1, idx);
+      return {
+        type: marker === '-' ? 'error' : 'ok',
+        value,
+        rest: input.slice(idx + 2),
+      };
+    }
+
+    if (marker === '$') {
+      const idx = input.indexOf('\r\n');
+      if (idx === -1) return null;
+      const len = parseInt(input.slice(1, idx), 10);
+      if (len === -1) {
+        return { type: 'ok', value: null, rest: input.slice(idx + 2) };
+      }
+      const total = idx + 2 + len + 2;
+      if (input.length < total) return null;
+      const value = input.slice(idx + 2, idx + 2 + len);
+      return { type: 'ok', value, rest: input.slice(total) };
+    }
+
+    if (marker === '*') {
+      // For our command path, we do not need to parse nested arrays fully.
+      // Consume minimal array response as opaque ok.
+      const idx = input.indexOf('\r\n');
+      if (idx === -1) return null;
+      const count = parseInt(input.slice(1, idx), 10);
+      if (count < 0) {
+        return { type: 'ok', value: null, rest: input.slice(idx + 2) };
+      }
+      let rest = input.slice(idx + 2);
+      for (let i = 0; i < count; i++) {
+        const item = this._readOne(rest);
+        if (!item) return null;
+        rest = item.rest;
+      }
+      return { type: 'ok', value: 'array', rest };
+    }
+
+    return null;
+  }
+
+  close() {
+    if (this.socket) {
+      this.socket.end();
+      this.socket.destroy();
+      this.socket = null;
+    }
+  }
+}
+
+function splitLines(state, chunk, onLine) {
+  state.buffer += chunk;
+  const parts = state.buffer.split(/\r?\n/);
+  state.buffer = parts.pop() || '';
+  for (const p of parts) {
+    onLine(p);
+  }
+}
+
+async function run() {
+  const config = parseRedisUrl(redisUrl);
+  const redis = new RedisClient(config);
+  await redis.connect();
+
+  const startedAt = Date.now();
+  await redis.xadd({
+    type: 'status',
+    event: 'started',
+    task_id: taskId,
+    ts: String(startedAt),
+  });
+  await redis.expire(ttlSeconds);
+
+  const proc = spawn(claudeCli, claudeArgs, {
+    cwd,
+    windowsHide: true,
+    stdio: ['ignore', 'pipe', 'pipe'],
+  });
+
+  const stdoutState = { buffer: '' };
+  const stderrState = { buffer: '' };
+
+  proc.stdout.on('data', (buf) => {
+    splitLines(stdoutState, buf.toString(), (line) => {
+      if (!line.trim()) return;
+      void redis
+        .xadd({ type: 'stdout', task_id: taskId, ts: String(Date.now()), data: line })
+        .catch(() => {});
+    });
+  });
+
+  proc.stderr.on('data', (buf) => {
+    splitLines(stderrState, buf.toString(), (line) => {
+      if (!line.trim()) return;
+      void redis
+        .xadd({ type: 'stderr', task_id: taskId, ts: String(Date.now()), data: line })
+        .catch(() => {});
+    });
+  });
+
+  proc.on('close', async (code, signal) => {
+    if (stdoutState.buffer.trim()) {
+      await redis.xadd({
+        type: 'stdout',
+        task_id: taskId,
+        ts: String(Date.now()),
+        data: stdoutState.buffer,
+      });
+    }
+    if (stderrState.buffer.trim()) {
+      await redis.xadd({
+        type: 'stderr',
+        task_id: taskId,
+        ts: String(Date.now()),
+        data: stderrState.buffer,
+      });
+    }
+
+    await redis.xadd({
+      type: 'status',
+      event: 'completed',
+      task_id: taskId,
+      ts: String(Date.now()),
+      exit_code: String(code == null ? -1 : code),
+      signal: signal || '',
+      success: String((code || 0) === 0),
+      duration_ms: String(Date.now() - startedAt),
+    });
+    await redis.expire(ttlSeconds);
+    redis.close();
+    process.exit((code || 0) === 0 ? 0 : 1);
+  });
+
+  proc.on('error', async (err) => {
+    await redis.xadd({
+      type: 'status',
+      event: 'failed',
+      task_id: taskId,
+      ts: String(Date.now()),
+      error: err.message,
+    });
+    await redis.expire(ttlSeconds);
+    redis.close();
+    process.exit(1);
+  });
+}
+
+run().catch(() => process.exit(1));

package/scripts/dev-install.sh

@@ -77,7 +77,8 @@ else
 fi
 
 # Find the tarball
-TARBALL=$(ls -t kaitranntt-ccs-*.tgz 2>/dev/null | head -1)
+PACKAGE_NAME=$(node -p "require('./package.json').name.replace(/^@/, '').replace(/\//g, '-')")
+TARBALL=$(ls -t "${PACKAGE_NAME}"-*.tgz 2>/dev/null | head -1)
 
 if [ -z "$TARBALL" ]; then
     echo "[X] ERROR: No tarball found"

package/scripts/monitor-task.js

@@ -0,0 +1,313 @@
+#!/usr/bin/env node
+
+/**
+ * CCS Background Task Monitor
+ *
+ * 监控 CCS 后台任务的执行状态，提供可靠的状态检测
+ *
+ * 使用方法:
+ *   node monitor-task.js <taskId>
+ *   node monitor-task.js <outputFile>
+ *
+ * 功能:
+ * 1. 检测任务是否启动（输出文件是否存在）
+ * 2. 检测任务是否完成（stream-json 中是否有 stop_reason）
+ * 3. 检测任务是否卡住（文件大小长时间不变）
+ * 4. 检测 API 端点是否可用（解析错误信息）
+ * 5. 实时显示任务进度
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+// 配置
+const CHECK_INTERVAL = 2000; // 检查间隔 2 秒
+const STUCK_TIMEOUT = 30000; // 30 秒文件大小不变视为卡住
+const MAX_WAIT_TIME = 300000; // 最多等待 5 分钟
+
+class TaskMonitor {
+  constructor(taskIdOrFile) {
+    this.taskIdOrFile = taskIdOrFile;
+    this.outputFile = this._resolveOutputFile(taskIdOrFile);
+    this.lastSize = 0;
+    this.lastChangeTime = Date.now();
+    this.startTime = Date.now();
+    this.checkCount = 0;
+  }
+
+  _resolveOutputFile(input) {
+    // 如果是完整路径，直接使用
+    if (fs.existsSync(input)) {
+      return input;
+    }
+
+    // 如果是 taskId，构建路径
+    const taskDir = path.join(os.tmpdir(), 'ccs-tasks');
+    const outputFile = path.join(taskDir, `${input}.output`);
+
+    if (fs.existsSync(outputFile)) {
+      return outputFile;
+    }
+
+    // 尝试查找匹配的文件
+    if (fs.existsSync(taskDir)) {
+      const files = fs.readdirSync(taskDir);
+      const matched = files.find(f => f.includes(input) && f.endsWith('.output'));
+      if (matched) {
+        return path.join(taskDir, matched);
+      }
+    }
+
+    return outputFile; // 返回预期路径，即使不存在
+  }
+
+  async monitor() {
+    console.log(`[Monitor] 开始监控任务: ${path.basename(this.outputFile)}`);
+    console.log(`[Monitor] 输出文件: ${this.outputFile}`);
+    console.log('');
+
+    while (true) {
+      this.checkCount++;
+      const elapsed = Date.now() - this.startTime;
+
+      // 超时检查
+      if (elapsed > MAX_WAIT_TIME) {
+        console.log(`\n[超时] 任务执行超过 ${MAX_WAIT_TIME / 1000} 秒，停止监控`);
+        return { status: 'timeout', elapsed };
+      }
+
+      // 文件存在性检查
+      if (!fs.existsSync(this.outputFile)) {
+        console.log(`[等待] 输出文件尚未生成... (${(elapsed / 1000).toFixed(1)}s)`);
+        await this._sleep(CHECK_INTERVAL);
+        continue;
+      }
+
+      // 读取文件内容
+      const stats = fs.statSync(this.outputFile);
+      const currentSize = stats.size;
+
+      // 文件大小变化检查
+      if (currentSize !== this.lastSize) {
+        this.lastSize = currentSize;
+        this.lastChangeTime = Date.now();
+      } else {
+        const stuckTime = Date.now() - this.lastChangeTime;
+        if (stuckTime > STUCK_TIMEOUT && currentSize > 0) {
+          // 文件有内容但长时间不变，可能已完成或卡住
+          const result = this._analyzeOutput();
+          if (result.completed) {
+            console.log(`\n[完成] 任务执行完成 (${(elapsed / 1000).toFixed(1)}s)`);
+            return result;
+          } else {
+            console.log(`\n[警告] 文件大小 ${stuckTime / 1000}s 未变化，可能卡住`);
+          }
+        }
+      }
+
+      // 分析输出内容
+      const result = this._analyzeOutput();
+
+      // 显示进度
+      this._displayProgress(result, elapsed);
+
+      // 检查是否完成
+      if (result.completed) {
+        console.log(`\n[完成] 任务执行完成 (${(elapsed / 1000).toFixed(1)}s)`);
+        return result;
+      }
+
+      // 检查是否有错误
+      if (result.error) {
+        console.log(`\n[错误] 任务执行失败: ${result.error}`);
+        return result;
+      }
+
+      await this._sleep(CHECK_INTERVAL);
+    }
+  }
+
+  _analyzeOutput() {
+    try {
+      const content = fs.readFileSync(this.outputFile, 'utf8');
+      const lines = content.trim().split('\n');
+
+      const result = {
+        completed: false,
+        error: null,
+        sessionId: null,
+        totalCost: null,
+        turns: 0,
+        toolUses: [],
+        lastMessage: null,
+        apiAvailable: true,
+      };
+
+      // 解析每一行 stream-json
+      for (const line of lines) {
+        if (!line.trim()) continue;
+
+        try {
+          const msg = JSON.parse(line);
+
+          // 提取 session_id
+          if (msg.session_id) {
+            result.sessionId = msg.session_id;
+          }
+
+          // 检测初始化消息（说明 API 可用）
+          if (msg.type === 'system' && msg.subtype === 'init') {
+            result.apiAvailable = true;
+          }
+
+          // 检测助手消息
+          if (msg.type === 'assistant' && msg.message) {
+            result.lastMessage = msg.message;
+
+            // 检测完成标志
+            if (msg.message.stop_reason) {
+              result.completed = true;
+            }
+
+            // 提取工具使用
+            if (msg.message.content) {
+              const tools = msg.message.content.filter(c => c.type === 'tool_use');
+              result.toolUses.push(...tools.map(t => t.name));
+            }
+          }
+
+          // 检测用户消息（计算轮次）
+          if (msg.type === 'user') {
+            result.turns++;
+          }
+
+          // 检测成本信息
+          if (msg.type === 'system' && msg.subtype === 'cost') {
+            result.totalCost = msg.total_cost_usd;
+          }
+
+          // 检测错误
+          if (msg.type === 'error' || (msg.message && msg.message.error)) {
+            result.error = msg.error || msg.message.error;
+            result.apiAvailable = false;
+          }
+
+        } catch (parseError) {
+          // 忽略解析错误，可能是不完整的行
+        }
+      }
+
+      // 检测 API 连接错误（通过内容关键词）
+      if (content.includes('ECONNREFUSED') || content.includes('ETIMEDOUT')) {
+        result.error = 'API 端点连接失败';
+        result.apiAvailable = false;
+      }
+
+      if (content.includes('401') || content.includes('Unauthorized')) {
+        result.error = 'API 认证失败';
+        result.apiAvailable = false;
+      }
+
+      if (content.includes('429') || content.includes('rate limit')) {
+        result.error = 'API 速率限制';
+        result.apiAvailable = false;
+      }
+
+      return result;
+
+    } catch (error) {
+      return {
+        completed: false,
+        error: `读取输出文件失败: ${error.message}`,
+        apiAvailable: false,
+      };
+    }
+  }
+
+  _displayProgress(result, elapsed) {
+    const elapsedSec = (elapsed / 1000).toFixed(1);
+    const size = (this.lastSize / 1024).toFixed(1);
+
+    let status = `[进行中] ${elapsedSec}s | ${size}KB`;
+
+    if (result.sessionId) {
+      status += ` | Session: ${result.sessionId.substring(0, 8)}`;
+    }
+
+    if (result.turns > 0) {
+      status += ` | 轮次: ${result.turns}`;
+    }
+
+    if (result.toolUses.length > 0) {
+      const lastTool = result.toolUses[result.toolUses.length - 1];
+      status += ` | 最后工具: ${lastTool}`;
+    }
+
+    if (result.totalCost) {
+      status += ` | 成本: $${result.totalCost.toFixed(4)}`;
+    }
+
+    // 使用 \r 覆盖同一行
+    process.stdout.write(`\r${status}`.padEnd(100));
+  }
+
+  _sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+  }
+}
+
+// 主函数
+async function main() {
+  const args = process.argv.slice(2);
+
+  if (args.length === 0) {
+    console.error('用法: node monitor-task.js <taskId|outputFile>');
+    console.error('');
+    console.error('示例:');
+    console.error('  node monitor-task.js ccs-1770543682008-m9ml7u');
+    console.error('  node monitor-task.js /tmp/ccs-tasks/ccs-1770543682008-m9ml7u.output');
+    process.exit(1);
+  }
+
+  const taskIdOrFile = args[0];
+  const monitor = new TaskMonitor(taskIdOrFile);
+
+  try {
+    const result = await monitor.monitor();
+
+    console.log('\n');
+    console.log('=== 任务结果 ===');
+    console.log(`状态: ${result.completed ? '✓ 完成' : result.error ? '✗ 失败' : '? 未知'}`);
+
+    if (result.error) {
+      console.log(`错误: ${result.error}`);
+    }
+
+    if (result.sessionId) {
+      console.log(`Session ID: ${result.sessionId}`);
+    }
+
+    if (result.turns > 0) {
+      console.log(`执行轮次: ${result.turns}`);
+    }
+
+    if (result.totalCost) {
+      console.log(`总成本: $${result.totalCost.toFixed(4)}`);
+    }
+
+    if (result.toolUses.length > 0) {
+      console.log(`使用的工具: ${[...new Set(result.toolUses)].join(', ')}`);
+    }
+
+    console.log(`API 可用性: ${result.apiAvailable ? '✓ 可用' : '✗ 不可用'}`);
+
+    process.exit(result.completed ? 0 : 1);
+
+  } catch (error) {
+    console.error(`\n[错误] 监控失败: ${error.message}`);
+    process.exit(1);
+  }
+}
+
+main();

package/dist/auth/auth-commands.d.ts

@@ -1,62 +0,0 @@
-/**
- * Auth Commands (Facade)
- *
- * CLI interface for CCS multi-account management.
- * Commands: create, list, show, remove, default, reset-default
- *
- * Login-per-profile model: Each profile is an isolated Claude instance.
- * Users login directly in each instance (no credential copying).
- *
- * Implementation Note: This is a facade that delegates to modular command handlers.
- * See ./commands/ for individual command implementations.
- */
-/**
- * Auth Commands Class (Facade)
- *
- * Maintains class API for backward compatibility while delegating
- * to modular command handlers.
- */
-declare class AuthCommands {
-    private registry;
-    private instanceMgr;
-    private readonly version;
-    constructor();
-    /**
-     * Get command context for handlers
-     */
-    private getContext;
-    /**
-     * Show help for auth commands
-     */
-    showHelp(): Promise<void>;
-    /**
-     * Create new profile - delegates to create-command.ts
-     */
-    handleCreate(args: string[]): Promise<void>;
-    /**
-     * List all profiles - delegates to list-command.ts
-     */
-    handleList(args: string[]): Promise<void>;
-    /**
-     * Show profile details - delegates to show-command.ts
-     */
-    handleShow(args: string[]): Promise<void>;
-    /**
-     * Remove profile - delegates to remove-command.ts
-     */
-    handleRemove(args: string[]): Promise<void>;
-    /**
-     * Set default profile - delegates to default-command.ts
-     */
-    handleDefault(args: string[]): Promise<void>;
-    /**
-     * Reset default profile - delegates to default-command.ts
-     */
-    handleResetDefault(): Promise<void>;
-    /**
-     * Route auth command to appropriate handler
-     */
-    route(args: string[]): Promise<void>;
-}
-export default AuthCommands;
-//# sourceMappingURL=auth-commands.d.ts.map

package/dist/auth/auth-commands.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"auth-commands.d.ts","sourceRoot":"","sources":["../../src/auth/auth-commands.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAkBH;;;;;GAKG;AACH,cAAM,YAAY;IAChB,OAAO,CAAC,QAAQ,CAAkB;IAClC,OAAO,CAAC,WAAW,CAAkB;IACrC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA+B;;IAOvD;;OAEG;IACH,OAAO,CAAC,UAAU;IAQlB;;OAEG;IACG,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;IA0D/B;;OAEG;IACG,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAIjD;;OAEG;IACG,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAI/C;;OAEG;IACG,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAI/C;;OAEG;IACG,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAIjD;;OAEG;IACG,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAIlD;;OAEG;IACG,kBAAkB,IAAI,OAAO,CAAC,IAAI,CAAC;IAIzC;;OAEG;IACG,KAAK,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;CAsE3C;AAED,eAAe,YAAY,CAAC"}