@renseiai/agentfactory 0.8.0

package/dist/src/orchestrator/api-activity-emitter.d.ts

@@ -0,0 +1,167 @@
+/**
+ * API-based Activity Emitter
+ *
+ * Emits Claude stream events to Linear via the agent app's API endpoint.
+ * This is used when the orchestrator runs remotely (as a worker) and needs
+ * to proxy activities through the Vercel app which has OAuth tokens.
+ *
+ * The agent app API endpoint (/api/sessions/[id]/activity) retrieves the
+ * OAuth token from Redis using the session's organizationId and forwards
+ * the activity to Linear's Agent API.
+ *
+ * Mapping:
+ * - assistant message → response (persisted, user-directed communication)
+ * - tool_use → action (ephemeral)
+ * - tool_result → action (ephemeral)
+ * - result → response (persisted)
+ * - error → error (persisted)
+ */
+/** Configuration for the API activity emitter */
+export interface ApiActivityEmitterConfig {
+    /** Linear session ID */
+    sessionId: string;
+    /** Worker ID for authentication */
+    workerId: string;
+    /** API base URL (e.g., https://agent.rensei.dev) */
+    apiBaseUrl: string;
+    /** API authentication key */
+    apiKey: string;
+    /** Minimum interval between activities in ms (default: 500ms) */
+    minInterval?: number;
+    /** Maximum length for tool outputs before truncation (default: 2000) */
+    maxOutputLength?: number;
+    /** Whether to include timestamps in activities (default: false) */
+    includeTimestamps?: boolean;
+    /** Optional callback when an activity is emitted */
+    onActivityEmitted?: (type: string, content: string) => void;
+    /** Optional callback when an activity is throttled */
+    onActivityThrottled?: (type: string, content: string) => void;
+    /** Optional callback when API call fails */
+    onActivityError?: (type: string, error: Error) => void;
+    /** Optional callback when a progress update is posted */
+    onProgressPosted?: (milestone: string, message: string) => void;
+    /** Optional callback when session ownership is revoked (403 from another worker) */
+    onOwnershipRevoked?: () => void;
+}
+/** Progress milestone types */
+export type ProgressMilestone = 'claimed' | 'worktree' | 'started' | 'running' | 'tests' | 'pr' | 'completed' | 'failed' | 'stopped' | 'resumed';
+/**
+ * API Activity Emitter
+ *
+ * Handles rate-limited emission of Claude events to Linear via API proxy.
+ */
+export declare class ApiActivityEmitter {
+    private readonly sessionId;
+    private workerId;
+    private readonly apiBaseUrl;
+    private readonly apiKey;
+    private readonly minInterval;
+    private readonly maxOutputLength;
+    private readonly includeTimestamps;
+    private readonly onActivityEmitted?;
+    private readonly onActivityThrottled?;
+    private readonly onActivityError?;
+    private readonly onProgressPosted?;
+    private readonly onOwnershipRevoked?;
+    /** Circuit breaker: set when 403 ownership error is received */
+    private ownershipRevoked;
+    private lastEmitTime;
+    private queue;
+    private flushTimer;
+    private isProcessing;
+    private readonly reportedToolErrors;
+    constructor(config: ApiActivityEmitterConfig);
+    /**
+     * Update the worker ID used for API requests.
+     * Called after worker re-registration to ensure activities are attributed
+     * to the new worker ID and pass ownership checks.
+     */
+    updateWorkerId(newWorkerId: string): void;
+    /**
+     * Get the current worker ID
+     */
+    getWorkerId(): string;
+    /**
+     * Check if ownership has been revoked (circuit breaker tripped)
+     */
+    isOwnershipRevoked(): boolean;
+    /**
+     * Emit a thought activity (persistent by default for visibility in Linear)
+     */
+    emitThought(content: string, ephemeral?: boolean): Promise<void>;
+    /**
+     * Emit a tool use activity (ephemeral by default)
+     */
+    emitToolUse(tool: string, input: Record<string, unknown>, ephemeral?: boolean): Promise<void>;
+    /**
+     * Emit a response activity (persisted)
+     */
+    emitResponse(content: string): Promise<void>;
+    /**
+     * Emit an error activity (persisted)
+     */
+    emitError(error: Error | string): Promise<void>;
+    /**
+     * Post a progress update comment to the Linear issue thread.
+     * Unlike activities which are ephemeral, progress updates are
+     * persisted as comments and visible in the issue thread.
+     *
+     * @param milestone - The type of progress milestone (e.g., 'started', 'completed')
+     * @param message - The progress message to post
+     */
+    postProgress(milestone: ProgressMilestone, message: string): Promise<boolean>;
+    /**
+     * Report a tool error as a Linear issue for tracking and improvement.
+     * Creates a bug in the Agent project backlog via API.
+     *
+     * @param toolName - Name of the tool that errored
+     * @param errorMessage - The error message
+     * @param context - Additional context about the error
+     * @returns The created issue, or null if creation failed or was deduplicated
+     */
+    reportToolError(toolName: string, errorMessage: string, context?: {
+        issueIdentifier?: string;
+        additionalContext?: Record<string, unknown>;
+    }): Promise<{
+        id: string;
+        identifier: string;
+        url: string;
+    } | null>;
+    /**
+     * Queue an activity for emission with rate limiting
+     */
+    private queueActivity;
+    /**
+     * Process queued activities
+     */
+    private processQueue;
+    /**
+     * Merge consecutive similar activities in the queue
+     */
+    private mergeQueuedActivities;
+    /**
+     * Emit a single activity to Linear via API
+     */
+    private emitActivity;
+    /**
+     * Summarize tool input for display
+     */
+    private summarizeToolInput;
+    /**
+     * Truncate long output strings
+     */
+    private truncateOutput;
+    /**
+     * Flush all pending activities immediately
+     */
+    flush(): Promise<void>;
+    /**
+     * Helper delay function
+     */
+    private delay;
+}
+/**
+ * Create an API activity emitter instance
+ */
+export declare function createApiActivityEmitter(config: ApiActivityEmitterConfig): ApiActivityEmitter;
+//# sourceMappingURL=api-activity-emitter.d.ts.map

