@elizaos/ui 2.0.0-alpha.25 → 2.0.0-alpha.334

package/packages/typescript/src/services/onboarding-rpc.d.ts

@@ -0,0 +1,225 @@
+/**
+ * Onboarding RPC Methods
+ *
+ * Provides RPC methods for native apps (macOS, iOS) to interact with
+ * the onboarding wizard programmatically.
+ *
+ * Methods:
+ * - wizard.start: Start onboarding, returns initial state
+ * - wizard.step: Advance to next step with input
+ * - wizard.getState: Get current state
+ * - wizard.cancel: Abort onboarding
+ */
+import { type OnboardingContext, type OnboardingInput, type OnboardingProgress, OnboardingStep, type SerializedOnboardingState } from "../types/onboarding";
+import type { UUID } from "../types/primitives";
+/**
+ * RPC method names.
+ */
+export declare const WIZARD_RPC_METHODS: {
+    readonly START: "wizard.start";
+    readonly STEP: "wizard.step";
+    readonly GET_STATE: "wizard.getState";
+    readonly CANCEL: "wizard.cancel";
+    readonly GO_BACK: "wizard.goBack";
+    readonly SKIP: "wizard.skip";
+};
+/**
+ * Parameters for wizard.start RPC.
+ */
+export interface WizardStartParams {
+    /** World ID for context */
+    worldId?: UUID;
+    /** User ID being onboarded */
+    userId?: UUID;
+    /** Platform identifier */
+    platform?: string;
+    /** Restore from existing state if available */
+    restoreState?: SerializedOnboardingState;
+}
+/**
+ * Result of wizard.start RPC.
+ */
+export interface WizardStartResult {
+    /** Whether start was successful */
+    success: boolean;
+    /** Session ID for subsequent calls */
+    sessionId: string;
+    /** Initial state */
+    state: WizardState;
+    /** Error message if failed */
+    error?: string;
+}
+/**
+ * Parameters for wizard.step RPC.
+ */
+export interface WizardStepParams {
+    /** Session ID from wizard.start */
+    sessionId: string;
+    /** Input for the current step */
+    input: OnboardingInput;
+}
+/**
+ * Result of wizard.step RPC.
+ */
+export interface WizardStepResult {
+    /** Whether step was successful */
+    success: boolean;
+    /** Updated state after step */
+    state: WizardState;
+    /** Error if step failed */
+    error?: string;
+    /** Message for the user */
+    message?: string;
+}
+/**
+ * Parameters for wizard.getState RPC.
+ */
+export interface WizardGetStateParams {
+    /** Session ID from wizard.start */
+    sessionId: string;
+}
+/**
+ * Result of wizard.getState RPC.
+ */
+export interface WizardGetStateResult {
+    /** Whether request was successful */
+    success: boolean;
+    /** Current state */
+    state?: WizardState;
+    /** Error if request failed */
+    error?: string;
+}
+/**
+ * Parameters for wizard.cancel RPC.
+ */
+export interface WizardCancelParams {
+    /** Session ID from wizard.start */
+    sessionId: string;
+    /** Whether to save partial progress */
+    saveProgress?: boolean;
+}
+/**
+ * Result of wizard.cancel RPC.
+ */
+export interface WizardCancelResult {
+    /** Whether cancel was successful */
+    success: boolean;
+    /** Serialized state if saveProgress was true */
+    savedState?: SerializedOnboardingState;
+    /** Error if cancel failed */
+    error?: string;
+}
+/**
+ * Parameters for wizard.goBack RPC.
+ */
+export interface WizardGoBackParams {
+    /** Session ID from wizard.start */
+    sessionId: string;
+    /** Target step to go back to (optional, defaults to previous) */
+    targetStep?: OnboardingStep;
+}
+/**
+ * Parameters for wizard.skip RPC.
+ */
+export interface WizardSkipParams {
+    /** Session ID from wizard.start */
+    sessionId: string;
+}
+/**
+ * Wizard state for RPC responses.
+ */
+export interface WizardState {
+    /** Current step */
+    currentStep: OnboardingStep;
+    /** Step label for display */
+    currentStepLabel: string;
+    /** Step description */
+    currentStepDescription: string;
+    /** Progress information */
+    progress: OnboardingProgress;
+    /** Whether onboarding is complete */
+    isComplete: boolean;
+    /** Full context */
+    context: OnboardingContext;
+    /** Available actions for current step */
+    availableActions: string[];
+}
+/**
+ * Callback for wizard state changes (for WebSocket events).
+ */
+export type WizardStateChangeCallback = (sessionId: string, oldState: WizardState, newState: WizardState) => void;
+/**
+ * Onboarding RPC Service
+ *
+ * Manages wizard sessions and handles RPC calls from native apps.
+ */
+export declare class OnboardingRPCService {
+    /** Active wizard sessions keyed by session ID */
+    private sessions;
+    /** State change callbacks for WebSocket notifications */
+    private stateChangeCallbacks;
+    /**
+     * Register a callback for state changes.
+     */
+    onStateChange(callback: WizardStateChangeCallback): () => void;
+    /**
+     * Notify all callbacks of a state change.
+     */
+    private notifyStateChange;
+    /**
+     * Convert context to wizard state.
+     */
+    private toWizardState;
+    /**
+     * Handle wizard.start RPC.
+     */
+    start(params: WizardStartParams): Promise<WizardStartResult>;
+    /**
+     * Handle wizard.step RPC.
+     */
+    step(params: WizardStepParams): Promise<WizardStepResult>;
+    /**
+     * Handle wizard.getState RPC.
+     */
+    getState(params: WizardGetStateParams): WizardGetStateResult;
+    /**
+     * Handle wizard.cancel RPC.
+     */
+    cancel(params: WizardCancelParams): WizardCancelResult;
+    /**
+     * Handle wizard.goBack RPC.
+     */
+    goBack(params: WizardGoBackParams): WizardStepResult;
+    /**
+     * Handle wizard.skip RPC.
+     */
+    skip(params: WizardSkipParams): Promise<WizardStepResult>;
+    /**
+     * Get all active session IDs.
+     */
+    getActiveSessions(): string[];
+    /**
+     * Check if a session exists.
+     */
+    hasSession(sessionId: string): boolean;
+    /**
+     * Clean up all sessions.
+     */
+    dispose(): void;
+}
+/**
+ * Create a new OnboardingRPCService instance.
+ */
+export declare function createOnboardingRPCService(): OnboardingRPCService;
+/**
+ * Helper to create RPC method handlers for integration with existing RPC systems.
+ */
+export declare function createWizardRPCHandlers(service: OnboardingRPCService): {
+    "wizard.start": (params: WizardStartParams) => Promise<WizardStartResult>;
+    "wizard.step": (params: WizardStepParams) => Promise<WizardStepResult>;
+    "wizard.getState": (params: WizardGetStateParams) => WizardGetStateResult;
+    "wizard.cancel": (params: WizardCancelParams) => WizardCancelResult;
+    "wizard.goBack": (params: WizardGoBackParams) => WizardStepResult;
+    "wizard.skip": (params: WizardSkipParams) => Promise<WizardStepResult>;
+};
+//# sourceMappingURL=onboarding-rpc.d.ts.map

