axexec 1.0.0

package/dist/agents/copilot/parse-event.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Event parser for Copilot CLI.
+ *
+ * Parses JSONL events from Copilot CLI session files. The wrapper script
+ * (stream-session.ts) tails the session file and outputs events to stdout,
+ * which are then parsed by this module.
+ */
+import type { EventParser } from "../../types/adapter.js";
+/**
+ * Creates a parser for Copilot CLI JSONL events.
+ *
+ * Maintains state for:
+ * - Tool name correlation (toolCallId -> tool name)
+ * - Tool call deduplication (tracks emitted tool.call events)
+ * - Model tracking (updated from session.model_change)
+ * - Usage accumulation (for session.complete stats)
+ * - Turn end tracking (for session.complete emission)
+ */
+declare function createCopilotParser(): EventParser;
+export { createCopilotParser };

package/dist/agents/copilot/parse-event.js

@@ -0,0 +1,137 @@
+/**
+ * Event parser for Copilot CLI.
+ *
+ * Parses JSONL events from Copilot CLI session files. The wrapper script
+ * (stream-session.ts) tails the session file and outputs events to stdout,
+ * which are then parsed by this module.
+ */
+import { createTimestampParser } from "../../parse-iso-timestamp.js";
+import { CopilotEvent, isAbortEvent, isAssistantMessageEvent, isAssistantTurnEndEvent, isAssistantUsageEvent, isSessionErrorEvent, isSessionModelChangeEvent, isSessionStartEvent, isToolExecutionCompleteEvent, isToolExecutionStartEvent, } from "./types.js";
+import { transformAssistantMessageEvent, transformSessionErrorEvent, transformSessionStartEvent, transformToolCompleteEvent, transformToolStartEvent, } from "./transform-event.js";
+/**
+ * Creates a parser for Copilot CLI JSONL events.
+ *
+ * Maintains state for:
+ * - Tool name correlation (toolCallId -> tool name)
+ * - Tool call deduplication (tracks emitted tool.call events)
+ * - Model tracking (updated from session.model_change)
+ * - Usage accumulation (for session.complete stats)
+ * - Turn end tracking (for session.complete emission)
+ */
+function createCopilotParser() {
+    const parseTimestamp = createTimestampParser();
+    const toolNames = new Map();
+    const emittedToolCalls = new Set();
+    let currentModel = "unknown";
+    let accumulatedUsage;
+    let sessionStartEmitted = false;
+    let lastTurnEndTimestamp;
+    let sessionCompleteEmitted = false;
+    return (line) => {
+        const trimmed = line.trim();
+        // Drain call - emit session.complete if we haven't already
+        // The adapter signals end-of-stream by calling the parser with an empty string
+        if (trimmed === "") {
+            return emitSessionComplete();
+        }
+        // Parse and validate JSON
+        const event = parseEventLine(trimmed);
+        if (!event) {
+            return undefined;
+        }
+        // Dispatch based on event type
+        return handleEvent(event);
+    };
+    function emitSessionComplete() {
+        if (!sessionCompleteEmitted && lastTurnEndTimestamp !== undefined) {
+            sessionCompleteEmitted = true;
+            return {
+                type: "session.complete",
+                stats: {
+                    durationMs: accumulatedUsage?.durationMs ?? 0,
+                    costUsd: accumulatedUsage?.costUsd,
+                    inputTokens: accumulatedUsage?.inputTokens,
+                    outputTokens: accumulatedUsage?.outputTokens,
+                },
+                timestamp: lastTurnEndTimestamp,
+            };
+        }
+        return undefined;
+    }
+    function handleEvent(event) {
+        if (isSessionStartEvent(event)) {
+            if (sessionStartEmitted)
+                return undefined;
+            sessionStartEmitted = true;
+            return transformSessionStartEvent(event, currentModel, parseTimestamp);
+        }
+        if (isSessionModelChangeEvent(event)) {
+            currentModel = event.data.newModel;
+            return undefined;
+        }
+        if (isSessionErrorEvent(event)) {
+            return transformSessionErrorEvent(event, parseTimestamp);
+        }
+        if (isAssistantMessageEvent(event)) {
+            return transformAssistantMessageEvent(event, toolNames, parseTimestamp);
+        }
+        if (isAssistantUsageEvent(event)) {
+            accumulateUsage(event);
+            return undefined;
+        }
+        if (isAssistantTurnEndEvent(event)) {
+            lastTurnEndTimestamp = parseTimestamp(event.timestamp);
+            return undefined;
+        }
+        if (isToolExecutionStartEvent(event)) {
+            return transformToolStartEvent(event, toolNames, emittedToolCalls, parseTimestamp);
+        }
+        if (isToolExecutionCompleteEvent(event)) {
+            return transformToolCompleteEvent(event, toolNames, parseTimestamp);
+        }
+        if (isAbortEvent(event)) {
+            return {
+                type: "session.error",
+                code: "ABORTED",
+                message: event.data.reason,
+                timestamp: parseTimestamp(event.timestamp),
+            };
+        }
+        return undefined;
+    }
+    function accumulateUsage(event) {
+        if (!accumulatedUsage) {
+            accumulatedUsage = {
+                inputTokens: 0,
+                outputTokens: 0,
+                costUsd: 0,
+                durationMs: 0,
+            };
+        }
+        if (event.data.inputTokens) {
+            accumulatedUsage.inputTokens += event.data.inputTokens;
+        }
+        if (event.data.outputTokens) {
+            accumulatedUsage.outputTokens += event.data.outputTokens;
+        }
+        if (event.data.cost) {
+            accumulatedUsage.costUsd += event.data.cost;
+        }
+        if (event.data.duration) {
+            accumulatedUsage.durationMs += event.data.duration;
+        }
+    }
+}
+/** Parse a JSONL line into a CopilotEvent */
+function parseEventLine(line) {
+    let json;
+    try {
+        json = JSON.parse(line);
+    }
+    catch {
+        return undefined;
+    }
+    const result = CopilotEvent.safeParse(json);
+    return result.success ? result.data : undefined;
+}
+export { createCopilotParser };