package/dist/src/orchestrator/api-activity-emitter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"api-activity-emitter.d.ts","sourceRoot":"","sources":["../../../src/orchestrator/api-activity-emitter.ts"],"names":[],"mappings":"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"}

package/dist/src/orchestrator/api-activity-emitter.js

@@ -0,0 +1,417 @@
+/**
+ * API-based Activity Emitter
+ *
+ * Emits Claude stream events to Linear via the agent app's API endpoint.
+ * This is used when the orchestrator runs remotely (as a worker) and needs
+ * to proxy activities through the Vercel app which has OAuth tokens.
+ *
+ * The agent app API endpoint (/api/sessions/[id]/activity) retrieves the
+ * OAuth token from Redis using the session's organizationId and forwards
+ * the activity to Linear's Agent API.
+ *
+ * Mapping:
+ * - assistant message → response (persisted, user-directed communication)
+ * - tool_use → action (ephemeral)
+ * - tool_result → action (ephemeral)
+ * - result → response (persisted)
+ * - error → error (persisted)
+ */
+const DEFAULT_MIN_INTERVAL = 500;
+const DEFAULT_MAX_OUTPUT_LENGTH = 2000;
+/**
+ * API Activity Emitter
+ *
+ * Handles rate-limited emission of Claude events to Linear via API proxy.
+ */
+export class ApiActivityEmitter {
+    sessionId;
+    workerId; // Mutable to allow update after worker re-registration
+    apiBaseUrl;
+    apiKey;
+    minInterval;
+    maxOutputLength;
+    includeTimestamps;
+    onActivityEmitted;
+    onActivityThrottled;
+    onActivityError;
+    onProgressPosted;
+    onOwnershipRevoked;
+    /** Circuit breaker: set when 403 ownership error is received */
+    ownershipRevoked = false;
+    lastEmitTime = 0;
+    queue = [];
+    flushTimer = null;
+    isProcessing = false;
+    // Track reported tool error signatures for deduplication
+    reportedToolErrors = new Set();
+    constructor(config) {
+        this.sessionId = config.sessionId;
+        this.workerId = config.workerId;
+        this.apiBaseUrl = config.apiBaseUrl.replace(/\/$/, ''); // Remove trailing slash
+        this.apiKey = config.apiKey;
+        this.minInterval = config.minInterval ?? DEFAULT_MIN_INTERVAL;
+        this.maxOutputLength = config.maxOutputLength ?? DEFAULT_MAX_OUTPUT_LENGTH;
+        this.includeTimestamps = config.includeTimestamps ?? false;
+        this.onActivityEmitted = config.onActivityEmitted;
+        this.onActivityThrottled = config.onActivityThrottled;
+        this.onActivityError = config.onActivityError;
+        this.onProgressPosted = config.onProgressPosted;
+        this.onOwnershipRevoked = config.onOwnershipRevoked;
+    }
+    /**
+     * Update the worker ID used for API requests.
+     * Called after worker re-registration to ensure activities are attributed
+     * to the new worker ID and pass ownership checks.
+     */
+    updateWorkerId(newWorkerId) {
+        this.workerId = newWorkerId;
+    }
+    /**
+     * Get the current worker ID
+     */
+    getWorkerId() {
+        return this.workerId;
+    }
+    /**
+     * Check if ownership has been revoked (circuit breaker tripped)
+     */
+    isOwnershipRevoked() {
+        return this.ownershipRevoked;
+    }
+    /**
+     * Emit a thought activity (persistent by default for visibility in Linear)
+     */
+    async emitThought(content, ephemeral = false) {
+        await this.queueActivity({
+            type: 'thought',
+            content,
+            ephemeral,
+        });
+    }
+    /**
+     * Emit a tool use activity (ephemeral by default)
+     */
+    async emitToolUse(tool, input, ephemeral = true) {
+        const inputSummary = this.summarizeToolInput(tool, input);
+        await this.queueActivity({
+            type: 'action',
+            content: `${tool}: ${inputSummary}`,
+            ephemeral,
+            toolName: tool,
+            toolInput: input,
+        });
+    }
+    /**
+     * Emit a response activity (persisted)
+     */
+    async emitResponse(content) {
+        await this.queueActivity({
+            type: 'response',
+            content,
+            ephemeral: false,
+        });
+    }
+    /**
+     * Emit an error activity (persisted)
+     */
+    async emitError(error) {
+        const message = error instanceof Error ? error.message : error;
+        await this.queueActivity({
+            type: 'error',
+            content: message,
+            ephemeral: false,
+        });
+    }
+    /**
+     * Post a progress update comment to the Linear issue thread.
+     * Unlike activities which are ephemeral, progress updates are
+     * persisted as comments and visible in the issue thread.
+     *
+     * @param milestone - The type of progress milestone (e.g., 'started', 'completed')
+     * @param message - The progress message to post
+     */
+    async postProgress(milestone, message) {
+        if (this.ownershipRevoked)
+            return false;
+        try {
+            const response = await fetch(`${this.apiBaseUrl}/api/sessions/${this.sessionId}/progress`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    Authorization: `Bearer ${this.apiKey}`,
+                },
+                body: JSON.stringify({
+                    workerId: this.workerId,
+                    milestone,
+                    message,
+                }),
+            });
+            if (!response.ok) {
+                const errorText = await response.text();
+                throw new Error(`API error ${response.status}: ${errorText}`);
+            }
+            const result = (await response.json());
+            if (result.posted) {
+                this.onProgressPosted?.(milestone, message);
+            }
+            else {
+                console.warn(`Progress not posted: ${result.reason ?? 'unknown'}`);
+            }
+            return result.posted;
+        }
+        catch (error) {
+            const err = error instanceof Error ? error : new Error(String(error));
+            console.error(`Failed to post progress (${milestone}):`, err);
+            this.onActivityError?.('progress', err);
+            return false;
+        }
+    }
+    /**
+     * Report a tool error as a Linear issue for tracking and improvement.
+     * Creates a bug in the Agent project backlog via API.
+     *
+     * @param toolName - Name of the tool that errored
+     * @param errorMessage - The error message
+     * @param context - Additional context about the error
+     * @returns The created issue, or null if creation failed or was deduplicated
+     */
+    async reportToolError(toolName, errorMessage, context) {
+        // Deduplicate using tool name + first 100 chars of error
+        const signature = `${toolName}:${errorMessage.substring(0, 100)}`;
+        if (this.reportedToolErrors.has(signature)) {
+            return null;
+        }
+        this.reportedToolErrors.add(signature);
+        try {
+            const response = await fetch(`${this.apiBaseUrl}/api/sessions/${this.sessionId}/tool-error`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    Authorization: `Bearer ${this.apiKey}`,
+                },
+                body: JSON.stringify({
+                    workerId: this.workerId,
+                    toolName,
+                    errorMessage,
+                    context,
+                }),
+            });
+            if (!response.ok) {
+                const errorText = await response.text();
+                throw new Error(`API error ${response.status}: ${errorText}`);
+            }
+            const result = (await response.json());
+            if (result.created && result.issue) {
+                return result.issue;
+            }
+            return null;
+        }
+        catch (error) {
+            const err = error instanceof Error ? error : new Error(String(error));
+            console.error('[ApiActivityEmitter] Failed to report tool error:', err);
+            this.onActivityError?.('tool-error', err);
+            return null;
+        }
+    }
+    /**
+     * Queue an activity for emission with rate limiting
+     */
+    async queueActivity(activity) {
+        if (this.ownershipRevoked)
+            return;
+        this.queue.push(activity);
+        // Schedule flush if not already scheduled
+        if (!this.flushTimer && !this.isProcessing) {
+            const timeSinceLastEmit = Date.now() - this.lastEmitTime;
+            const delay = Math.max(0, this.minInterval - timeSinceLastEmit);
+            this.flushTimer = setTimeout(() => {
+                this.flushTimer = null;
+                this.processQueue();
+            }, delay);
+        }
+    }
+    /**
+     * Process queued activities
+     */
+    async processQueue() {
+        if (this.isProcessing || this.queue.length === 0)
+            return;
+        this.isProcessing = true;
+        try {
+            // Merge similar consecutive activities to reduce API calls
+            const merged = this.mergeQueuedActivities();
+            for (const activity of merged) {
+                await this.emitActivity(activity);
+                this.lastEmitTime = Date.now();
+                // Small delay between emissions to avoid rate limits
+                if (merged.length > 1) {
+                    await this.delay(100);
+                }
+            }
+        }
+        finally {
+            this.isProcessing = false;
+            // If more activities were queued during processing, schedule another flush
+            if (this.queue.length > 0 && !this.flushTimer) {
+                this.flushTimer = setTimeout(() => {
+                    this.flushTimer = null;
+                    this.processQueue();
+                }, this.minInterval);
+            }
+        }
+    }
+    /**
+     * Merge consecutive similar activities in the queue
+     */
+    mergeQueuedActivities() {
+        const activities = [...this.queue];
+        this.queue = [];
+        if (activities.length <= 1)
+            return activities;
+        const merged = [];
+        let current = activities[0];
+        for (let i = 1; i < activities.length; i++) {
+            const next = activities[i];
+            // Merge consecutive thoughts
+            if (current.type === 'thought' &&
+                next.type === 'thought' &&
+                current.ephemeral === next.ephemeral) {
+                current = {
+                    ...current,
+                    content: `${current.content}\n\n${next.content}`,
+                };
+                this.onActivityThrottled?.('thought', next.content);
+                continue;
+            }
+            // Merge consecutive tool results for same tool
+            if (current.type === 'action' &&
+                next.type === 'action' &&
+                current.toolName === next.toolName &&
+                current.ephemeral === next.ephemeral) {
+                current = {
+                    ...current,
+                    content: `${current.content}\n${next.content}`,
+                };
+                this.onActivityThrottled?.('action', next.content);
+                continue;
+            }
+            merged.push(current);
+            current = next;
+        }
+        merged.push(current);
+        return merged;
+    }
+    /**
+     * Emit a single activity to Linear via API
+     */
+    async emitActivity(activity) {
+        if (this.ownershipRevoked)
+            return;
+        try {
+            const content = this.includeTimestamps
+                ? `[${new Date().toISOString()}] ${activity.content}`
+                : activity.content;
+            const response = await fetch(`${this.apiBaseUrl}/api/sessions/${this.sessionId}/activity`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Authorization': `Bearer ${this.apiKey}`,
+                },
+                body: JSON.stringify({
+                    workerId: this.workerId,
+                    activity: {
+                        type: activity.type,
+                        content,
+                        toolName: activity.toolName,
+                        toolInput: activity.toolInput,
+                    },
+                }),
+            });
+            if (!response.ok) {
+                const errorText = await response.text();
+                throw new Error(`API error ${response.status}: ${errorText}`);
+            }
+            const result = (await response.json());
+            if (!result.forwarded) {
+                console.warn(`Activity not forwarded: ${result.reason ?? 'unknown'}`);
+            }
+            this.onActivityEmitted?.(activity.type, content);
+        }
+        catch (error) {
+            const err = error instanceof Error ? error : new Error(String(error));
+            // Circuit breaker: stop emitting if session ownership was revoked
+            if (err.message.includes('403') && err.message.includes('owned by another worker')) {
+                this.ownershipRevoked = true;
+                console.warn(`[${this.sessionId}] Session ownership revoked — stopping activity emission`);
+                this.onOwnershipRevoked?.();
+                return;
+            }
+            console.error(`Failed to emit ${activity.type} activity via API:`, err);
+            this.onActivityError?.(activity.type, err);
+        }
+    }
+    /**
+     * Summarize tool input for display
+     */
+    summarizeToolInput(tool, input) {
+        // Tool-specific summaries
+        switch (tool) {
+            case 'Read':
+                return String(input.file_path || input.path || 'file');
+            case 'Write':
+                return String(input.file_path || input.path || 'file');
+            case 'Edit':
+                return String(input.file_path || input.path || 'file');
+            case 'Grep':
+                return `"${input.pattern}" in ${input.path || '.'}`;
+            case 'Glob':
+                return String(input.pattern || '*');
+            case 'Bash':
+                const cmd = String(input.command || '');
+                return cmd.length > 50 ? cmd.substring(0, 47) + '...' : cmd;
+            case 'Task':
+                return String(input.description || input.prompt || 'task');
+            default:
+                // Generic: show first string value or truncated JSON
+                const firstStringValue = Object.values(input).find((v) => typeof v === 'string');
+                if (firstStringValue) {
+                    return firstStringValue.length > 50
+                        ? firstStringValue.substring(0, 47) + '...'
+                        : firstStringValue;
+                }
+                const json = JSON.stringify(input);
+                return json.length > 50 ? json.substring(0, 47) + '...' : json;
+        }
+    }
+    /**
+     * Truncate long output strings
+     */
+    truncateOutput(output) {
+        if (output.length <= this.maxOutputLength)
+            return output;
+        return (output.substring(0, this.maxOutputLength) +
+            `\n\n... (truncated ${output.length - this.maxOutputLength} chars)`);
+    }
+    /**
+     * Flush all pending activities immediately
+     */
+    async flush() {
+        if (this.flushTimer) {
+            clearTimeout(this.flushTimer);
+            this.flushTimer = null;
+        }
+        await this.processQueue();
+    }
+    /**
+     * Helper delay function
+     */
+    delay(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+}
+/**
+ * Create an API activity emitter instance
+ */
+export function createApiActivityEmitter(config) {
+    return new ApiActivityEmitter(config);
+}

