@getforgeai/cli 0.1.0-beta.1

package/dist/orchestrator/stream-json-extractor.js

@@ -0,0 +1,579 @@
+import { vmLog } from "../vm/log.js";
+/**
+ * Extracts text deltas from Claude Code's `--output-format stream-json` output.
+ *
+ * With `--include-partial-messages`, Claude emits newline-delimited JSON objects.
+ * Text tokens arrive as `stream_event` objects with `event.delta.type === "text_delta"`.
+ *
+ * Official filter pattern (from docs):
+ *   select(.type == "stream_event" and .event.delta.type? == "text_delta") | .event.delta.text
+ *
+ * This extractor also handles:
+ * - `assistant` snapshot messages containing AskUserQuestion tool_use blocks:
+ *   extracts the question text and emits it so the wizard chat user can see it.
+ *   When `onQuestion` is provided, emits structured data instead of formatted text.
+ * - Ignores: thinking, other tool_use, system events, rate limits, etc.
+ */
+/** Tools we extract activity from, with their detail extractor. */
+const TOOL_DETAIL_EXTRACTORS = {
+    Read: (input) => truncateEnd(input.file_path, 60),
+    Edit: (input) => truncateEnd(input.file_path, 60),
+    Write: (input) => truncateEnd(input.file_path, 60),
+    Bash: (input) => {
+        const cmd = input.command;
+        if (!cmd)
+            return null;
+        const firstLine = cmd.split("\n")[0] ?? cmd;
+        return firstLine.length > 80 ? firstLine.slice(0, 77) + "..." : firstLine;
+    },
+    Grep: (input) => {
+        const pattern = input.pattern;
+        if (!pattern)
+            return null;
+        const truncated = pattern.length > 40 ? pattern.slice(0, 37) + "..." : pattern;
+        return `"${truncated}"`;
+    },
+    Glob: (input) => {
+        const pattern = input.pattern;
+        if (!pattern)
+            return null;
+        return pattern.length > 60 ? pattern.slice(0, 57) + "..." : pattern;
+    },
+    WebFetch: (input) => {
+        const url = input.url;
+        if (!url)
+            return null;
+        return url.length > 60 ? url.slice(0, 57) + "..." : url;
+    },
+    WebSearch: (input) => {
+        const query = input.query;
+        if (!query)
+            return null;
+        return query.length > 60 ? query.slice(0, 57) + "..." : query;
+    },
+    Agent: (input) => {
+        const description = input.description;
+        if (!description)
+            return null;
+        return description.length > 60
+            ? description.slice(0, 57) + "..."
+            : description;
+    },
+    // ForgeAI MCP tools
+    forge_create_task_group: (input) => truncateStart(input.name, 60),
+    forge_add_group_dependency: (input) => {
+        const blocking = input.blockingGroupName;
+        const blocked = input.blockedGroupName;
+        if (blocking && blocked)
+            return `${blocking} → ${blocked}`;
+        return blocking ?? blocked ?? null;
+    },
+    forge_create_task: (input) => truncateStart(input.title, 60),
+    forge_add_task_dependency: (input) => {
+        const blocking = input.blockingTaskTitle;
+        const blocked = input.blockedTaskTitle;
+        if (blocking && blocked)
+            return `${blocking} → ${blocked}`;
+        return blocking ?? blocked ?? null;
+    },
+    forge_complete_step: (input) => {
+        const deliverables = input.deliverables;
+        if (Array.isArray(deliverables))
+            return `${deliverables.length} deliverables`;
+        return null;
+    },
+    forge_get_task: () => null,
+    forge_update_status: (input) => input.status ?? null,
+    forge_ask_human: (input) => truncateStart(input.question, 60),
+    forge_requeue: (input) => truncateStart(input.reason, 60),
+    forge_column_done: (input) => truncateStart(input.taskId, 60),
+};
+function truncateEnd(value, maxLen) {
+    if (!value)
+        return null;
+    if (value.length <= maxLen)
+        return value;
+    return "..." + value.slice(-(maxLen - 3));
+}
+function truncateStart(value, maxLen) {
+    if (!value)
+        return null;
+    if (value.length <= maxLen)
+        return value;
+    return value.slice(0, maxLen - 3) + "...";
+}
+export class StreamJsonExtractor {
+    onText;
+    lineBuf = "";
+    /** Track which tool_use IDs we've already emitted (questions + activity). */
+    emittedToolUseIds = new Set();
+    /** Track which system event UUIDs we've already processed (sub-agent progress). */
+    emittedSystemUuids = new Set();
+    /** Incremented on each message_start — groups text from the same API turn. */
+    turnIndex = 0;
+    onQuestion;
+    onToolActivity;
+    onTokenUsage;
+    inputTokens = 0;
+    outputTokens = 0;
+    /** Error text from the last `type: "result"` event with `is_error: true`. */
+    lastError = null;
+    /** Session ID for log context (optional). */
+    sessionId;
+    constructor(onText, onQuestion, onToolActivity, onTokenUsage, sessionId) {
+        this.onText = onText;
+        this.onQuestion = onQuestion;
+        this.onToolActivity = onToolActivity;
+        this.onTokenUsage = onTokenUsage;
+        this.sessionId = sessionId;
+    }
+    write(data) {
+        this.lineBuf += data;
+        // Process complete lines (newline-delimited JSON)
+        let newlineIdx;
+        while ((newlineIdx = this.lineBuf.indexOf("\n")) !== -1) {
+            const line = this.lineBuf.slice(0, newlineIdx).trim();
+            this.lineBuf = this.lineBuf.slice(newlineIdx + 1);
+            if (line)
+                this.parseLine(line);
+        }
+    }
+    /** Flush any remaining partial line on process exit. */
+    flush() {
+        const line = this.lineBuf.trim();
+        this.lineBuf = "";
+        if (line)
+            this.parseLine(line);
+    }
+    parseLine(line) {
+        try {
+            const obj = JSON.parse(line);
+            const objType = obj.type;
+            switch (objType) {
+                case "stream_event":
+                    this.handleStreamEvent(obj);
+                    break;
+                case "assistant":
+                    this.handleAssistantSnapshot(obj);
+                    break;
+                case "result":
+                    this.handleResult(obj);
+                    break;
+                case "system":
+                    this.handleSystemEvent(obj);
+                    break;
+            }
+        }
+        catch {
+            // Not valid JSON — skip (could be stderr leaking into stdout)
+            vmLog.dim("stream-json", "Non-JSON line skipped", this.sessionId);
+        }
+    }
+    handleMessageStart(event) {
+        this.turnIndex++;
+        const message = event.message;
+        const usage = message?.usage;
+        const inputTokens = this.calculateInputTokens(usage);
+        vmLog.dim("stream-json", `message_start: turnIndex=${this.turnIndex}, input_tokens=${inputTokens}, raw=${JSON.stringify(usage)}, onTokenUsage=${!!this.onTokenUsage}`, this.sessionId);
+        if (inputTokens > 0 && this.onTokenUsage) {
+            this.inputTokens += inputTokens;
+            this.onTokenUsage({
+                inputTokens: this.inputTokens,
+                outputTokens: this.outputTokens,
+            });
+        }
+    }
+    calculateInputTokens(usage) {
+        return ((typeof usage?.input_tokens === "number" ? usage.input_tokens : 0) +
+            (typeof usage?.cache_creation_input_tokens === "number"
+                ? usage.cache_creation_input_tokens
+                : 0) +
+            (typeof usage?.cache_read_input_tokens === "number"
+                ? usage.cache_read_input_tokens
+                : 0));
+    }
+    handleContentBlockStart(event) {
+        const contentBlock = event.content_block;
+        if (contentBlock?.type === "compaction") {
+            vmLog.dim("stream-json", "compaction block started", this.sessionId);
+            this.onToolActivity?.({
+                toolName: "Compaction",
+                toolDetail: "Summarizing conversation context...",
+            });
+        }
+    }
+    handleMessageDelta(event) {
+        const usage = event.usage;
+        const outputTokens = usage?.output_tokens;
+        const outputTokensDisplay = typeof outputTokens === "number" ? String(outputTokens) : "N/A";
+        vmLog.dim("stream-json", `message_delta: output_tokens=${outputTokensDisplay}, onTokenUsage=${!!this.onTokenUsage}`, this.sessionId);
+        if (typeof outputTokens === "number" && this.onTokenUsage) {
+            this.outputTokens += outputTokens;
+            this.onTokenUsage({
+                inputTokens: this.inputTokens,
+                outputTokens: this.outputTokens,
+            });
+        }
+    }
+    handleStreamEvent(obj) {
+        const event = obj.event;
+        if (!event)
+            return;
+        const eventType = event.type;
+        if (eventType === "message_start") {
+            this.handleMessageStart(event);
+            return;
+        }
+        if (eventType === "content_block_start") {
+            this.handleContentBlockStart(event);
+            return;
+        }
+        if (eventType === "message_delta") {
+            this.handleMessageDelta(event);
+            return;
+        }
+        const delta = event.delta;
+        if (!delta)
+            return;
+        if (delta.type === "text_delta" && typeof delta.text === "string") {
+            this.onText(delta.text);
+        }
+    }
+    /**
+     * Handle `type: "result"` event — contains final usage stats.
+     * Used as fallback if message_start/message_delta didn't provide usage.
+     */
+    handleResult(obj) {
+        const result = obj.result;
+        if (!result)
+            return;
+        // Capture error text from result events (e.g. API billing errors)
+        // Structure: { type: "result", result: { is_error: true, error: "..." } }
+        // Fallback: error text may also be in result as a string (older formats)
+        if (result.is_error === true) {
+            if (typeof result.error === "string") {
+                this.lastError = result.error;
+            }
+            else if (typeof result.result === "string") {
+                this.lastError = result.result;
+            }
+        }
+        if (!this.onTokenUsage)
+            return;
+        const usage = result.usage;
+        if (!usage)
+            return;
+        // Include cache tokens for accurate input count
+        const rawInput = typeof usage.input_tokens === "number" ? usage.input_tokens : 0;
+        const cacheCreation = typeof usage.cache_creation_input_tokens === "number"
+            ? usage.cache_creation_input_tokens
+            : 0;
+        const cacheRead = typeof usage.cache_read_input_tokens === "number"
+            ? usage.cache_read_input_tokens
+            : 0;
+        const totalInput = rawInput + cacheCreation + cacheRead;
+        const outputTokens = usage.output_tokens;
+        if (totalInput > 0)
+            this.inputTokens = totalInput;
+        if (typeof outputTokens === "number")
+            this.outputTokens = outputTokens;
+        this.onTokenUsage({
+            inputTokens: this.inputTokens,
+            outputTokens: this.outputTokens,
+        });
+    }
+    handleAskUserQuestion(blockId, questions) {
+        this.emittedToolUseIds.add(blockId);
+        if (this.onQuestion) {
+            const structured = this.extractStructuredQuestions(questions);
+            if (structured.length > 0) {
+                this.onQuestion(structured);
+            }
+        }
+        else {
+            const formatted = this.formatQuestions(questions);
+            if (formatted) {
+                this.onText(formatted);
+            }
+        }
+    }
+    handleToolActivity(blockId, name, input) {
+        if (!this.onToolActivity)
+            return;
+        const extractor = TOOL_DETAIL_EXTRACTORS[name];
+        const detail = extractor && input ? extractor(input) : null;
+        if (detail !== null || !extractor) {
+            this.emittedToolUseIds.add(blockId);
+            const toolUseId = name === "Agent" ? blockId : undefined;
+            this.onToolActivity({
+                toolName: name,
+                toolDetail: detail ?? name,
+                toolUseId,
+            });
+        }
+    }
+    isValidToolUseBlock(block) {
+        if (block.type !== "tool_use")
+            return false;
+        if (typeof block.id !== "string")
+            return false;
+        if (this.emittedToolUseIds.has(block.id))
+            return false;
+        return true;
+    }
+    /**
+     * Handle `type: "assistant"` snapshot messages.
+     * These contain cumulative content blocks after streaming completes for each block.
+     * We extract AskUserQuestion tool_use blocks and format questions as readable text.
+     */
+    handleAssistantSnapshot(obj) {
+        const message = obj.message;
+        if (!message)
+            return;
+        const content = message.content;
+        if (!Array.isArray(content))
+            return;
+        for (const block of content) {
+            if (!this.isValidToolUseBlock(block))
+                continue;
+            const blockId = block.id;
+            const name = block.name;
+            if (!name)
+                continue;
+            const input = block.input;
+            if (name === "AskUserQuestion") {
+                if (!input)
+                    continue;
+                const questions = input.questions;
+                if (!Array.isArray(questions) || questions.length === 0)
+                    continue;
+                this.handleAskUserQuestion(blockId, questions);
+                continue;
+            }
+            this.handleToolActivity(blockId, name, input);
+        }
+    }
+    /**
+     * Handle `type: "system"` events — sub-agent progress updates.
+     * System events with `last_tool_name` + `tool_use_id` represent tools used by sub-agents.
+     * `tool_use_id` references the parent Agent tool_use block id.
+     */
+    handleSystemEvent(obj) {
+        if (!this.onToolActivity)
+            return;
+        const toolUseId = obj.tool_use_id;
+        const uuid = obj.uuid;
+        if (!toolUseId)
+            return;
+        // Deduplicate by uuid
+        if (uuid && this.emittedSystemUuids.has(uuid))
+            return;
+        if (uuid)
+            this.emittedSystemUuids.add(uuid);
+        const lastToolName = obj.last_tool_name;
+        const status = obj.status;
+        // Agent completion event (has status, no last_tool_name)
+        if (status && !lastToolName) {
+            this.onToolActivity({
+                toolName: "__agent_complete__",
+                toolDetail: "",
+                parentToolUseId: toolUseId,
+            });
+            return;
+        }
+        // Sub-agent progress event (has last_tool_name)
+        if (!lastToolName)
+            return;
+        const description = obj.description;
+        let detail;
+        if (!description) {
+            detail = lastToolName;
+        }
+        else if (description.length > 60) {
+            detail = description.slice(0, 57) + "...";
+        }
+        else {
+            detail = description;
+        }
+        this.onToolActivity({
+            toolName: lastToolName,
+            toolDetail: detail,
+            parentToolUseId: toolUseId,
+        });
+    }
+    extractStructuredQuestions(questions) {
+        const result = [];
+        for (const q of questions) {
+            const question = q.question;
+            if (!question)
+                continue;
+            const data = { question };
+            if (typeof q.header === "string") {
+                data.header = q.header;
+            }
+            if (typeof q.multiSelect === "boolean") {
+                data.multiSelect = q.multiSelect;
+            }
+            const options = q.options;
+            if (Array.isArray(options)) {
+                data.options = options
+                    .filter((opt) => typeof opt.label === "string")
+                    .map((opt) => ({
+                    label: opt.label,
+                    ...(typeof opt.description === "string"
+                        ? { description: opt.description }
+                        : {}),
+                }));
+            }
+            result.push(data);
+        }
+        return result;
+    }
+    formatOptionLine(label, description) {
+        if (!label)
+            return null;
+        return description ? `- ${label}: ${description}` : `- ${label}`;
+    }
+    formatQuestionOptions(options) {
+        if (!Array.isArray(options))
+            return [];
+        const lines = [];
+        for (const opt of options) {
+            const label = opt.label;
+            const desc = opt.description;
+            const line = this.formatOptionLine(label, desc);
+            if (line)
+                lines.push(line);
+        }
+        return lines;
+    }
+    formatQuestions(questions) {
+        const parts = [];
+        for (const q of questions) {
+            const question = q.question;
+            if (!question)
+                continue;
+            parts.push(`\n${question}`);
+            const options = q.options;
+            parts.push(...this.formatQuestionOptions(options));
+        }
+        return parts.length > 0 ? "\n" + parts.join("\n") + "\n" : "";
+    }
+    // --- Billing / token error detection ---
+    static BILLING_PATTERNS = [
+        /credit.{0,20}balance/i,
+        /insufficient.{0,20}(?:credit|fund|balance|quota)/i,
+        /exceed.{0,20}(?:quota|budget|limit)/i,
+        /usage.{0,20}limit.{0,20}reached/i,
+        /limit.{0,20}(?:will )?reset/i,
+        /(?:hit|reached).{0,10}(?:your )?limit/i,
+        /billing/i,
+        /payment.{0,20}(?:required|failed|method)/i,
+        /account.{0,20}(?:suspended|deactivated)/i,
+        /out of (?:credit|token)/i,
+    ];
+    /**
+     * Check if the captured error (from result event or accumulated stderr)
+     * indicates a billing/token exhaustion issue.
+     * Optionally accepts extra text (e.g. stderr buffer) to scan.
+     */
+    isBillingError(extraText) {
+        const texts = [this.lastError, extraText].filter(Boolean);
+        return texts.some((text) => StreamJsonExtractor.BILLING_PATTERNS.some((re) => re.test(text)));
+    }
+    /**
+     * Extract the usage-limit reset timestamp from error text.
+     * Handles multiple formats:
+     *   - "reset at 2026-03-08T15:00:00+00:00" (ISO datetime)
+     *   - "resets 7pm (Europe/Paris)" (time + timezone)
+     *   - "resets in 2 hours" (relative duration)
+     * Returns an ISO string if a valid future timestamp is found, otherwise null.
+     */
+    extractResetTimestamp(extraText) {
+        const texts = [this.lastError, extraText].filter(Boolean);
+        for (const text of texts) {
+            // Pattern 1: "reset at <ISO datetime>"
+            const isoMatch = /reset\s+at\s+(.+?)(?:\.|$)/i.exec(text);
+            if (isoMatch) {
+                const dateStr = isoMatch[1].trim();
+                const parsed = new Date(dateStr);
+                if (!Number.isNaN(parsed.getTime()) && parsed.getTime() > Date.now()) {
+                    return parsed.toISOString();
+                }
+            }
+            // Pattern 2: "resets 7pm (Europe/Paris)" or "resets 19:00 (Europe/Paris)"
+            const tzMatch = /resets?\s+(\d{1,2})(?::(\d{2}))?\s*(am|pm)?\s*\(([^)]+)\)/i.exec(text);
+            if (tzMatch) {
+                const result = StreamJsonExtractor.resolveTimeInTimezone(tzMatch[1], tzMatch[2], tzMatch[3], tzMatch[4]);
+                if (result)
+                    return result;
+            }
+            // Pattern 3: "resets in 2 hours" or "resets in 30 minutes"
+            const relMatch = /resets?\s+in\s+(\d+)\s*(hour|hr|minute|min)s?/i.exec(text);
+            if (relMatch) {
+                const amount = parseInt(relMatch[1], 10);
+                const unit = relMatch[2].toLowerCase();
+                const ms = unit.startsWith("hour") || unit === "hr"
+                    ? amount * 3600_000
+                    : amount * 60_000;
+                const future = new Date(Date.now() + ms);
+                return future.toISOString();
+            }
+        }
+        return null;
+    }
+    /**
+     * Resolve a time-of-day (e.g. "7pm") in a named timezone to an ISO string.
+     * Uses Intl.DateTimeFormat to avoid external dependencies.
+     */
+    static resolveTimeInTimezone(hourStr, minuteStr, ampm, timezone) {
+        try {
+            let hour = parseInt(hourStr, 10);
+            const minute = minuteStr ? parseInt(minuteStr, 10) : 0;
+            if (ampm) {
+                const isPm = ampm.toLowerCase() === "pm";
+                if (isPm && hour < 12)
+                    hour += 12;
+                if (!isPm && hour === 12)
+                    hour = 0;
+            }
+            // Get current date in the target timezone
+            const now = new Date();
+            const formatter = new Intl.DateTimeFormat("en-US", {
+                timeZone: timezone,
+                year: "numeric",
+                month: "2-digit",
+                day: "2-digit",
+                hour: "2-digit",
+                minute: "2-digit",
+                hour12: false,
+            });
+            const parts = formatter.formatToParts(now);
+            const get = (type) => parseInt(parts.find((p) => p.type === type)?.value ?? "0", 10);
+            const tzYear = get("year");
+            const tzMonth = get("month");
+            const tzDay = get("day");
+            const tzHour = get("hour");
+            const tzMinute = get("minute");
+            // Build target time in the timezone's "local" frame
+            // Then compute the UTC offset to convert to absolute time
+            const localNowMs = Date.UTC(tzYear, tzMonth - 1, tzDay, tzHour, tzMinute);
+            const offsetMs = localNowMs - now.getTime();
+            // Target time today in timezone-local frame
+            let targetLocalMs = Date.UTC(tzYear, tzMonth - 1, tzDay, hour, minute);
+            // If already past, try tomorrow
+            if (targetLocalMs - offsetMs <= now.getTime()) {
+                targetLocalMs += 86_400_000;
+            }
+            const result = new Date(targetLocalMs - offsetMs);
+            if (result.getTime() > Date.now()) {
+                return result.toISOString();
+            }
+        }
+        catch {
+            // Invalid timezone or parse error — fall through
+        }
+        return null;
+    }
+}
+//# sourceMappingURL=stream-json-extractor.js.map