package/packages/typescript/src/services/onboarding-rpc.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"onboarding-rpc.d.ts","sourceRoot":"","sources":["../../../../../../typescript/src/services/onboarding-rpc.ts"],"names":[],"mappings":"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"}

package/packages/typescript/src/services/onboarding-rpc.js

@@ -0,0 +1,318 @@
+/**
+ * Onboarding RPC Methods
+ *
+ * Provides RPC methods for native apps (macOS, iOS) to interact with
+ * the onboarding wizard programmatically.
+ *
+ * Methods:
+ * - wizard.start: Start onboarding, returns initial state
+ * - wizard.step: Advance to next step with input
+ * - wizard.getState: Get current state
+ * - wizard.cancel: Abort onboarding
+ */
+import { logger } from "../logger";
+import { ONBOARDING_STEP_DESCRIPTIONS, ONBOARDING_STEP_LABELS, OnboardingStep, } from "../types/onboarding";
+import { OnboardingStateMachine, } from "./onboarding-state";
+/**
+ * RPC method names.
+ */
+export const WIZARD_RPC_METHODS = {
+    START: "wizard.start",
+    STEP: "wizard.step",
+    GET_STATE: "wizard.getState",
+    CANCEL: "wizard.cancel",
+    GO_BACK: "wizard.goBack",
+    SKIP: "wizard.skip",
+};
+/**
+ * Onboarding RPC Service
+ *
+ * Manages wizard sessions and handles RPC calls from native apps.
+ */
+export class OnboardingRPCService {
+    /** Active wizard sessions keyed by session ID */
+    sessions = new Map();
+    /** State change callbacks for WebSocket notifications */
+    stateChangeCallbacks = new Set();
+    /**
+     * Register a callback for state changes.
+     */
+    onStateChange(callback) {
+        this.stateChangeCallbacks.add(callback);
+        return () => this.stateChangeCallbacks.delete(callback);
+    }
+    /**
+     * Notify all callbacks of a state change.
+     */
+    notifyStateChange(sessionId, oldState, newState) {
+        for (const callback of this.stateChangeCallbacks) {
+            try {
+                callback(sessionId, oldState, newState);
+            }
+            catch (err) {
+                logger.error({ err, sessionId }, "[OnboardingRPCService] Error in state change callback");
+            }
+        }
+    }
+    /**
+     * Convert context to wizard state.
+     */
+    toWizardState(machine) {
+        const context = machine.getContext();
+        const currentStep = context.currentStep;
+        // Determine available actions based on current step
+        const availableActions = ["cancel"];
+        if (currentStep !== OnboardingStep.WELCOME) {
+            availableActions.push("goBack");
+        }
+        if (currentStep !== OnboardingStep.WELCOME &&
+            currentStep !== OnboardingStep.RISK_ACK &&
+            currentStep !== OnboardingStep.COMPLETE) {
+            availableActions.push("skip");
+        }
+        if (currentStep !== OnboardingStep.COMPLETE) {
+            availableActions.push("advance");
+        }
+        return {
+            currentStep,
+            currentStepLabel: ONBOARDING_STEP_LABELS[currentStep],
+            currentStepDescription: ONBOARDING_STEP_DESCRIPTIONS[currentStep],
+            progress: machine.getProgress(),
+            isComplete: currentStep === OnboardingStep.COMPLETE,
+            context,
+            availableActions,
+        };
+    }
+    /**
+     * Handle wizard.start RPC.
+     */
+    async start(params) {
+        try {
+            const config = {
+                platform: params.platform || "wizard",
+                mode: "wizard",
+                worldId: params.worldId,
+                userId: params.userId,
+                onStepChange: (_oldStep, newStep, context) => {
+                    const machine = this.sessions.get(context.sessionId);
+                    if (machine) {
+                        const oldState = this.toWizardState(machine);
+                        // Need to create a temporary new state
+                        const newState = { ...oldState, currentStep: newStep };
+                        this.notifyStateChange(context.sessionId, oldState, newState);
+                    }
+                },
+            };
+            let machine;
+            if (params.restoreState) {
+                // Restore from existing state
+                machine = OnboardingStateMachine.fromJSON(params.restoreState, config);
+                logger.info({ sessionId: machine.getContext().sessionId }, "[OnboardingRPCService] Restored wizard session");
+            }
+            else {
+                // Create new session
+                machine = new OnboardingStateMachine(config);
+                logger.info({ sessionId: machine.getContext().sessionId }, "[OnboardingRPCService] Started new wizard session");
+            }
+            const sessionId = machine.getContext().sessionId;
+            this.sessions.set(sessionId, machine);
+            return {
+                success: true,
+                sessionId,
+                state: this.toWizardState(machine),
+            };
+        }
+        catch (err) {
+            logger.error({ err }, "[OnboardingRPCService] Error starting wizard");
+            return {
+                success: false,
+                sessionId: "",
+                state: {},
+                error: err instanceof Error ? err.message : String(err),
+            };
+        }
+    }
+    /**
+     * Handle wizard.step RPC.
+     */
+    async step(params) {
+        const machine = this.sessions.get(params.sessionId);
+        if (!machine) {
+            return {
+                success: false,
+                state: {},
+                error: `Session not found: ${params.sessionId}`,
+            };
+        }
+        try {
+            const oldState = this.toWizardState(machine);
+            const result = await machine.advanceStep(params.input);
+            const newState = this.toWizardState(machine);
+            if (result.success) {
+                this.notifyStateChange(params.sessionId, oldState, newState);
+            }
+            return {
+                success: result.success,
+                state: newState,
+                error: result.error?.message,
+                message: result.message,
+            };
+        }
+        catch (err) {
+            logger.error({ err, sessionId: params.sessionId }, "[OnboardingRPCService] Error processing step");
+            return {
+                success: false,
+                state: this.toWizardState(machine),
+                error: err instanceof Error ? err.message : String(err),
+            };
+        }
+    }
+    /**
+     * Handle wizard.getState RPC.
+     */
+    getState(params) {
+        const machine = this.sessions.get(params.sessionId);
+        if (!machine) {
+            return {
+                success: false,
+                error: `Session not found: ${params.sessionId}`,
+            };
+        }
+        return {
+            success: true,
+            state: this.toWizardState(machine),
+        };
+    }
+    /**
+     * Handle wizard.cancel RPC.
+     */
+    cancel(params) {
+        const machine = this.sessions.get(params.sessionId);
+        if (!machine) {
+            return {
+                success: false,
+                error: `Session not found: ${params.sessionId}`,
+            };
+        }
+        let savedState;
+        if (params.saveProgress) {
+            savedState = machine.toJSON();
+        }
+        // Clean up session
+        this.sessions.delete(params.sessionId);
+        logger.info({ sessionId: params.sessionId, savedProgress: params.saveProgress }, "[OnboardingRPCService] Cancelled wizard session");
+        return {
+            success: true,
+            savedState,
+        };
+    }
+    /**
+     * Handle wizard.goBack RPC.
+     */
+    goBack(params) {
+        const machine = this.sessions.get(params.sessionId);
+        if (!machine) {
+            return {
+                success: false,
+                state: {},
+                error: `Session not found: ${params.sessionId}`,
+            };
+        }
+        try {
+            const oldState = this.toWizardState(machine);
+            const result = machine.goBack(params.targetStep);
+            const newState = this.toWizardState(machine);
+            if (result.success) {
+                this.notifyStateChange(params.sessionId, oldState, newState);
+            }
+            return {
+                success: result.success,
+                state: newState,
+                error: result.error?.message,
+                message: result.message,
+            };
+        }
+        catch (err) {
+            logger.error({ err, sessionId: params.sessionId }, "[OnboardingRPCService] Error going back");
+            return {
+                success: false,
+                state: this.toWizardState(machine),
+                error: err instanceof Error ? err.message : String(err),
+            };
+        }
+    }
+    /**
+     * Handle wizard.skip RPC.
+     */
+    async skip(params) {
+        const machine = this.sessions.get(params.sessionId);
+        if (!machine) {
+            return {
+                success: false,
+                state: {},
+                error: `Session not found: ${params.sessionId}`,
+            };
+        }
+        try {
+            const oldState = this.toWizardState(machine);
+            const result = await machine.skipStep();
+            const newState = this.toWizardState(machine);
+            if (result.success) {
+                this.notifyStateChange(params.sessionId, oldState, newState);
+            }
+            return {
+                success: result.success,
+                state: newState,
+                error: result.error?.message,
+                message: result.message,
+            };
+        }
+        catch (err) {
+            logger.error({ err, sessionId: params.sessionId }, "[OnboardingRPCService] Error skipping step");
+            return {
+                success: false,
+                state: this.toWizardState(machine),
+                error: err instanceof Error ? err.message : String(err),
+            };
+        }
+    }
+    /**
+     * Get all active session IDs.
+     */
+    getActiveSessions() {
+        return Array.from(this.sessions.keys());
+    }
+    /**
+     * Check if a session exists.
+     */
+    hasSession(sessionId) {
+        return this.sessions.has(sessionId);
+    }
+    /**
+     * Clean up all sessions.
+     */
+    dispose() {
+        this.sessions.clear();
+        this.stateChangeCallbacks.clear();
+        logger.info("[OnboardingRPCService] Disposed all sessions");
+    }
+}
+/**
+ * Create a new OnboardingRPCService instance.
+ */
+export function createOnboardingRPCService() {
+    return new OnboardingRPCService();
+}
+/**
+ * Helper to create RPC method handlers for integration with existing RPC systems.
+ */
+export function createWizardRPCHandlers(service) {
+    return {
+        [WIZARD_RPC_METHODS.START]: async (params) => service.start(params),
+        [WIZARD_RPC_METHODS.STEP]: async (params) => service.step(params),
+        [WIZARD_RPC_METHODS.GET_STATE]: (params) => service.getState(params),
+        [WIZARD_RPC_METHODS.CANCEL]: (params) => service.cancel(params),
+        [WIZARD_RPC_METHODS.GO_BACK]: (params) => service.goBack(params),
+        [WIZARD_RPC_METHODS.SKIP]: async (params) => service.skip(params),
+    };
+}