package/dist/agents/copilot/stream-session.d.ts

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+/**
+ * Copilot CLI session file streamer.
+ *
+ * This script runs Copilot CLI and streams session events from the JSONL
+ * session file to stdout. It's designed to be invoked as a wrapper by axexec.
+ *
+ * Usage: node stream-session.js <prompt> [copilot-args...]
+ */
+export {};

package/dist/agents/copilot/stream-session.js

@@ -0,0 +1,120 @@
+#!/usr/bin/env node
+/**
+ * Copilot CLI session file streamer.
+ *
+ * This script runs Copilot CLI and streams session events from the JSONL
+ * session file to stdout. It's designed to be invoked as a wrapper by axexec.
+ *
+ * Usage: node stream-session.js <prompt> [copilot-args...]
+ */
+import { spawn } from "node:child_process";
+import { tailFile } from "./tail-file.js";
+import { getExistingSessionFiles, waitForSessionFile, } from "./watch-session.js";
+/** Main entry point */
+async function main() {
+    const cliArguments = process.argv.slice(2);
+    const prompt = cliArguments[0];
+    if (!prompt) {
+        process.stderr.write("Usage: stream-session.js <prompt> [args...]\n");
+        process.exit(2);
+    }
+    // Build Copilot CLI arguments
+    const extraArguments = cliArguments.slice(1);
+    const copilotArguments = [
+        "-p",
+        prompt,
+        "--allow-all-tools",
+        // Enable network access without confirmation prompts.
+        // Copilot requires user approval for URL access by default, but other
+        // agents (Gemini, OpenCode) allow it by default. For unified behavior,
+        // enable it. This matches how --allow-all-tools works for other operations.
+        // See: copilot-cli-decompiled/copilot-source/index.js line 418918
+        "--allow-all-urls",
+        ...extraArguments,
+    ];
+    // Record existing session files
+    const existingFiles = getExistingSessionFiles();
+    // Abort controller for cleanup
+    const abortController = new AbortController();
+    // Track resources for cleanup
+    let copilotProcess;
+    let sessionWatcherCleanup;
+    // Cleanup function
+    const cleanup = () => {
+        abortController.abort();
+        sessionWatcherCleanup?.();
+        if (copilotProcess && !copilotProcess.killed) {
+            copilotProcess.kill();
+        }
+    };
+    // Handle signals
+    process.on("SIGINT", cleanup);
+    process.on("SIGTERM", cleanup);
+    try {
+        // Start Copilot CLI
+        const copilotBin = process.env["AXEXEC_COPILOT_PATH"] ?? "copilot";
+        const child = spawn(copilotBin, copilotArguments, {
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        copilotProcess = child;
+        // Pipe Copilot's stdout/stderr to our stderr (for debugging)
+        // We use stdout for JSONL events only
+        child.stdout.pipe(process.stderr);
+        child.stderr.pipe(process.stderr);
+        // Handle spawn errors
+        child.on("error", (error) => {
+            process.stderr.write(`Error spawning Copilot CLI: ${error.message}\n`);
+            cleanup();
+            process.exit(1);
+        });
+        // Wait for new session file
+        const sessionWatcher = waitForSessionFile(existingFiles);
+        sessionWatcherCleanup = sessionWatcher.cleanup;
+        const sessionFilePath = await sessionWatcher.promise;
+        sessionWatcherCleanup = undefined;
+        // Start tailing the session file
+        const tailPromise = (async () => {
+            for await (const line of tailFile(sessionFilePath, abortController.signal)) {
+                if (line.trim()) {
+                    process.stdout.write(line + "\n");
+                }
+            }
+        })();
+        // Wait for Copilot to exit
+        const exitCode = await new Promise((resolve) => {
+            child.on("close", (code) => {
+                resolve(code ?? 0);
+            });
+        });
+        // Give a moment for final events to be written
+        await new Promise((resolve) => setTimeout(resolve, 200));
+        // Stop tailing
+        abortController.abort();
+        // Wait for tail to finish processing
+        try {
+            await tailPromise;
+        }
+        catch {
+            // Ignore abort errors
+        }
+        process.exit(exitCode);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        process.stderr.write(`Error: ${message}\n`);
+        // Don't call cleanup() here - finally block handles it
+        process.exit(1);
+    }
+    finally {
+        cleanup();
+    }
+}
+// Run main and handle errors
+try {
+    await main();
+}
+catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    process.stderr.write(`Fatal error: ${message}\n`);
+    process.exit(1);
+}

package/dist/agents/copilot/tail-file.d.ts

@@ -0,0 +1,11 @@
+/**
+ * File tailing utility for streaming new lines from a file.
+ */
+/**
+ * Tail a file and yield lines as they're written.
+ *
+ * Polls the file for new content and yields complete lines as they appear.
+ * Buffers partial lines across reads to avoid splitting JSONL records.
+ * Continues until the abort signal is triggered.
+ */
+export declare function tailFile(filePath: string, signal: AbortSignal): AsyncGenerator<string>;

package/dist/agents/copilot/tail-file.js

@@ -0,0 +1,52 @@
+/**
+ * File tailing utility for streaming new lines from a file.
+ */
+import { createReadStream, statSync } from "node:fs";
+/**
+ * Tail a file and yield lines as they're written.
+ *
+ * Polls the file for new content and yields complete lines as they appear.
+ * Buffers partial lines across reads to avoid splitting JSONL records.
+ * Continues until the abort signal is triggered.
+ */
+export async function* tailFile(filePath, signal) {
+    let position = 0;
+    let buffer = "";
+    // Keep reading until aborted
+    while (!signal.aborted) {
+        try {
+            const stats = statSync(filePath);
+            const fileSize = stats.size;
+            if (fileSize > position) {
+                // New data available
+                const stream = createReadStream(filePath, {
+                    start: position,
+                    end: fileSize - 1,
+                });
+                for await (const chunk of stream) {
+                    // Check abort during iteration - signal can change while awaiting
+                    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+                    if (signal.aborted)
+                        break;
+                    buffer += chunk.toString("utf8");
+                    // Yield complete lines (terminated by newline)
+                    if (buffer.includes("\n")) {
+                        const lines = buffer.split("\n");
+                        // Keep last element as buffer (partial line or empty string)
+                        buffer = lines.pop() ?? "";
+                        for (const line of lines) {
+                            yield line;
+                        }
+                    }
+                }
+                position = fileSize;
+            }
+            // Wait a bit before checking again
+            await new Promise((resolve) => setTimeout(resolve, 50));
+        }
+        catch {
+            // File might be temporarily unavailable, wait and retry
+            await new Promise((resolve) => setTimeout(resolve, 100));
+        }
+    }
+}

package/dist/agents/copilot/transform-event.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Event transformation functions for Copilot CLI events.
+ *
+ * Transforms raw Copilot events into normalized AxexecEvent format.
+ */
+import type { AxexecEvent } from "../../types/events.js";
+import type { CopilotAssistantMessageEvent, CopilotSessionErrorEvent, CopilotSessionStartEvent, CopilotToolExecutionCompleteEvent, CopilotToolExecutionStartEvent } from "./types.js";
+type TimestampParser = (isoString: string | undefined) => number;
+/** Transforms a session.start event */
+export declare function transformSessionStartEvent(event: CopilotSessionStartEvent, model: string, parseTimestamp: TimestampParser): AxexecEvent;
+/** Transforms a session.error event */
+export declare function transformSessionErrorEvent(event: CopilotSessionErrorEvent, parseTimestamp: TimestampParser): AxexecEvent;
+/** Transforms an assistant.message event */
+export declare function transformAssistantMessageEvent(event: CopilotAssistantMessageEvent, toolNames: Map<string, string>, parseTimestamp: TimestampParser): AxexecEvent | undefined;
+/** Transforms a tool.execution_start event */
+export declare function transformToolStartEvent(event: CopilotToolExecutionStartEvent, toolNames: Map<string, string>, emittedToolCalls: Set<string>, parseTimestamp: TimestampParser): AxexecEvent | undefined;
+/** Transforms a tool.execution_complete event */
+export declare function transformToolCompleteEvent(event: CopilotToolExecutionCompleteEvent, toolNames: Map<string, string>, parseTimestamp: TimestampParser): AxexecEvent;
+export {};

package/dist/agents/copilot/transform-event.js

@@ -0,0 +1,100 @@
+/**
+ * Event transformation functions for Copilot CLI events.
+ *
+ * Transforms raw Copilot events into normalized AxexecEvent format.
+ */
+/**
+ * Infers the provider from a Copilot model name.
+ *
+ * Copilot supports models from multiple providers:
+ * - claude-* → anthropic
+ * - gpt-*, o1-*, o3-*, o4-* → openai
+ * - gemini-* → google
+ *
+ * Returns undefined for unrecognized models (field is optional).
+ */
+function inferProviderFromModel(model) {
+    if (model.startsWith("claude-"))
+        return "anthropic";
+    if (model.startsWith("gpt-"))
+        return "openai";
+    if (model.startsWith("o1-") ||
+        model.startsWith("o3-") ||
+        model.startsWith("o4-"))
+        return "openai";
+    if (model.startsWith("gemini-"))
+        return "google";
+    return undefined;
+}
+/** Transforms a session.start event */
+export function transformSessionStartEvent(event, model, parseTimestamp) {
+    const resolvedModel = event.data.selectedModel ?? model;
+    return {
+        type: "session.start",
+        sessionId: event.data.sessionId,
+        agent: "copilot",
+        model: resolvedModel,
+        provider: inferProviderFromModel(resolvedModel),
+        timestamp: parseTimestamp(event.timestamp),
+    };
+}
+/** Transforms a session.error event */
+export function transformSessionErrorEvent(event, parseTimestamp) {
+    return {
+        type: "session.error",
+        code: event.data.errorType,
+        message: event.data.message,
+        timestamp: parseTimestamp(event.timestamp),
+    };
+}
+/** Transforms an assistant.message event */
+export function transformAssistantMessageEvent(event, toolNames, parseTimestamp) {
+    const timestamp = parseTimestamp(event.timestamp);
+    // If there are tool requests, pre-register the tool names for correlation
+    // but DON'T emit tool.call here - we'll emit from tool.execution_start
+    for (const request of event.data.toolRequests ?? []) {
+        toolNames.set(request.toolCallId, request.name);
+    }
+    // Emit text content as agent message (only if there's actual content)
+    if (event.data.content) {
+        return {
+            type: "agent.message",
+            content: event.data.content,
+            timestamp,
+        };
+    }
+    return undefined;
+}
+/** Transforms a tool.execution_start event */
+export function transformToolStartEvent(event, toolNames, emittedToolCalls, parseTimestamp) {
+    const callId = event.data.toolCallId;
+    // Check if we've already emitted this tool call
+    if (emittedToolCalls.has(callId)) {
+        return undefined;
+    }
+    emittedToolCalls.add(callId);
+    const tool = event.data.toolName;
+    toolNames.set(callId, tool);
+    return {
+        type: "tool.call",
+        callId,
+        tool,
+        input: event.data.arguments,
+        timestamp: parseTimestamp(event.timestamp),
+    };
+}
+/** Transforms a tool.execution_complete event */
+export function transformToolCompleteEvent(event, toolNames, parseTimestamp) {
+    const callId = event.data.toolCallId;
+    const tool = toolNames.get(callId) ?? "unknown";
+    // Clean up to prevent memory leaks
+    toolNames.delete(callId);
+    return {
+        type: "tool.result",
+        callId,
+        tool,
+        output: event.data.result?.content ?? event.data.error?.message,
+        success: event.data.success,
+        timestamp: parseTimestamp(event.timestamp),
+    };
+}