ai-stream-tee 1.3.0

package/dist/agents/base.js

@@ -0,0 +1,60 @@
+import cp from 'node:child_process';
+import { inspect } from 'node:util';
+import { log } from '../log.js';
+export class BaseAgent {
+    exec;
+    args;
+    constructor(exec, args) {
+        this.exec = exec;
+        this.args = args;
+    }
+    execute(client, { execPath }) {
+        const child_process = cp.spawn(execPath ?? this.exec, this.args, {
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        child_process.stdout
+            .on('data', (data) => {
+            client.put(data);
+            const output = data.toString('utf-8');
+            output.split('\n').forEach(line => {
+                if (line.trim()) {
+                    this.handleLine(line);
+                }
+            });
+        })
+            .on('end', () => {
+            client.stop(false, 'stdout end');
+        })
+            .on('error', (err) => {
+            client.stop(true, `stdout error: ${err.message}`);
+        });
+        child_process.stderr.pipe(process.stderr, { end: false });
+        child_process
+            .on('error', async (err) => {
+            log('ERROR', `failed to spawn claude code: ${inspect(err)}`);
+            client.stop(true, `spawn error: ${err.message}`);
+            process.exit(1);
+        })
+            .on('close', (code, signal) => {
+            if (code != null) {
+                this.handleClose(code);
+                if (code === 0) {
+                    log('INFO', `${this.exec} close with code ${code}`);
+                }
+                else {
+                    log('ERROR', `${this.exec} close with code ${code}`);
+                }
+                process.exitCode = code;
+            }
+            else {
+                log('ERROR', `${this.exec} close with signal: ${signal}`);
+                process.exitCode = -1;
+            }
+            client.wait()
+                .finally(() => {
+                process.exit();
+            });
+        });
+        return child_process;
+    }
+}

package/dist/agents/claude.js

@@ -0,0 +1,37 @@
+import { BaseAgent } from './base.js';
+export class Claude extends BaseAgent {
+    constructor(args) {
+        super('claude', ['-p', '--output-format', 'stream-json', '--include-partial-messages', '--verbose', ...args]);
+    }
+    result;
+    handleLine(line) {
+        try {
+            const chunk = JSON.parse(line);
+            if (chunk.type === 'result') {
+                this.result = chunk;
+            }
+        }
+        catch {
+        }
+    }
+    handleClose(code) {
+        const result = this.result;
+        if (result) {
+            if (result.subtype === 'success') {
+                if (result.is_error) {
+                    // Force exit with error
+                    process.stderr.write(result.result + '\n');
+                }
+                else {
+                    process.stdout.write(result.result + '\n');
+                }
+            }
+            else {
+                process.stderr.write(result.subtype + '\n');
+            }
+        }
+        else {
+            process.stderr.write(`claude code exit (${code}) with no result message.`);
+        }
+    }
+}

package/dist/agents/codex.js

@@ -0,0 +1,41 @@
+import { BaseAgent } from './base.js';
+export class Codex extends BaseAgent {
+    final_message;
+    final_turn_failed;
+    constructor(args) {
+        super('codex', ['exec', '--json', ...args]);
+    }
+    handleLine(line) {
+        try {
+            const chunk = JSON.parse(line);
+            if (chunk.type === 'item.completed') {
+                if (chunk.item.type === 'agent_message') {
+                    this.final_message = chunk.item;
+                }
+            }
+            if (chunk.type === 'turn.failed') {
+                this.final_turn_failed = chunk;
+            }
+        }
+        catch {
+        }
+    }
+    handleClose(code) {
+        if (code === 0) {
+            if (this.final_message) {
+                process.stdout.write(this.final_message.text + '\n');
+            }
+            else {
+                process.stdout.write('No final message.\n');
+            }
+        }
+        else {
+            if (this.final_turn_failed) {
+                process.stderr.write(this.final_turn_failed.error.message + '\n');
+            }
+            else {
+                process.stderr.write(`codex exit (${code}) with no error result.\n`);
+            }
+        }
+    }
+}

package/dist/agents/pantheon-tdd.js

@@ -0,0 +1,36 @@
+import { BaseAgent } from './base.js';
+export class PantheonTdd extends BaseAgent {
+    final_item;
+    constructor(args) {
+        super('dev-agent', ['--headless', '--stream-json', ...args]);
+    }
+    handleLine(line) {
+        try {
+            const chunk = JSON.parse(line);
+            if (chunk.type === 'thread.completed') {
+                this.final_item = chunk;
+            }
+        }
+        catch {
+        }
+    }
+    handleClose(code) {
+        if (code === 0) {
+            if (this.final_item) {
+                if (this.final_item.status === 'error') {
+                    process.stderr.write(this.final_item.summary);
+                    process.exitCode = 1;
+                }
+                else {
+                    process.stdout.write(JSON.stringify(this.final_item.final_report, undefined, 2) + '\n');
+                }
+            }
+            else {
+                process.stdout.write('No final item.\n');
+            }
+        }
+        else {
+            process.stderr.write(`tdd exit (${code}).\n`);
+        }
+    }
+}

package/dist/agents/pantheon.js

@@ -0,0 +1,51 @@
+import { BaseAgent } from './base.js';
+export class PantheonAgent extends BaseAgent {
+    final_item;
+    constructor(subAgent, args) {
+        super(subAgent, ['--headless', '--stream-json', ...args]);
+    }
+    handleLine(line) {
+        try {
+            const chunk = JSON.parse(line);
+            if (chunk.type === 'thread.completed') {
+                this.final_item = chunk;
+            }
+        }
+        catch {
+        }
+    }
+    handleClose(code) {
+        if (code === 0) {
+            if (this.final_item) {
+                if (this.final_item.status === 'error') {
+                    process.stderr.write(this.final_item.summary);
+                    process.exitCode = 1;
+                }
+                else {
+                    process.stdout.write(JSON.stringify(this.final_item.final_report, undefined, 2) + '\n');
+                }
+            }
+            else {
+                process.stdout.write('No final item.\n');
+            }
+        }
+        else {
+            process.stderr.write(`tdd exit (${code}).\n`);
+        }
+    }
+    static determineSubAgent(name) {
+        switch (name) {
+            case 'dev':
+            case 'tdd':
+            case 'pantheon-tdd':
+            case 'dev-agent':
+                return 'dev-agent';
+            case 'review':
+            case 'pantheon-review':
+            case 'review-agent':
+                return 'review';
+            default:
+                throw new Error(`Invalid pantheon agent ${name}`);
+        }
+    }
+}

package/dist/agents/qwen.js

@@ -0,0 +1,70 @@
+import { BaseAgent } from './base.js';
+export class Qwen extends BaseAgent {
+    constructor(args) {
+        // Qwen Code CLI arguments
+        super('qwen', ['--output-format', 'stream-json', ...args]);
+    }
+    lastContent = '';
+    usage;
+    hasError = false;
+    handleLine(line) {
+        try {
+            const chunk = JSON.parse(line);
+            switch (chunk.type) {
+                case 'content':
+                    if (chunk.content) {
+                        this.lastContent += chunk.content;
+                        // Forward content to stdout for streaming
+                        process.stdout.write(JSON.stringify({
+                            type: 'content',
+                            content: chunk.content,
+                        }) + '\n');
+                    }
+                    break;
+                case 'finish':
+                    this.usage = chunk.usage;
+                    // Forward finish event
+                    process.stdout.write(JSON.stringify({
+                        type: 'finish',
+                        reason: chunk.reason,
+                        usage: chunk.usage,
+                    }) + '\n');
+                    break;
+                case 'error':
+                    this.hasError = true;
+                    // Forward error event
+                    process.stderr.write(JSON.stringify({
+                        type: 'error',
+                        error: chunk.error,
+                        message: chunk.message,
+                    }) + '\n');
+                    break;
+            }
+        }
+        catch (e) {
+            // If parsing fails, treat as plain text output
+            if (line.trim()) {
+                this.lastContent += line + '\n';
+                process.stdout.write(JSON.stringify({
+                    type: 'content',
+                    content: line,
+                }) + '\n');
+            }
+        }
+    }
+    handleClose(code) {
+        const exitEvent = {
+            type: 'finish',
+            reason: this.hasError ? 'error' : 'stop',
+            exit_code: code,
+            usage: this.usage,
+        };
+        process.stdout.write(JSON.stringify(exitEvent) + '\n');
+        if (this.hasError || code !== 0) {
+            process.stderr.write(`qwen code exited with code ${code}\n`);
+            if (this.lastContent) {
+                process.stderr.write(`Last output: ${this.lastContent.slice(0, 500)}\n`);
+            }
+        }
+    }
+}

package/dist/client.js

@@ -0,0 +1,173 @@
+import { inspect } from 'node:util';
+import { Agent, Dispatcher, fetch } from 'undici';
+import { log } from './log.js';
+export class StreamClient {
+    streamServerUrl;
+    streamServerToken;
+    streamId;
+    streamMessageId;
+    contentType;
+    buf = [];
+    chunks = [];
+    finalPending = [];
+    agent;
+    cursor = 0;
+    headers = {};
+    init;
+    initialized = false;
+    heartbeatTimeout;
+    failed = false;
+    constructor(streamServerUrl, streamServerToken, streamId, streamMessageId, contentType) {
+        this.streamServerUrl = streamServerUrl;
+        this.streamServerToken = streamServerToken;
+        this.streamId = streamId;
+        this.streamMessageId = streamMessageId;
+        this.contentType = contentType;
+        this.agent = new Agent();
+        if (streamServerToken) {
+            this.headers['Authorization'] = `Bearer ${streamServerToken}`;
+        }
+        this.scheduleHeartbeat();
+        this.init = retryIfFailed('init stream', async () => {
+            await fetch(`${this.streamServerUrl}/v2/streams`, {
+                method: 'POST',
+                headers: {
+                    ...this.headers,
+                    'Content-Type': 'application/json',
+                },
+                dispatcher: this.agent,
+                body: JSON.stringify({
+                    stream_id: streamId,
+                    message_id: streamMessageId ?? streamId,
+                    content_type: contentType,
+                }),
+            }).then(handleResponse('init stream'));
+        })
+            .then(() => {
+            this.initialized = true;
+            this.buf.forEach(chunk => this.put(chunk));
+            this.buf = [];
+        })
+            .catch(() => {
+            this.failed = true;
+            this.cancelHeartbeat();
+        });
+    }
+    cancelHeartbeat() {
+        clearTimeout(this.heartbeatTimeout);
+    }
+    scheduleHeartbeat() {
+        clearTimeout(this.heartbeatTimeout);
+        this.heartbeatTimeout = setTimeout(() => {
+            fetch(`${this.streamServerUrl}/v2/streams/${encodeURIComponent(this.streamId)}/actions/heartbeat`, {
+                method: 'POST',
+                headers: {
+                    ...this.headers,
+                },
+                dispatcher: this.agent,
+                keepalive: true,
+            }).catch(() => { })
+                .finally(() => {
+                this.scheduleHeartbeat();
+            });
+        }, 5000);
+    }
+    async wait() {
+        await this.init;
+        if (this.failed) {
+            return;
+        }
+        const chunks = this.chunks;
+        this.chunks = [];
+        await Promise.allSettled(chunks);
+        if (this.chunks.length > 0) {
+            await this.wait();
+        }
+        else {
+            await Promise.allSettled(this.finalPending.map(fp => fp()));
+        }
+    }
+    put(data) {
+        if (this.failed) {
+            return;
+        }
+        if (!this.initialized) {
+            this.buf.push(data);
+            return;
+        }
+        const range = `bytes ${this.cursor}-${this.cursor + data.length - 1}`;
+        this.cursor += data.length;
+        this.chunks.push(retryIfFailed(`send range ${range}`, async () => {
+            await fetch(`${this.streamServerUrl}/v2/streams/${encodeURIComponent(this.streamId)}/content`, {
+                method: 'PUT',
+                headers: {
+                    ...this.headers,
+                    'X-Content-Range': range,
+                },
+                body: data,
+                dispatcher: this.agent,
+                keepalive: true,
+            }).then(handleResponse('put data'));
+        }).catch(() => {
+            this.stop(true, 'failed to send data');
+            this.failed = true;
+            this.cancelHeartbeat();
+        }).finally(() => {
+            if (!this.failed) {
+                this.scheduleHeartbeat();
+            }
+        }));
+    }
+    stop(abort, reason) {
+        this.init.then(() => {
+            if (this.failed) {
+                return;
+            }
+            log('INFO', `${abort ? 'abort' : 'stop'} stream ${this.cursor}: ${reason}\n`);
+            this.cancelHeartbeat();
+            this.finalPending.push(() => retryIfFailed(`end stream`, async () => {
+                await fetch(`${this.streamServerUrl}/v2/streams/${encodeURIComponent(this.streamId)}/actions/stop`, {
+                    method: 'POST',
+                    headers: {
+                        ...this.headers,
+                        'Content-Type': 'application/json',
+                    },
+                    body: JSON.stringify({
+                        stop_state: abort ? 'abort' : 'done',
+                        stop_reason: reason,
+                        final_size: this.cursor,
+                    }),
+                    dispatcher: this.agent,
+                    keepalive: true,
+                }).then(handleResponse('stop stream'));
+            }));
+        });
+    }
+}
+function handleResponse(action) {
+    return async (res) => {
+        if (!res.ok) {
+            throw new Error(`failed to ${action}: ${res.status} ${await res.text().catch(() => res.statusText)}`);
+        }
+    };
+}
+async function retryIfFailed(action, cb, times = 3) {
+    let attempt = 0;
+    for (let i = 0; i < times; i++) {
+        try {
+            await cb();
+            return;
+        }
+        catch (e) {
+            attempt++;
+            if (attempt < times) {
+                log('WARN', `failed to ${action}, retrying after 1 second... (${attempt}/${times}) ${inspect(e)}`);
+                await new Promise(resolve => setTimeout(resolve, 1000));
+            }
+            else {
+                log('ERROR', `failed to ${action}, giving up. (${attempt}/${times}) ${inspect(e)}`);
+                throw e;
+            }
+        }
+    }
+}

package/dist/index.js

@@ -0,0 +1,67 @@
+#!/usr/bin/env node
+import { program } from 'commander';
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { Claude } from './agents/claude.js';
+import { Codex } from './agents/codex.js';
+import { PantheonTdd } from './agents/pantheon-tdd.js';
+import { PantheonAgent } from './agents/pantheon.js';
+import { Qwen } from './agents/qwen.js';
+import { StreamClient } from './client.js';
+import { log, setSilent } from './log.js';
+const packageJsonDir = path.resolve(fileURLToPath(import.meta.url), '../../package.json');
+const VERSION = JSON.parse(fs.readFileSync(packageJsonDir, 'utf-8')).version;
+const command = program
+    .version(VERSION)
+    .argument('<agent>', '`claude` or `codex`')
+    .requiredOption('--stream-server-url <string>', 'ai stream proxy server url e.g. http://localhost:8888.')
+    .requiredOption('--stream-id <string>', 'stream id for this agent execution.')
+    .option('--stream-message-id <string>', 'message id for this agent execution. Default to stream-id.')
+    .option('--stream-protocol <string>', 'v2', 'v2')
+    .option('--stream-server-token <string>', 'auth token')
+    .option('--exec-path <string>', 'path to agent executable. Default to standard agent name in PATH.')
+    .option('--suppress-logs', 'suppress all logs except for errors.', false)
+    .allowUnknownOption()
+    .allowExcessArguments()
+    .action(async function (action, options) {
+    const { operands, unknown } = this.parseOptions(process.argv.slice(2));
+    const { streamServerUrl, streamServerToken, streamId, streamMessageId, execPath, suppressLogs, } = options;
+    if (suppressLogs) {
+        setSilent(true);
+    }
+    log('INFO', VERSION);
+    const [agent, ...restOperands] = operands;
+    let a;
+    let contentType;
+    switch (agent) {
+        case 'claude':
+            a = new Claude([...unknown, ...restOperands]);
+            contentType = 'claude-code-stream-json+include-partial-messages';
+            break;
+        case 'codex':
+            a = new Codex([...unknown, ...restOperands]);
+            contentType = 'codex-stream-json';
+            break;
+        case 'pantheon-tdd':
+            a = new PantheonTdd([...unknown, ...restOperands]);
+            contentType = 'pantheon-tdd-stream-json';
+            log('WARN', 'pantheon-tdd is deprecated, use code-tee pantheon dev');
+            break;
+        case 'pantheon': {
+            const [subAgent, ...otherOperands] = restOperands;
+            a = new PantheonAgent(PantheonAgent.determineSubAgent(subAgent), [...unknown, ...otherOperands]);
+            contentType = 'pantheon-agent-stream-json';
+            break;
+        }
+        case 'qwen':
+            a = new Qwen([...unknown, ...restOperands]);
+            contentType = 'qwen-stream-json';
+            break;
+        default:
+            log('ERROR', `unknown agent ${agent}`);
+            process.exit(1);
+    }
+    a.execute(new StreamClient(streamServerUrl, streamServerToken, streamId, streamMessageId, contentType), { execPath });
+});
+command.parse();

package/dist/log.js

@@ -0,0 +1,12 @@
+let silentMode = false;
+export function setSilent(silent) {
+    silentMode = true;
+}
+export function log(level, str) {
+    if (silentMode) {
+        if (level === 'INFO' || level === 'WARN') {
+            return;
+        }
+    }
+    process.stderr.write(`[code-tee ${Date.now()} ${level.padStart(5, ' ')}]: ${str}\n`);
+}

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "ai-stream-tee",
+  "version": "1.3.0",
+  "description": "Multi-agent CLI wrapper with Qwen support",
+  "main": "dist/index.js",
+  "type": "module",
+  "scripts": {
+    "build": "tsc"
+  },
+  "dependencies": {
+    "commander": "^14.0.0",
+    "undici": "^7.16.0"
+  },
+  "bin": {
+    "ai-stream-tee": "./dist/index.js"
+  },
+  "files": [
+    "readme.md",
+    "dist"
+  ],
+  "engines": {
+    "node": ">=22.14.0"
+  },
+  "devDependencies": {
+    "@anthropic-ai/claude-code": "^1.0.128",
+    "@openai/codex": "^0.60.1",
+    "@openai/codex-sdk": "^0.60.1",
+    "@types/node": "^22.18.0",
+    "pantheon-tdd-sdk": "^1.0.0",
+    "typescript": "^5.9.2"
+  }
+}

package/readme.md

@@ -0,0 +1,16 @@
+## Usage
+
+```shell
+# Claude Code
+code-tee \                                                                                                                  
+    --stream-server-url "http://127.0.0.1:3000" \
+    --stream-id "my-magic-stream-id" \
+    --stream-message-id "my-magic-stream-message-id" \
+    claude "Hi"
+
+# Codex
+code-tee \                                                                                                                  
+    --target-url "http://127.0.0.1:3000" \
+    --stream-id "my-magic-stream-id" \
+    codex "Hi"
+```