package/packages/typescript/src/services/onboarding-state.d.ts

@@ -0,0 +1,155 @@
+/**
+ * Onboarding State Machine
+ *
+ * A state machine for onboarding that can be driven by CLI prompts
+ * OR chat messages. Handles step transitions, validation, and persistence.
+ */
+import { type OnboardingContext, type OnboardingInput, type OnboardingProgress, type OnboardingResult, type OnboardingSettings, OnboardingStep, type OnboardingStepError, type SerializedOnboardingState } from "../types/onboarding";
+import type { UUID } from "../types/primitives";
+/**
+ * Step handler function type.
+ */
+type StepHandler<T> = (data: T, context: OnboardingContext) => Promise<OnboardingResult>;
+/**
+ * Configuration options for the state machine.
+ */
+export interface OnboardingStateMachineConfig {
+    /** Platform identifier (cli, discord, telegram, etc.) */
+    platform: string;
+    /** Onboarding mode */
+    mode: "cli" | "conversational" | "wizard";
+    /** World ID for persistence */
+    worldId?: UUID;
+    /** User ID being onboarded */
+    userId?: UUID;
+    /** Optional existing context to restore from */
+    existingContext?: OnboardingContext;
+    /** Callback when step changes */
+    onStepChange?: (oldStep: OnboardingStep, newStep: OnboardingStep, context: OnboardingContext) => void | Promise<void>;
+    /** Callback when onboarding completes */
+    onComplete?: (context: OnboardingContext) => void | Promise<void>;
+    /** Callback when an error occurs */
+    onError?: (error: OnboardingStepError, context: OnboardingContext) => void;
+}
+/**
+ * Onboarding State Machine.
+ *
+ * Manages the onboarding flow across CLI and conversational interfaces.
+ * Supports step progression, validation, persistence, and event callbacks.
+ *
+ * @example
+ * ```typescript
+ * const machine = new OnboardingStateMachine({
+ *   platform: 'cli',
+ *   mode: 'cli',
+ *   onComplete: (ctx) => console.log('Onboarding complete!')
+ * });
+ *
+ * // Advance through steps
+ * await machine.advanceStep({ step: OnboardingStep.WELCOME, data: { acknowledged: true } });
+ * await machine.advanceStep({ step: OnboardingStep.RISK_ACK, data: { accepted: true } });
+ * // ...
+ * ```
+ */
+export declare class OnboardingStateMachine {
+    private context;
+    private config;
+    private stepHandlers;
+    constructor(config: OnboardingStateMachineConfig);
+    /**
+     * Create the initial context for a new onboarding session.
+     */
+    private createInitialContext;
+    /**
+     * Register the default step handlers.
+     */
+    private registerDefaultHandlers;
+    /**
+     * Get the current onboarding step.
+     */
+    getCurrentStep(): OnboardingStep;
+    /**
+     * Get the full onboarding context.
+     */
+    getContext(): OnboardingContext;
+    /**
+     * Get the current settings.
+     */
+    getSettings(): OnboardingSettings;
+    /**
+     * Check if we can advance from the current step.
+     */
+    canAdvance(): boolean;
+    /**
+     * Get the completion progress.
+     */
+    getProgress(): OnboardingProgress;
+    /**
+     * Process input and advance to the next step.
+     */
+    advanceStep(input: OnboardingInput): Promise<OnboardingResult>;
+    /**
+     * Skip the current step (if allowed).
+     */
+    skipStep(): Promise<OnboardingResult>;
+    /**
+     * Go back to a previous step.
+     */
+    goBack(targetStep?: OnboardingStep): OnboardingResult;
+    /**
+     * Serialize the current state for persistence.
+     */
+    toJSON(): SerializedOnboardingState;
+    /**
+     * Restore state from a serialized representation.
+     */
+    static fromJSON(serialized: SerializedOnboardingState, config: Omit<OnboardingStateMachineConfig, "existingContext">): OnboardingStateMachine;
+    /**
+     * Reset the state machine to the beginning.
+     */
+    reset(): void;
+    /**
+     * Register a custom handler for a step.
+     */
+    registerHandler<T>(step: OnboardingStep, handler: StepHandler<T>): void;
+    /**
+     * Handle the WELCOME step.
+     */
+    private handleWelcome;
+    /**
+     * Handle the RISK_ACK step.
+     */
+    private handleRiskAck;
+    /**
+     * Handle the AUTH step.
+     */
+    private handleAuth;
+    /**
+     * Validate auth input.
+     */
+    private validateAuthInput;
+    /**
+     * Handle the CHANNELS step.
+     */
+    private handleChannels;
+    /**
+     * Handle the SKILLS step.
+     */
+    private handleSkills;
+}
+/**
+ * Create a new onboarding state machine with default configuration.
+ */
+export declare function createOnboardingStateMachine(config: Partial<OnboardingStateMachineConfig> & {
+    platform: string;
+}): OnboardingStateMachine;
+/**
+ * Check if an onboarding context is complete.
+ */
+export declare function isOnboardingComplete(context: OnboardingContext): boolean;
+/**
+ * Get a summary of the onboarding context for display.
+ */
+export declare function getOnboardingSummary(context: OnboardingContext): string;
+export {};
+//# sourceMappingURL=onboarding-state.d.ts.map