omnara 0.2.3 → 0.3.0

package/dist/orchestrator/worker-manager.d.ts

@@ -1,121 +1,66 @@
-import { EventEmitter } from 'events';
-import type { SDKUserMessage, McpServerConfig } from '@anthropic-ai/claude-agent-sdk';
-import type { AgentClient } from './ai-client.js';
-import { AsyncQueue } from './utils/async-queue.js';
+import type { McpServerConfig } from '@anthropic-ai/claude-agent-sdk';
+import { type AgentClient } from './ai-client.js';
 import { WorktreeManager } from './utils/worktree-manager.js';
-export type WorkerStatus = 'running' | 'completed' | 'error' | 'canceled';
-export interface WorkerProgressEntry {
-    timestamp: number;
-    message: string;
-}
-export interface WorkerRecord {
-    id: string;
-    task: string;
-    prompt: string;
-    sessionId: string;
-    sdkSessionId?: string | null;
-    status: WorkerStatus;
-    startedAt: number;
-    lastUpdateAt: number;
-    originSessionId?: string;
-    progress: WorkerProgressEntry[];
-    result?: string;
-    error?: string;
-    metadata?: Record<string, unknown>;
-    messageQueue: AsyncQueue<SDKUserMessage>;
-    worktreePath?: string;
-    branchName?: string;
-    work_context?: string;
-    worktree_name?: string;
-}
-export interface WorkerMessageEvent {
-    record: WorkerRecord;
-    messageType: 'assistant_text' | 'assistant_complete' | 'tool_call' | 'tool_result';
-    text?: string;
-    success?: boolean;
-    toolName?: string;
-    toolUseId?: string;
-    toolInput?: unknown;
-    toolContent?: unknown;
-    isError?: boolean;
-}
+import { Session, type CompleteMessageEnvelope } from './session.js';
+import type { WorkerStatus } from './worker-types.js';
+import type { MessageEnvelope } from '@omnara/shared-js/schemas';
+export type { WorkerStatus, WorkerRecord, WorkerSessionMessageEvent } from './worker-types.js';
 interface LaunchWorkerOptions {
     task: string;
     prompt: string;
     work_context: string;
     worktree_name: string;
-    originSessionId?: string;
+    originSessionId: string;
     metadata?: Record<string, unknown>;
 }
 interface WorkerManagerOptions {
     createClient: (mcpServers?: Record<string, McpServerConfig>, cwd?: string) => AgentClient;
-    resolveSessionIdBySdk?: (sdkSessionId?: string) => string | undefined;
+    broadcastMessage: (msg: MessageEnvelope) => Promise<void> | void;
+    broadcastComplete: (complete: CompleteMessageEnvelope) => Promise<void> | void;
+    announceWorkerSession?: (info: {
+        sessionId: string;
+        parentSessionId?: string;
+        metadata?: Record<string, unknown>;
+    }) => Promise<void> | void;
     repoPath: string;
-    worktreesEnabled: boolean;
-    worktreesBaseRef?: string;
 }