package/dist/vm/claude-token-manager.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Claude OAuth Token Manager — secure storage + interactive setup.
+ *
+ * Uses `claude setup-token` to obtain a long-lived OAuth token (1 year)
+ * for programmatic use in Docker containers.
+ *
+ * Storage:
+ *   - macOS: Keychain via `security` command (service: "ForgeAI-claude-oauth")
+ *   - Linux/Windows: encrypted file at ~/.forgeai/auth/claude-oauth.json
+ *
+ * Flow:
+ *   1. ensureClaudeToken() checks for stored token
+ *   2. If absent, runs `claude setup-token` interactively
+ *   3. Captures the token from stdout
+ *   4. Saves to Keychain (macOS) or encrypted file (other platforms)
+ *   5. Returns the token for injection into containers
+ */
+/** Store the Claude OAuth token securely. Keychain on macOS, encrypted file elsewhere. */
+export declare function saveClaudeToken(token: string): Promise<void>;
+/** Load the Claude OAuth token. Returns null if not found or invalid. */
+export declare function loadClaudeToken(): Promise<string | null>;
+/** Check if a Claude OAuth token is stored. */
+export declare function hasClaudeToken(): Promise<boolean>;
+/**
+ * Run `claude setup-token` interactively to obtain a long-lived OAuth token.
+ * The user must be logged into Claude Code on this machine.
+ * Returns the token string, or throws if the process fails.
+ */
+export declare function runClaudeSetupToken(): Promise<string>;
+/**
+ * Ensure a Claude OAuth token is available.
+ * If not stored, runs `claude setup-token` interactively.
+ * Returns the token.
+ */
+export declare function ensureClaudeToken(): Promise<string>;
+//# sourceMappingURL=claude-token-manager.d.ts.map