package/dist/src/orchestrator/heartbeat-writer.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Heartbeat Writer
+ *
+ * Periodically writes heartbeat state to the .agent/ directory.
+ * Uses atomic writes (temp file + rename) to prevent corruption.
+ */
+import type { HeartbeatActivityType, HeartbeatWriterConfig } from './state-types.js';
+/**
+ * HeartbeatWriter periodically writes heartbeat state to enable crash detection
+ */
+export declare class HeartbeatWriter {
+    private readonly config;
+    private readonly heartbeatPath;
+    private intervalHandle;
+    private lastActivityType;
+    private lastActivityTimestamp;
+    private toolCallsCount;
+    private currentOperation;
+    private stopped;
+    constructor(config: HeartbeatWriterConfig);
+    /**
+     * Start the heartbeat writer
+     * Immediately writes the first heartbeat, then starts the interval
+     */
+    start(): void;
+    /**
+     * Stop the heartbeat writer
+     * Should be called when the agent exits
+     */
+    stop(): void;
+    /**
+     * Update the last activity type
+     * Call this when the agent does something
+     */
+    updateActivity(type: HeartbeatActivityType, operation?: string): void;
+    /**
+     * Record a tool call
+     */
+    recordToolCall(toolName: string): void;
+    /**
+     * Record thinking activity
+     */
+    recordThinking(): void;
+    /**
+     * Write the heartbeat file atomically
+     */
+    private writeHeartbeat;
+}
+/**
+ * Create a heartbeat writer for an agent
+ */
+export declare function createHeartbeatWriter(config: HeartbeatWriterConfig): HeartbeatWriter;
+/**
+ * Parse environment variable for heartbeat interval
+ */
+export declare function getHeartbeatIntervalFromEnv(): number;
+//# sourceMappingURL=heartbeat-writer.d.ts.map