-export declare class WorkerManager extends EventEmitter {
+type Worker = {
+    status: WorkerStatus;
+    session: Session;
+    ai: AgentClient;
+    task: string;
+    parentSessionId: string;
+    worktreeName?: string;
+    directory: string;
+    startedAt: number;
+    lastUpdateAt: number;
+};
+export declare class WorkerManager {
     private readonly options;
-    private readonly workers;
-    private readonly runningQueries;
-    private worktreeManager;
-    repoPath: string;
+    private workers;
+    worktreeManager: WorktreeManager;
+    broadcastMessage: (msg: MessageEnvelope) => Promise<void> | void;
+    broadcastComplete: (complete: CompleteMessageEnvelope) => Promise<void> | void;
+    readonly repoPath: string;
+    private readonly announceWorkerSession?;
     constructor(options: WorkerManagerOptions);
-    private initializeConfig;
-    listWorkers(): WorkerRecord[];
-    getWorker(id: string): WorkerRecord | undefined;
-    getWorkerByTask(task: string): WorkerRecord | undefined;
-    /**
-     * Get a formatted summary of all current worker statuses for inclusion in system prompts.
-     * Returns a string describing all active workers and their current state.
-     */
-    getWorkerStatusSummary(): string;
-    launchWorker({ task, prompt, work_context, worktree_name, originSessionId, metadata }: LaunchWorkerOptions, toolUseId?: string): WorkerRecord;
-    private createWorktreeAndRun;
-    cancelWorker(id: string): boolean;
+    listWorkers(): Worker[];
+    getWorker(id: string): Worker | undefined;
+    getWorkerByTask(task: string): Worker | undefined;
+    cancelWorker(id: string): Promise<boolean>;
+    launchWorker({ task, prompt, worktree_name, originSessionId, }: LaunchWorkerOptions): Promise<Worker>;
     /**
      * Route a user message to a worker by session ID.
-     * This is used when users send messages directly to subagent sessions from the frontend.
-     *
-     * @param sessionId - The session ID of the worker
-     * @param message - The message content to send
-     * @returns true if message was sent, false if worker not found
+     * Thin wrapper around enqueueMessage.
      */
-    routeUserMessageToWorker(sessionId: string, message: string): Promise<boolean>;
+    userMessageWorker(sessionId: string, userId: string, message: string): Promise<boolean>;
     /**
      * Send a message to a worker (running or completed).
-     *
-     * @param task - The task name of the worker to message
-     * @param message - The message content to send
-     * @param interrupt - If true, interrupt current generation; if false, queue for next turn
-     * @param toolUseId - Optional tool use ID to track this operation for relay forwarding
-     * @returns true if message was sent, false if worker not found or message queue is closed
-     */
-    messageWorker(task: string, message: string, interrupt: boolean, toolUseId?: string): Promise<boolean>;
-    private emitUpdate;
-    private emitCompleted;
-    private handleStatusUpdate;
-    /**
-     * Create an async iterable stream of user messages for the worker.
-     * Yields the initial prompt, then streams any additional messages from the queue.
-     * If initialPrompt is empty, skips the initial yield and only consumes from the queue.
-     */
-    private createMessageStream;
-    private runWorker;
-    private handleMessage;
-    private extractAssistantText;
-    private extractDeltaText;
-    private extractError;
-    private wrapPrompt;
-    /**
-     * Shutdown the worker manager and cleanup all resources
-     * This should be called during application shutdown to ensure all worktrees are cleaned up
+     * Thin wrapper around enqueueMessage.
      */
+    toolMessageWorker(task: string, message: string): Promise<boolean>;
     shutdown(): Promise<void>;
-    /**
-     * Get the WorktreeManager instance
-     * @returns The WorktreeManager instance
-     */
-    getWorktreeManager(): WorktreeManager;
+    private onComplete;
+    onMessage(id: string, msg: MessageEnvelope): Promise<void>;
+    private commitWorkerChanges;
 }
-export {};

package/dist/orchestrator/worker-types.d.ts

@@ -0,0 +1,23 @@
+import type { MessageEnvelope } from '@omnara/shared-js/schemas';
+import type { Session } from './session.js';
+export type WorkerStatus = 'running' | 'completed' | 'error' | 'canceled';
+export interface WorkerRecord {
+    id: string;
+    task: string;
+    prompt: string;
+    sdkSessionId?: string | null;
+    status: WorkerStatus;
+    startedAt: number;
+    lastUpdateAt: number;
+    originSessionId?: string;
+    result?: string;
+    error?: string;
+    metadata?: Record<string, unknown>;
+    session?: Session;
+    worktreePath?: string;
+    worktreeName?: string;
+}
+export interface WorkerSessionMessageEvent {
+    record: WorkerRecord;
+    message: MessageEnvelope;
+}

package/dist/relay/relay-bridge.d.ts

@@ -39,10 +39,9 @@ export declare class RelayBridge extends EventEmitter {
     private ensureUserSession;
     private sendPrimarySessionInit;
     private sendFrame;
+    private handleOutboundControl;
     private handleWebsocketLifecycle;
-    private handleOutbound;
     private handleInbound;
-    private toRelayFrame;
     private tryHandleControlMessage;
     private tryHandleMessageEnvelope;
     private handleSessionBootstrap;
@@ -54,16 +53,9 @@ export declare class RelayBridge extends EventEmitter {
     private handleRelayRequest;
     private handleMessageEnvelope;
     private isTextContent;
-    private buildUserTextEnvelope;
-    private buildTextEnvelope;
-    private buildToolCallEnvelope;
-    private normalizeToolArguments;
-    private buildToolResultEnvelope;
-    private buildAgentCompleteEnvelope;
-    private buildProgressEnvelope;
-    private buildEnvelope;
     private isMessageEnvelope;
     private enqueue;
+    private sendSessionInitControl;
     private flushQueue;
     private startPingTimer;
     private clearLoginWait;

package/dist/utils/logger.d.ts

@@ -32,18 +32,28 @@ export declare function getLogLevel(): LogLevel;
 export interface Logger extends Console {
     important(...args: unknown[]): void;
     success(...args: unknown[]): void;
+    close?(): Promise<void>;
 }
 /**
  * Creates a controlled logger instance
  */
+type LogSink = (entry: {
+    line: string;
+    raw: unknown[];
+}) => void;
 export declare class ControlledLogger implements Logger {
     private logLevel;
     private forceOutput;
     private _console;
+    private sinks;
+    private closers;
+    private formatLine;
     Console: typeof console.Console;
     constructor(options?: {
         logLevel?: LogLevel;
         forceOutput?: boolean;
+        sinks?: LogSink[];
+        closers?: Array<() => Promise<void> | void>;
     });
     /**
      * Standard log output (INFO level)
@@ -78,10 +88,12 @@ export declare class ControlledLogger implements Logger {
      * Success messages that should typically be shown
      */
     success(...args: unknown[]): void;
+    close(): Promise<void>;
     /**
      * Check if a message should be logged at the given level
      */
     private shouldLog;
+    private write;
     /**
      * Update the log level dynamically
      */
@@ -117,6 +129,8 @@ export declare const logger: ControlledLogger;
 export declare function createLogger(componentName?: string, options?: {
     logLevel?: LogLevel;
     forceOutput?: boolean;
+    sinks?: LogSink[];
+    closers?: Array<() => Promise<void> | void>;
 }): Logger;
 /**
  * Helper to extract error messages consistently
@@ -126,3 +140,4 @@ export declare function extractErrorMessage(error: unknown): string;
  * Print current logger configuration (useful for debugging)
  */
 export declare function printLoggerConfig(): void;
+export {};

package/instrument.mjs

@@ -0,0 +1,14 @@
+import * as Sentry from '@sentry/node';
+
+const DEFAULT_DSN =
+  'https://ad24dca67a2ab987c433aba53f738743@o4509630021828608.ingest.us.sentry.io/4510413097467904';
+
+const dsn = process.env.OMNARA_SENTRY_DSN ?? process.env.SENTRY_DSN ?? DEFAULT_DSN;
+
+if (dsn) {
+  Sentry.init({
+    dsn,
+    environment: process.env.OMNARA_ENV ?? process.env.NODE_ENV ?? 'production',
+    sendDefaultPii: false,
+  });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "omnara",
-  "version": "0.2.3",
+  "version": "0.3.0",
   "type": "module",
   "description": "Command-line interface for Omnara.",
   "main": "dist/cli.js",
@@ -23,6 +23,7 @@
   "files": [
     "dist",
     "bin",
+    "instrument.mjs",
     "scripts",
     "README.md"
   ],
@@ -30,6 +31,7 @@
     "@anthropic-ai/claude-agent-sdk": "^0.1.42",
     "@anthropic-ai/sdk": "^0.67.0",
     "@modelcontextprotocol/sdk": "^1.20.1",
+    "@sentry/node": "^10.26.0",
     "@supabase/supabase-js": "^2.76.1",
     "@types/glob": "^8.1.0",
     "ajv": "^8.17.1",
@@ -48,6 +50,7 @@
     "@types/ws": "^8.18.1",
     "@typescript-eslint/eslint-plugin": "^8.46.2",
     "@typescript-eslint/parser": "^8.46.2",
+    "@vitest/ui": "^2.1.8",
     "esbuild": "^0.25.12",
     "eslint": "^9.38.0",
     "eslint-formatter-unix": "^8.40.0",
@@ -55,7 +58,8 @@
     "prettier": "^3.6.2",
     "tsx": "^4.7.0",
     "typescript": "^5.4.0",
-    "typescript-eslint": "^8.46.2"
+    "typescript-eslint": "^8.46.2",
+    "vitest": "^2.1.8"
   },
   "engines": {
     "node": ">=20"

package/scripts/test-preinstall.js

@@ -122,4 +122,3 @@ console.log('  2. Pack: npm pack');
 console.log('  3. Install: npm install -g omnara-0.1.4.tgz');
 console.log('  4. Verify: omnara --version');
 console.log('='.repeat(60));
-

package/dist/daemon/file-logger.d.ts

@@ -1,24 +0,0 @@
-import fs from 'node:fs';
-import { ControlledLogger, LogLevel } from '../utils/logger.js';
-export declare class FileBackedLogger extends ControlledLogger {
-    private readonly stream;
-    private closed;
-    constructor(stream: fs.WriteStream, options?: {
-        logLevel?: LogLevel;
-        forceOutput?: boolean;
-    });
-    log(...args: unknown[]): void;
-    info(...args: unknown[]): void;
-    debug(...args: unknown[]): void;
-    warn(...args: unknown[]): void;
-    error(...args: unknown[]): void;
-    trace(...args: unknown[]): void;
-    important(...args: unknown[]): void;
-    success(...args: unknown[]): void;
-    close(): Promise<void>;
-    private writeLine;
-}
-export declare function createDaemonFileLogger(): Promise<{
-    logger: FileBackedLogger;
-    logPath: string;
-}>;

package/dist/daemon/session-log-manager.d.ts

@@ -1,10 +0,0 @@
-import fs from 'node:fs';
-export interface SessionLogHandle {
-    stream: fs.WriteStream;
-    logPath: string;
-}
-export declare function createSessionLog(handle: {
-    workspaceId: string;
-    launchId: string;
-}): Promise<SessionLogHandle>;
-export declare function writeSessionLog(stream: fs.WriteStream, level: string, args: unknown[]): void;

package/dist/orchestrator/tools/worker-status-tool.d.ts

@@ -1,7 +0,0 @@
-export interface StatusUpdateEvent {
-    message: string;
-    metadata?: Record<string, unknown>;
-    timestamp: number;
-}
-export type StatusUpdateCallback = (event: StatusUpdateEvent) => void;
-export declare function createWorkerStatusMcpServer(onStatusUpdate: StatusUpdateCallback): import("@anthropic-ai/claude-agent-sdk").McpSdkServerConfigWithInstance;

package/dist/orchestrator/utils/async-queue.d.ts

@@ -1,26 +0,0 @@
-/**
- * A simple async queue for streaming messages to workers.
- * Allows pushing messages and consuming them via async iteration.
- */
-export declare class AsyncQueue<T> {
-    private queue;
-    private resolvers;
-    private closed;
-    /**
-     * Push a new item to the queue.
-     * If there are waiting consumers, resolve them immediately.
-     */
-    push(item: T): void;
-    /**
-     * Close the queue, signaling that no more items will be added.
-     */
-    close(): void;
-    /**
-     * Check if the queue is closed.
-     */
-    isClosed(): boolean;
-    /**
-     * Async iterator implementation for consuming items from the queue.
-     */
-    [Symbol.asyncIterator](): AsyncIterator<T>;
-}