omnara 0.1.10 → 0.2.0

package/dist/commands/agent.d.ts

@@ -1,7 +1,8 @@
-import { Command } from 'commander';
-export declare function buildAgentCommand(): Command;
 export interface OrchestratorOptions {
     backendUrl?: string;
     frontendUrl?: string;
+    workspaceId?: string;
+    userSessionId?: string;
+    agentSessionId?: string;
 }
 export declare function runAgentOrchestrator(options?: OrchestratorOptions): Promise<void>;

package/dist/commands/daemon.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function buildDaemonCommand(): Command;

package/dist/commands/index.d.ts

@@ -1,2 +1,3 @@
-export { buildAgentCommand, runAgentOrchestrator, type OrchestratorOptions } from './agent.js';
+export { runAgentOrchestrator, type OrchestratorOptions } from './agent.js';
 export { buildAuthCommand } from './auth.js';
+export { buildDaemonCommand } from './daemon.js';

package/dist/config/omnara-config.d.ts

@@ -1,22 +1,7 @@
 import * as z from 'zod';
+import type { WorkspaceConfigSchema } from '@omnara/shared-js/schemas';
+declare const OmnaraConfig: z.ZodType<WorkspaceConfigSchema.WorkspaceConfig>;
 export type OmnaraConfig = z.infer<typeof OmnaraConfig>;