package/dist/src/orchestrator/heartbeat-writer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"heartbeat-writer.d.ts","sourceRoot":"","sources":["../../../src/orchestrator/heartbeat-writer.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,OAAO,KAAK,EAEV,qBAAqB,EACrB,qBAAqB,EACtB,MAAM,kBAAkB,CAAA;AAKzB;;GAEG;AACH,qBAAa,eAAe;IAC1B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAiC;IACxD,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAQ;IACtC,OAAO,CAAC,cAAc,CAA8C;IACpE,OAAO,CAAC,gBAAgB,CAAgC;IACxD,OAAO,CAAC,qBAAqB,CAAQ;IACrC,OAAO,CAAC,cAAc,CAAI;IAC1B,OAAO,CAAC,gBAAgB,CAAsB;IAC9C,OAAO,CAAC,OAAO,CAAQ;gBAEX,MAAM,EAAE,qBAAqB;IASzC;;;OAGG;IACH,KAAK,IAAI,IAAI;IA2Bb;;;OAGG;IACH,IAAI,IAAI,IAAI;IAQZ;;;OAGG;IACH,cAAc,CAAC,IAAI,EAAE,qBAAqB,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI;IASrE;;OAEG;IACH,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI;IAItC;;OAEG;IACH,cAAc,IAAI,IAAI;IAItB;;OAEG;IACH,OAAO,CAAC,cAAc;CAyBvB;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,qBAAqB,GAAG,eAAe,CAEpF;AAED;;GAEG;AACH,wBAAgB,2BAA2B,IAAI,MAAM,CASpD"}