-declare const OmnaraConfig: z.ZodObject<{
-    worktrees: z.ZodDefault<z.ZodObject<{
-        enabled: z.ZodDefault<z.ZodBoolean>;
-    }, "strip", z.ZodTypeAny, {
-        enabled: boolean;
-    }, {
-        enabled?: boolean | undefined;
-    }>>;
-}, "strip", z.ZodTypeAny, {
-    worktrees: {
-        enabled: boolean;
-    };
-}, {
-    worktrees?: {
-        enabled?: boolean | undefined;
-    } | undefined;
-}>;
 /**
  * Read and parse the omnara.jsonc configuration file
  *

package/dist/daemon/config-store.d.ts

@@ -0,0 +1,37 @@
+export interface DirectoryEntry {
+    id: string;
+    path: string;
+    label?: string;
+    addedAt: string;
+    lastUsedAt?: string;
+}
+export interface MachineMetadata {
+    id?: string;
+    name?: string;
+    token?: string;
+    lastSeenAt?: string;
+    tokenExpiresAt?: string;
+}
+export interface DaemonSettings {
+    maxSessions?: number;
+    autoUpdateCheckSeconds?: number;
+}
+export interface DaemonConfigData {
+    machine?: MachineMetadata;
+    directories: DirectoryEntry[];
+    settings?: DaemonSettings;
+}
+export declare class DaemonConfigStore {
+    private readonly filePath;
+    constructor(filePath?: string);
+    load(): Promise<DaemonConfigData>;
+    save(config: DaemonConfigData): Promise<void>;
+    update(mutate: (config: DaemonConfigData) => void | DaemonConfigData): Promise<DaemonConfigData>;
+    ensureDirectory(absolutePath: string, options?: {
+        label?: string;
+        touch?: boolean;
+    }): Promise<{
+        entry: DirectoryEntry;
+        created: boolean;
+    }>;
+}

package/dist/daemon/daemon-client.d.ts

@@ -0,0 +1,26 @@
+import type { DirectoryEntry } from './config-store.js';
+import type { DaemonStatusPayload, LaunchWorkspaceResult } from './local-control-server.js';
+import { DaemonStateStore } from './state-store.js';
+import type { MachineMessageSchema } from '../../../shared-js/dist/schemas/generated.js';
+export declare class DaemonClient {
+    private readonly stateStore;
+    constructor(stateStore?: DaemonStateStore);
+    getStatus(): Promise<DaemonStatusPayload | null>;
+    addDirectory(directoryPath: string, label?: string): Promise<{
+        directory: DirectoryEntry;
+        created: boolean;
+    } | null>;
+    stop(status?: Exclude<MachineMessageSchema.MachineStatus, 'ONLINE'>): Promise<boolean>;
+    launchSession(options: {
+        path: string;
+        initialPrompt?: string;
+        userSessionId?: string;
+    }): Promise<LaunchWorkspaceResult | null>;
+    private getEndpoint;
+    private request;
+}
+export declare class HttpError extends Error {
+    readonly statusCode: number;
+    readonly body?: string | undefined;
+    constructor(message: string, statusCode: number, body?: string | undefined);
+}

package/dist/daemon/daemon-launcher.d.ts

@@ -0,0 +1,30 @@
+import type { Logger } from '../utils/logger.js';
+export interface StartDaemonOptions {
+    waitForReady?: boolean;
+    reason?: string;
+    backendUrl?: string;
+    frontendUrl?: string;
+    logger?: Logger;
+}
+export interface StopDaemonOptions {
+    logger?: Logger;
+}
+export interface EnsureDaemonOptions {
+    cwd?: string;
+    label?: string;
+    reason?: string;
+    backendUrl?: string;
+    frontendUrl?: string;
+    logger?: Logger;
+}
+export interface StatusOptions {
+    logger?: Logger;
+}
+export interface KillAllOptions {
+    logger?: Logger;
+}
+export declare function ensureDaemonForSession(options?: EnsureDaemonOptions): Promise<void>;
+export declare function startDaemon(options?: StartDaemonOptions): Promise<boolean>;
+export declare function stopDaemon(options?: StopDaemonOptions): Promise<boolean>;
+export declare function showDaemonStatus(options?: StatusOptions): Promise<void>;
+export declare function killAllDaemonProcesses(options?: KillAllOptions): Promise<void>;

package/dist/daemon/daemon-service.d.ts

@@ -0,0 +1,30 @@
+import type { Logger } from '../utils/logger.js';
+import { DirectoryRegistry } from './directory-registry.js';
+import { DaemonStateStore } from './state-store.js';
+import { MachineSupervisor } from './machine-supervisor.js';
+import type { MachineMessageSchema } from '../../../shared-js/dist/schemas/generated.js';
+export interface DaemonServiceOptions {
+    directoryRegistry?: DirectoryRegistry;
+    stateStore?: DaemonStateStore;
+    machineSupervisor?: MachineSupervisor;
+    logger?: Logger;
+}
+export declare class DaemonService {
+    private readonly logger;
+    private readonly directoryRegistry;
+    private readonly stateStore;
+    private readonly machineSupervisor;
+    private controlHandle;
+    private startedAt;
+    private stopPromise;
+    private resolveStopPromise;
+    private stopping;
+    constructor(options?: DaemonServiceOptions);
+    start(): Promise<void>;
+    stop(status?: Exclude<MachineMessageSchema.MachineStatus, 'ONLINE'>): Promise<void>;
+    waitForShutdown(): Promise<void>;
+    private buildStatusPayload;
+    private handleLaunchRequest;
+    private persistState;
+    private cleanupState;
+}

package/dist/daemon/directory-registry.d.ts

@@ -0,0 +1,17 @@
+import { DaemonConfigStore, type DirectoryEntry } from './config-store.js';
+export interface DirectoryEnsureOptions {
+    label?: string;
+    updateLastUsed?: boolean;
+    skipValidation?: boolean;
+}
+export declare class DirectoryRegistry {
+    private readonly store;
+    constructor(store?: DaemonConfigStore);
+    list(): Promise<DirectoryEntry[]>;
+    getEntry(directoryPath: string): Promise<DirectoryEntry | null>;
+    ensureDirectory(directoryPath: string, options?: DirectoryEnsureOptions): Promise<{
+        entry: DirectoryEntry;
+        created: boolean;
+    }>;
+    private assertDirectory;
+}

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

@@ -0,0 +1,24 @@
+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/local-control-server.d.ts

@@ -0,0 +1,37 @@
+import type { Logger } from '../utils/logger.js';
+import type { DirectoryEntry } from './config-store.js';
+import { DirectoryRegistry } from './directory-registry.js';
+import type { MachineMessageSchema } from '../../../shared-js/dist/schemas/generated.js';
+export interface DaemonStatusPayload {
+    pid: number;
+    startedAt: string;
+    directories: DirectoryEntry[];
+}
+export interface LocalControlServerOptions {
+    directoryRegistry: DirectoryRegistry;
+    getStatus: () => Promise<DaemonStatusPayload>;
+    onStopRequested: (status: Exclude<MachineMessageSchema.MachineStatus, 'ONLINE'>) => Promise<void> | void;
+    onLaunchRequested?: (payload: LaunchWorkspacePayload) => Promise<LaunchWorkspaceResult>;
+    logger?: Logger;
+}
+export interface LocalControlServerHandle {
+    port: number;
+    token: string;
+    close(): Promise<void>;
+}
+export interface LaunchWorkspacePayload {
+    path: string;
+    initialPrompt?: string;
+    userSessionId?: string;
+}
+export interface LaunchWorkspaceSuccessPayload {
+    user_session_id: string;
+    workspace_id: string;
+    launch_id: string;
+}
+export interface LaunchWorkspaceResult {
+    status: 'ok' | 'error' | string;
+    payload?: LaunchWorkspaceSuccessPayload | null;
+    error?: string;
+}
+export declare function startLocalControlServer(options: LocalControlServerOptions): Promise<LocalControlServerHandle>;

package/dist/daemon/machine-supervisor.d.ts

@@ -0,0 +1,60 @@
+import type { Logger } from '../utils/logger.js';
+import { DirectoryRegistry } from './directory-registry.js';
+import { DaemonConfigStore } from './config-store.js';
+import type { AuthProvider } from '../auth/auth-provider.js';
+import type { LaunchWorkspaceResult } from './local-control-server.js';
+import type { MachineMessageSchema } from '../../../shared-js/dist/schemas/generated.js';
+export interface MachineSupervisorOptions {
+    backendUrl: string;
+    frontendUrl?: string;
+    directoryRegistry: DirectoryRegistry;
+    configStore: DaemonConfigStore;
+    authProvider: AuthProvider;
+    logger?: Logger;
+}
+export declare class MachineSupervisor {
+    private readonly backendUrl;
+    private readonly frontendUrl?;
+    private readonly directoryRegistry;
+    private readonly configStore;
+    private readonly authProvider;
+    private readonly apiClient;
+    private readonly logger;
+    private readonly sessionManager;
+    private running;
+    private stopRequested;
+    private loopPromise;
+    private websocket;
+    private heartbeatTimer;
+    private waitingForLogin;
+    private machineRegistrationReady;
+    constructor(options: MachineSupervisorOptions);
+    start(): Promise<void>;
+    launchWorkspaceSessionLocal(options: {
+        path: string;
+        initialPrompt?: string;
+        userSessionId?: string;
+    }): Promise<LaunchWorkspaceResult>;
+    stop(status: Exclude<MachineMessageSchema.MachineStatus, 'ONLINE'>): Promise<void>;
+    private runLoop;
+    private registerMachine;
+    private runWebsocket;
+    private handleSocketMessage;
+    private handleRpcRequest;
+    private sendRpcResponse;
+    private launchWorkspaceSessionFromRpc;
+    private launchWorkspaceSession;
+    private ensureWorkspaceForDirectory;
+    private ensureWorkspaceWithRetry;
+    private ensureUserSessionForWorkspace;
+    private buildWorkspaceMetadata;
+    private getMachineId;
+    private waitForMachineRegistration;
+    private startHeartbeatTimer;
+    private clearHeartbeatTimer;
+    private sendHeartbeat;
+    private sendMessage;
+    private clearLoginWait;
+    private closeWebsocket;
+    private recoverMachineRegistration;
+}

package/dist/daemon/paths.d.ts

@@ -0,0 +1,9 @@
+export declare const OMNARA_HOME_DIR: string;
+export declare const DAEMON_CONFIG_PATH: string;
+export declare const DAEMON_STATE_PATH: string;
+export declare const DAEMON_LOG_DIR: string;
+export declare const USER_SESSION_LOG_ROOT: string;
+export declare const DEFAULT_DIR_MODE = 448;
+export declare const DEFAULT_FILE_MODE = 384;
+export declare function ensureOmnaraHome(): Promise<void>;
+export declare function ensureDirectory(dirPath: string): Promise<void>;

package/dist/daemon/run-daemon.d.ts

@@ -0,0 +1 @@
+export declare function runDaemonProcess(): Promise<void>;

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

@@ -0,0 +1,10 @@
+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/daemon/session-pid-registry.d.ts

@@ -0,0 +1,5 @@
+export interface SessionRegistry {
+    [userSessionId: string]: number;
+}
+export declare function withSessionRegistry<T>(fn: (registry: SessionRegistry) => Promise<[SessionRegistry, T]> | [SessionRegistry, T]): Promise<T>;
+export declare function isProcessAlive(pid: number): Promise<boolean>;

package/dist/daemon/session-runner.d.ts

@@ -0,0 +1,28 @@
+import type { Logger } from '../utils/logger.js';
+import type { WorkspaceConfig } from '@omnara/shared-js/schemas';
+import { DirectoryRegistry } from './directory-registry.js';
+export interface SessionManagerOptions {
+    backendUrl: string;
+    frontendUrl?: string;
+    directoryRegistry: DirectoryRegistry;
+    logger: Logger;
+}
+export interface SessionLaunchSpec {
+    launchId: string;
+    directory: string;
+    userSessionId: string;
+    workspaceId: string;
+    workspaceConfig?: WorkspaceConfig | null;
+    initialPrompt?: string | null;
+    metadata?: Record<string, unknown> | null;
+}
+export declare class SessionManager {
+    private readonly backendUrl;
+    private readonly frontendUrl?;
+    private readonly directoryRegistry;
+    private readonly logger;
+    private readonly runners;
+    constructor(options: SessionManagerOptions);
+    startSession(spec: SessionLaunchSpec): Promise<void>;
+    stopAll(): Promise<void>;
+}

package/dist/daemon/state-store.d.ts

@@ -0,0 +1,14 @@
+export interface DaemonStateData {
+    pid: number;
+    port: number;
+    token: string;
+    startedAt: string;
+    version?: string;
+}
+export declare class DaemonStateStore {
+    private readonly filePath;
+    constructor(filePath?: string);
+    load(): Promise<DaemonStateData | null>;
+    save(state: DaemonStateData): Promise<void>;
+    clear(): Promise<void>;
+}

package/dist/http/machines.d.ts

@@ -0,0 +1,3 @@
+import { ApiClient } from './api-client.js';
+import type { MachineRegisterRequest, MachineRegisterResponse } from '@omnara/shared-js/schemas';
+export declare function registerMachine(client: ApiClient, accessToken: string, payload: MachineRegisterRequest): Promise<MachineRegisterResponse>;

package/dist/http/user-sessions.d.ts

@@ -7,7 +7,10 @@ export interface UserSessionDescriptor {
     name?: string | null;
     metadata?: Record<string, unknown> | null;
 }
-export declare function createUserSession(client: ApiClient, accessToken: string, options?: {
+export interface EnsureUserSessionOptions {
+    workspaceId: string;
+    userSessionId?: string;
     name?: string;
     metadata?: Record<string, unknown>;
-}): Promise<UserSessionDescriptor>;
+}
+export declare function ensureUserSession(client: ApiClient, accessToken: string, options: EnsureUserSessionOptions): Promise<UserSessionDescriptor>;

package/dist/http/workspaces.d.ts

@@ -0,0 +1,4 @@
+import type { WorkspaceDescriptor, WorkspaceEnsureRequest, WorkspaceSessionLaunchRequest, WorkspaceSessionLaunchResponse } from '@omnara/shared-js/schemas';
+import { ApiClient } from './api-client.js';
+export declare function ensureWorkspace(client: ApiClient, accessToken: string, payload: WorkspaceEnsureRequest): Promise<WorkspaceDescriptor>;
+export declare function launchWorkspaceSession(client: ApiClient, accessToken: string, workspaceId: string, payload: WorkspaceSessionLaunchRequest): Promise<WorkspaceSessionLaunchResponse>;

package/dist/orchestrator/agent-orchestrator.d.ts

@@ -2,12 +2,15 @@ import { type AgentClient } from './ai-client.js';
 import { Session } from './session.js';
 import { WorkerManager } from './worker-manager.js';
 import type { InboundMessage, OutboundMessage } from './orchestrator-types.js';
-import type { McpServerConfig } from '@anthropic-ai/claude-agent-sdk';
+import { type McpServerConfig } from '@anthropic-ai/claude-agent-sdk';
+import type { ControlMessageSchema } from '@omnara/shared-js/schemas';
 interface AgentOrchestratorDependencies {
     createMainClient?: () => AgentClient;
     createWorkerClient?: (mcpServers?: Record<string, McpServerConfig>, cwd?: string) => AgentClient;
     workerManager?: WorkerManager;
     repoPath?: string;
+    worktreesEnabled?: boolean;
+    worktreesBaseRef?: string;
 }
 export interface AgentOrchestratorClientAdapter {
     send: (message: OutboundMessage) => void;
@@ -20,6 +23,7 @@ export interface AgentOrchestratorConnection {
     disconnect(): void;
 }
 export declare class AgentOrchestrator {
+    private readonly completionsManager;
     private readonly aiClient;
     private readonly workerManager;
     private readonly sessions;
@@ -36,6 +40,7 @@ export declare class AgentOrchestrator {
     addClient(adapter: AgentOrchestratorClientAdapter): AgentOrchestratorConnection;
     start(): Promise<void>;
     stop(): Promise<void>;
+    cancel(): Promise<void>;
     private handleDisconnect;
     private handleClientMessage;
     private handleSessionInit;
@@ -62,6 +67,7 @@ export declare class AgentOrchestrator {
     private broadcastToAll;
     private findSessionIdBySdkSession;
     private sendToConnection;
+    getCompletions(request: ControlMessageSchema.CompletionsRequest): Promise<ControlMessageSchema.CompletionsResponse>;
 }
 export declare function startAgentOrchestrator(dependencies?: AgentOrchestratorDependencies): Promise<AgentOrchestrator>;
 export {};

package/dist/orchestrator/ai-client.d.ts

@@ -5,13 +5,16 @@ export interface AIClientConfig {
 export interface AgentClient {
     streamUserMessage(prompt: string, overrides?: Partial<Options>): AsyncIterable<SDKMessage>;
     createQuery(prompt: string | AsyncIterable<SDKUserMessage>, overrides?: Partial<Options>): Query;
+    cancel(): Promise<void>;
 }
 export declare const BASE_ALLOWED_ORCHESTRATOR_TOOLS: readonly ["Glob", "Grep", "LS", "Read", "WebFetch", "WebSearch", "TodoWrite"];
 export declare const BASE_ALLOWED_WORKER_TOOLS: readonly ["Task", "Bash", "Glob", "Grep", "LS", "ExitPlanMode", "Read", "Edit", "MultiEdit", "Write", "NotebookEdit", "WebFetch", "TodoWrite", "WebSearch", "BashOutput", "KillBash", "Skill", "SlashCommand"];
 export declare class AIClient implements AgentClient {
     private readonly baseOptions;
+    private runningQuery?;
     constructor(config?: AIClientConfig);
     streamUserMessage(prompt: string, overrides?: Partial<Options>): AsyncIterable<SDKMessage>;
     createQuery(prompt: string | AsyncIterable<SDKUserMessage>, overrides?: Partial<Options>): Query;
+    cancel(): Promise<void>;
     private ensureWorkingDirectory;
 }