rocketride 1.0.6 → 1.1.1

package/dist/types/client.d.ts

@@ -22,9 +22,13 @@
  * SOFTWARE.
  */
 import { DAPClient } from './core/DAPClient.js';
-import { DAPMessage, RocketRideClientConfig } from './types/index.js';
-import { TASK_STATUS, UPLOAD_RESULT, PIPELINE_RESULT, PipelineConfig } from './types/index.js';
+import { DAPMessage, RocketRideClientConfig, ConnectResult, ServerInfoResult } from './types/index.js';
+import { TASK_STATUS, UPLOAD_RESULT, PIPELINE_RESULT, PipelineConfig, DashboardResponse, ServicesResponse, ServiceDefinition, ValidationResult, CProfileStatusResponse, CProfileStopResponse, CProfileReportResponse } from './types/index.js';
 import { Question } from './schema/Question.js';
+import { AccountApi } from './account.js';
+import { BillingApi } from './billing.js';
+import { DatabaseApi } from './database.js';
+import { DeployApi } from './deploy.js';
 /**
  * Streaming data pipe for sending large datasets to RocketRide pipelines.
  *
@@ -91,7 +95,8 @@ export declare class DataPipe {
      * unique pipe ID that is used for subsequent operations.
      *
      * @returns This DataPipe instance (for method chaining)
-     * @throws Error if the pipe is already opened or if the pipeline is not running
+     * @throws Error if the pipe is already opened
+     * @throws PipeException if the server rejects the open request
      */
     open(): Promise<DataPipe>;
     /**
@@ -101,7 +106,8 @@ export declare class DataPipe {
      * multiple times to stream large datasets. The pipe must be opened first.
      *
      * @param buffer - Data to write, must be a Uint8Array
-     * @throws Error if the pipe is not opened, buffer is invalid, or write fails
+     * @throws Error if the pipe is not opened or buffer is invalid
+     * @throws PipeException if the server reports a write failure
      */
     write(buffer: Uint8Array): Promise<void>;
     /**
@@ -112,7 +118,7 @@ export declare class DataPipe {
      * the pipe cannot be reopened or written to again.
      *
      * @returns The processing result from the server, or undefined if already closed
-     * @throws Error if closing the pipe fails
+     * @throws PipeException if the server reports a failure while finalizing the pipe
      */
     close(): Promise<PIPELINE_RESULT | undefined>;
 }
@@ -134,9 +140,23 @@ export declare class DataPipe {
  * - Server connectivity testing (ping)
  * - Full TypeScript type safety
  */
+/**
+ * Identifies a monitor subscription key.
+ *
+ * - `{ token }` — monitors a specific running task by its session token.
+ * - `{ projectId, source }` — monitors a project/source regardless of task.
+ */
+export type MonitorKey = {
+    token: string;
+} | {
+    projectId: string;
+    source: string;
+    pipeId?: number;
+};
 export declare class RocketRideClient extends DAPClient {
     private _uri;
     private _apikey?;
+    private _wsPath?;
     private _env;
     private _callerOnEvent?;
     private _callerOnConnected?;
@@ -147,14 +167,23 @@ export declare class RocketRideClient extends DAPClient {
     private _nextChatId;
     /** Maps pipe_id → SSE callback for pipe-scoped real-time event dispatch. */
     readonly _ssePipeCallbacks: Map<number, (type: string, data: Record<string, unknown>) => Promise<void>>;
+    private _desiredState;
+    private _authenticated;
     private _persist;
-    private _reconnectTimeout?;
-    private _manualDisconnect;
-    private _maxRetryTime?;
-    private _retryStartTime?;
+    private _reconnectTimer?;
     private _currentReconnectDelay;
-    /** True after onConnected has been invoked; used to only invoke onDisconnected when we had a connection. */
-    private _didNotifyConnected;
+    /** Reference-counted monitor subscriptions: keyString → Map<eventType, refCount> */
+    private _monitorKeys;
+    /** Lazily-created account API namespace. */
+    private _account?;
+    /** Lazily-created billing API namespace. */
+    private _billing?;
+    /** Lazily-created database API namespace. */
+    private _database?;
+    /** Lazily-created deploy API namespace. */
+    private _deploy?;
+    /** Optional trace callback for observing all call() traffic. */
+    private _onTrace?;
     /**
      * Creates a new RocketRideClient instance.
      *
@@ -209,6 +238,27 @@ export declare class RocketRideClient extends DAPClient {
      * passing it to the client or doing your own validation.
      */
     static normalizeUri(uri: string): string;
+    /**
+     * Probe a server for its capabilities without authenticating.
+     *
+     * Creates a temporary public connection and sends an
+     * ``rrext_public_probe`` command. The server responds with version,
+     * capabilities, platform, and public apps without requiring credentials.
+     *
+     * @param uri - Server URI (e.g. ``"localhost:5565"``, ``"https://cloud.rocketride.ai"``)
+     * @param timeout - Optional timeout in ms for the entire operation
+     * @returns Server info including version and capability tags
+     * @throws Error if the server is unreachable or does not support probes
+     *
+     * @example
+     * ```typescript
+     * const info = await RocketRideClient.getServerInfo('localhost:5565');
+     * if (info.capabilities.includes('saas')) {
+     *   // Show cloud sign-in options
+     * }
+     * ```
+     */
+    static getServerInfo(uri: string, timeout?: number): Promise<ServerInfoResult>;
     /**
      * Normalize a user-provided URI into a fully-formed WebSocket address.
      * Builds on normalizeUri, then converts to ws/wss and appends /task/service.
@@ -223,61 +273,137 @@ export declare class RocketRideClient extends DAPClient {
      */
     private _setAuth;
     /**
-     * Clear any pending reconnection timeout.
+     * Create transport if needed and open the WebSocket. No auth.
      */
-    private _clearReconnectTimeout;
+    private _internalAttach;
     /**
-     * Single place for physical connection. Creates transport if needed, then
-     * calls DAPClient.connect (transport connect + auth handshake + onConnected).
+     * Send the ``auth`` DAP command over the open transport.
+     * Sets ``_authenticated`` and ``_connectResult`` on success.
+     * Throws ``AuthenticationException`` on failure (transport stays open).
      */
-    private _internalConnect;
+    private _internalLogin;
     /**
-     * Single place for physical disconnect. Closes the transport directly,
-     * which triggers onDisconnected via the transport callback.
+     * Send the ``deauth`` DAP command to revert to unauthenticated.
+     */
+    private _internalLogout;
+    /**
+     * Close the transport. Triggers onDisconnected via the transport callback.
      */
     private _internalDisconnect;
     /**
-     * Try to connect; on auth error notify and stop; on other error notify and
-     * reschedule with exponential backoff. Used by persist-mode connect() and
-     * by the reconnect timer.
+     * Clear the reconnect timer if active.
      */
-    private _attemptConnection;
+    private _clearReconnectTimer;
     /**
-     * Schedule a reconnection attempt with exponential backoff.
+     * Reconnect engine driven by ``_desiredState``.
+     *
+     * Schedules a timer that re-attaches (and re-logins if the user had
+     * been authenticated). Checks ``_desiredState`` after every await so
+     * user actions mid-reconnect are respected immediately.
+     *
+     * Linear backoff: 250ms → 500ms → ... → 15 000ms cap.
      */
     private _scheduleReconnect;
+    /**
+     * Attach to a RocketRide server (open WebSocket, no auth).
+     *
+     * If ``uri`` is provided and differs from the current URI, detaches
+     * first. If already attached to the same URI, this is a no-op.
+     *
+     * After attach, public APIs (``rrext_public_*``) are available.
+     *
+     * @param uri - Server URI override. Updates the stored URI if provided.
+     * @param options - Optional timeout for the WebSocket handshake.
+     */
+    attach(uri?: string, options?: {
+        timeout?: number;
+    }): Promise<void>;
+    /**
+     * Detach from the server (close WebSocket, cancel reconnection).
+     *
+     * Sets ``_desiredState`` to ``'detached'`` so the reconnect engine
+     * stops and ``onDisconnected`` does not restart it.
+     */
+    detach(): Promise<void>;
+    /**
+     * True when the WebSocket transport is connected (regardless of auth).
+     */
+    isAttached(): boolean;
+    /**
+     * Authenticate over an attached transport.
+     *
+     * If ``uri`` is provided and differs, detaches and re-attaches first.
+     * If ``auth`` is provided and differs from the current credential,
+     * logs out (best-effort) before logging in with the new credential.
+     * If already authenticated with the same credential, this is a no-op.
+     *
+     * @param credential - API key, rr_ token, or PKCE code object.
+     * @param options - Optional URI override and/or timeout.
+     * @returns ConnectResult with user identity on success.
+     * @throws AuthenticationException on auth failure (transport stays attached).
+     */
+    login(credential?: string | {
+        code: string;
+        verifier: string;
+        redirectUri: string;
+    }, options?: {
+        uri?: string;
+        timeout?: number;
+    }): Promise<ConnectResult>;
+    /**
+     * Deauthenticate: sends ``deauth`` to the server, clears client auth state.
+     * The transport stays attached — public APIs continue to work.
+     */
+    logout(): Promise<void>;
+    /**
+     * True when the auth handshake has succeeded on the current connection.
+     */
+    isAuthenticated(): boolean;
     /**
      * Check if the client is currently connected to the RocketRide server.
+     * Equivalent to ``isAttached()`` — kept for backward compatibility.
      */
     isConnected(): boolean;
     /**
-     * Connect to the RocketRide server.
+     * Connect to the RocketRide server and authenticate in a single call.
      *
-     * Must be called before executing pipelines or other operations.
-     * In persist mode, enables automatic reconnection on disconnect and on initial failure
-     * (calls onConnectError on each failed attempt and keeps retrying).
-     * @param options - Optional timeout (number) or connection parameters object with uri, auth, and timeout.
+     * Backward-compatible wrapper around ``attach()`` + ``login()``.
+     * Sends the credential as the first DAP message and returns the full
+     * ConnectResult (user identity + organizations + teams) on success.
+     *
+     * @param credential - API key / Zitadel access_token / rr_ user token / PKCE code object.
+     * @param options - Optional overrides: uri and/or timeout.
      */
-    connect(options?: number | {
+    connect(credential?: string | {
+        code: string;
+        verifier: string;
+        redirectUri: string;
+    }, options?: {
         uri?: string;
-        auth?: string;
         timeout?: number;
-    }): Promise<void>;
+    }): Promise<ConnectResult>;
+    /**
+     * Get the ConnectResult from the last successful connect().
+     * Returns undefined if not connected or not yet authenticated.
+     */
+    getAccountInfo(): ConnectResult | undefined;
+    /**
+     * Returns the ID of the user's primary organization.
+     */
+    getOrgId(): string | undefined;
     /**
      * Disconnect from the RocketRide server and stop automatic reconnection.
-     *
-     * Should be called when finished with the client to clean up resources.
+     * Backward-compatible wrapper around ``logout()`` + ``detach()``.
      */
     disconnect(): Promise<void>;
     /**
-     * Update server URI and/or auth at runtime. If currently connected,
-     * disconnects and reconnects with the new params. In persist mode,
-     * reconnection is scheduled only if we were connected.
-     */
-    setConnectionParams(options: {
-        uri?: string;
-        auth?: string;
-    }): Promise<void>;
+     * Update the environment variables used for pipeline substitution.
+     *
+     * The env dictionary is used by {@link use} and {@link validate} to replace
+    // ============================================================================
+    // PING METHODS
+    // ============================================================================
+
     /**
      * Test connectivity to the RocketRide server.
      *
@@ -286,17 +412,6 @@ export declare class RocketRideClient extends DAPClient {
      * and measuring response times.
      */
     ping(token?: string): Promise<void>;
-    /**
-     * Substitute environment variables in a string.
-     * Replaces ${ROCKETRIDE_*} patterns with values from client's env dictionary.
-     * If variable is not found, leaves it unchanged.
-     */
-    private substituteEnvVars;
-    /**
-     * Recursively process an object/array to substitute environment variables.
-     * Only processes string values, leaving other types unchanged.
-     */
-    private processEnvSubstitution;
     /**
      * Load Node.js fs/promises at runtime without static imports.
      * This keeps browser bundles free of Node built-ins while preserving Node features.
@@ -334,7 +449,7 @@ export declare class RocketRideClient extends DAPClient {
     validate(options: {
         pipeline: PipelineConfig | Record<string, unknown>;
         source?: string;
-    }): Promise<Record<string, unknown>>;
+    }): Promise<ValidationResult>;
     /**
      * Start an RocketRide pipeline for processing data.
      *
@@ -389,6 +504,12 @@ export declare class RocketRideClient extends DAPClient {
         ttl?: number;
         /** Pipeline trace level. When set, captures every lane write and invoke call in the response under '_trace'. */
         pipelineTraceLevel?: 'none' | 'metadata' | 'summary' | 'full';
+        /** Optional display name for the task (e.g. shown in dashboard). */
+        name?: string;
+        /** ROCKETRIDE_* environment overrides merged on top of server-side env. */
+        env?: Record<string, string>;
+        /** Team ID to run the task under. Defaults to the user's default team. */
+        teamId?: string;
     }): Promise<Record<string, unknown> & {
         token: string;
     }>;
@@ -396,10 +517,56 @@ export declare class RocketRideClient extends DAPClient {
      * Terminate a running pipeline.
      */
     terminate(token: string): Promise<void>;
+    /**
+     * Restart a running pipeline with a new configuration.
+     *
+     * Looks up the existing task by project/source, terminates it, and
+     * starts a new execution in one server round-trip.
+     *
+     * @param options.token - Existing task token (optional, resolved server-side if omitted).
+     * @param options.projectId - The project identifier.
+     * @param options.source - The source component identifier.
+     * @param options.pipeline - The pipeline configuration to restart with.
+     */
+    restart(options: {
+        token?: string;
+        projectId: string;
+        source: string;
+        pipeline: Record<string, unknown>;
+    }): Promise<void>;
     /**
      * Get the current status of a running pipeline.
+     *
+     * By default this call is bounded to 15s so callers/tests don't hang forever if the engine
+     * stops responding mid-request (especially important in CI). Pass `{ timeout: false }` to
+     * restore the previous behavior of using only the client-level request timeout (if any).
+     */
+    getTaskStatus(token: string, options?: {
+        timeout?: number | false;
+    }): Promise<TASK_STATUS>;
+    /**
+     * Resolve a running task's token from its project ID and source component.
+     *
+     * The token is required for operations like terminate and restart.
+     * Returns undefined if no task is currently running for the given project/source.
+     *
+     * @param options.projectId - The project identifier.
+     * @param options.source - The source component identifier.
      */
-    getTaskStatus(token: string): Promise<TASK_STATUS>;
+    getTaskToken(options: {
+        projectId: string;
+        source: string;
+    }): Promise<string | undefined>;
+    /**
+     * Returns the unresolved pipeline for a running task.
+     *
+     * The pipeline is returned exactly as stored — ${ROCKETRIDE_*} placeholders are
+     * NOT substituted, so no secrets are included in the response.
+     *
+     * @param token - Task token returned by {@link getTaskToken}.
+     * @returns The unresolved pipeline dict, or undefined if the task is not found.
+     */
+    getTaskPipeline(token: string): Promise<Record<string, unknown> | undefined>;
     /** Return objinfo with size set; never 0 (parse filter skips "empty"). */
     private _objinfoWithSize;
     /**
@@ -472,295 +639,343 @@ export declare class RocketRideClient extends DAPClient {
      */
     onConnectError(error: Error): Promise<void>;
     /**
-     * Handle connected events from the RocketRide server.
+     * Handle transport-level connected event.
+     *
+     * With the attach/login split, this fires when the WebSocket opens
+     * (before auth). The ``_internalLogin`` method handles the auth
+     * notification separately, so this is intentionally minimal.
      */
     onConnected(connectionInfo: string): Promise<void>;
     /**
-     * Handle disconnected events from the RocketRide server.
-     * Only invokes the user's onDisconnected if onConnected had previously been called
-     * (so "disconnect without ever connecting" does not fire the user callback).
+     * Handle transport disconnection.
+     *
+     * Clears transport and auth state, notifies the user callback,
+     * then consults ``_desiredState`` to decide whether to reconnect.
      */
     onDisconnected(reason: string, hasError: boolean): Promise<void>;
     /**
      * Subscribe to specific types of events from the server.
+     * @deprecated Use {@link addMonitor} / {@link removeMonitor} instead.
      */
     setEvents(token: string, eventTypes: string[], pipeId?: number): Promise<void>;
     /**
-     * Save or update a project pipeline.
+     * Add a monitor subscription. If the key already exists, the new types are
+     * merged via reference counting and the merged set is sent to the server.
      *
-     * Stores a project pipeline configuration on the server. If the project
-     * already exists, it will be updated. Use expectedVersion to ensure
-     * you're updating the version you expect (prevents conflicts).
+     * @param key - Monitor key: `{ token }` for a running task, or `{ projectId, source }` for a project.
+     * @param types - Event types to subscribe to (e.g. `['summary', 'flow']`).
+     */
+    addMonitor(key: MonitorKey, types: string[]): Promise<void>;
+    /**
+     * Remove a monitor subscription. Decrements reference counts for the given
+     * types. Only unsubscribes a type from the server when its count reaches 0.
      *
-     * @param options - Save project options
-     * @param options.projectId - Unique identifier for the project
-     * @param options.pipeline - Pipeline configuration object
-     * @param options.expectedVersion - Expected current version for atomic updates (optional)
-     * @returns Promise resolving to save result with success status, projectId, and new version
-     * @throws Error if save fails due to version mismatch, storage error, or invalid input
+     * @param key - Monitor key (must match the key used in addMonitor).
+     * @param types - Event types to unsubscribe from.
+     */
+    removeMonitor(key: MonitorKey, types: string[]): Promise<void>;
+    /**
+     * Send the merged type list for a monitor key to the server.
+     */
+    private _syncMonitor;
+    /**
+     * Replay all active monitor subscriptions to the server.
+     * Called automatically after reconnection.
+     */
+    private _resubscribeAllMonitors;
+    /**
+     * Convert a MonitorKey to a stable string for map lookup.
+     */
+    private _monitorKeyToString;
+    /**
+     * Reverse a key-string back to a MonitorKey (for resubscribeAll).
+     */
+    private _monitorStringToKey;
+    /**
+     * Persist a pipeline configuration as a named template in the account store.
      *
-     * @example
-     * ```typescript
-     * // Save a new project
-     * const result = await client.saveProject({
-     *   projectId: 'proj-123',
-     *   pipeline: {
-     *     name: 'Data Processor',
-     *     source: 'source_1',
-     *     components: [...]
-     *   }
-     * });
-     * console.log(`Saved version: ${result.version}`);
-     *
-     * // Update existing project with version check
-     * const existing = await client.getProject({ projectId: 'proj-123' });
-     * existing.name = 'Updated Name';
-     * const updated = await client.saveProject({
-     *   projectId: 'proj-123',
-     *   pipeline: existing,
-     *   expectedVersion: existing.version
-     * });
-     * ```
+     * Templates are stored as JSON files under `.templates/<templateId>.json`.
+     * Saving a template with an existing ID overwrites the previous version.
+     *
+     * @param options.templateId - Unique identifier for the template (no path separators)
+     * @param options.pipeline - Pipeline configuration object to save
+     * @throws Error if templateId is invalid or pipeline is not a non-empty object
      */
-    saveProject(options: {
-        projectId: string;
+    saveTemplate(options: {
+        templateId: string;
         pipeline: Record<string, any>;
-        expectedVersion?: string;
-    }): Promise<{
-        success: boolean;
-        project_id: string;
-        version: string;
-    }>;
+    }): Promise<void>;
+    /**
+     * Retrieve a previously saved pipeline template from the account store.
+     *
+     * @param options.templateId - Unique identifier of the template to retrieve
+     * @returns The pipeline configuration object that was saved
+     * @throws Error if the template does not exist or templateId is invalid
+     */
+    getTemplate(options: {
+        templateId: string;
+    }): Promise<Record<string, any>>;
+    /**
+     * Delete a pipeline template from the account store.
+     *
+     * @param options.templateId - Unique identifier of the template to delete
+     * @throws Error if the template does not exist or templateId is invalid
+     */
+    deleteTemplate(options: {
+        templateId: string;
+    }): Promise<void>;
     /**
-     * Retrieve a project by its ID.
+     * List all pipeline templates stored in the account store.
      *
-     * Fetches the complete pipeline configuration and current version for
-     * the specified project. Use this before updating to get the current
-     * version for atomic updates.
+     * Reads the `.templates` directory, parses each `.json` file, and extracts
+     * a summary for each template. Files that cannot be parsed are silently
+     * skipped so a single corrupt template does not break the entire listing.
      *
-     * @param options - Get project options
-     * @param options.projectId - Unique identifier of the project to retrieve
-     * @returns Promise resolving to project data with success status, pipeline, and version
-     * @throws Error if project doesn't exist or retrieval fails
+     * @returns Array of template summaries sorted in directory-listing order.
+     *          Each entry contains the template ID, display name, source components,
+     *          and total component count.
+     */
+    getAllTemplates(): Promise<Array<{
+        id: string;
+        name: string;
+        sources: any[];
+        totalComponents: number;
+    }>>;
+    /**
+     * Persist a pipeline execution log to the account store.
      *
-     * @example
-     * ```typescript
-     * // Get a project
-     * try {
-     *   const project = await client.getProject({ projectId: 'proj-123' });
-     *   console.log(`Project: ${project.name}`);
-     *   console.log(`Version: ${project.version}`);
-     * } catch (error) {
-     *   if (error.message.includes('NOT_FOUND')) {
-     *     console.log("Project doesn't exist");
-     *   }
-     * }
+     * Logs are stored under `.logs/<projectId>/<source>-<startTime>.log`.
+     * The filename is derived from `contents.body.startTime` so logs are
+     * naturally sortable by execution start time.
      *
-     * // Before updating - get current version
-     * const project = await client.getProject({ projectId: 'proj-123' });
-     * project.name = 'Updated';
-     * await client.saveProject({
-     *   projectId: 'proj-123',
-     *   pipeline: project,
-     *   expectedVersion: project.version
-     * });
-     * ```
+     * @param options.projectId - Project identifier that owns this log
+     * @param options.source - Source component identifier the log is associated with
+     * @param options.contents - Log payload; must contain `body.startTime`
+     * @returns The generated filename (e.g. `"ingest-1714000000000.log"`)
+     * @throws Error if any ID is invalid, contents is not an object, or startTime is missing
      */
-    getProject(options: {
+    saveLog(options: {
         projectId: string;
-    }): Promise<{
-        success: boolean;
-        pipeline: Record<string, any>;
-        version: string;
-    }>;
+        source: string;
+        contents: Record<string, any>;
+    }): Promise<string>;
     /**
-     * Delete a project by its ID.
+     * Retrieve a previously saved pipeline execution log from the account store.
      *
-     * Permanently removes a project from storage. Optionally verify the
-     * version before deletion to ensure you're deleting the version you
-     * expect (prevents accidental deletion of modified projects).
+     * @param options.projectId - Project identifier that owns the log
+     * @param options.name - Filename of the log (as returned by saveLog)
+     * @returns The log payload that was saved
+     * @throws Error if the log does not exist or projectId is invalid
+     */
+    getLog(options: {
+        projectId: string;
+        name: string;
+    }): Promise<Record<string, any>>;
+    /**
+     * Delete a pipeline execution log from the account store.
      *
-     * @param options - Delete project options
-     * @param options.projectId - Unique identifier of the project to delete
-     * @param options.expectedVersion - Expected current version for atomic deletion (required)
-     * @returns Promise resolving to deletion result with success status and message
-     * @throws Error if project doesn't exist, version mismatch, or deletion fails
+     * @param options.projectId - Project identifier that owns the log
+     * @param options.name - Filename of the log to delete
+     * @throws Error if the log does not exist or projectId is invalid
+     */
+    deleteLog(options: {
+        projectId: string;
+        name: string;
+    }): Promise<void>;
+    /**
+     * List pipeline execution logs stored for a project, optionally filtered by source.
      *
-     * @example
-     * ```typescript
-     * // Safe deletion with version check
-     * const project = await client.getProject({ projectId: 'proj-123' });
-     * try {
-     *   const result = await client.deleteProject({
-     *     projectId: 'proj-123',
-     *     expectedVersion: project.version
-     *   });
-     *   console.log('Project deleted successfully');
-     * } catch (error) {
-     *   if (error.message.includes('CONFLICT')) {
-     *     console.log('Project was modified, deletion cancelled');
-     *   }
-     * }
-     * ```
+     * Results are sorted ascending by `modified` timestamp so the oldest log
+     * appears first. The caller can page through or slice the array as needed.
+     *
+     * @param options.projectId - Project identifier whose logs to list
+     * @param options.source - Optional source component filter; when set, only logs
+     *                         whose filename starts with `<source>-` are returned
+     * @returns Array of log name and optional modified timestamp, sorted oldest-first
+     * @throws Error if projectId (or source when provided) is invalid
      */
-    deleteProject(options: {
+    listLogs(options: {
         projectId: string;
-        expectedVersion?: string;
-    }): Promise<{
-        success: boolean;
-        message: string;
+        source?: string;
+    }): Promise<Array<{
+        name: string;
+        modified?: number;
+    }>>;
+    /**
+     * Open a file handle for reading or writing.
+     *
+     * @param path - Relative path within the account store
+     * @param mode - 'r' for read, 'w' for write (default: 'r')
+     * @param offset - Initial byte offset (read mode only)
+     * @returns Object with 'handle' (string). Read mode also includes 'size' (number).
+     */
+    fsOpen(path: string, mode?: 'r' | 'w'): Promise<{
+        handle: string;
+        size?: number;
     }>;
     /**
-     * List all projects for the current user.
+     * Read data from an open read handle.
      *
-     * Retrieves a summary of all projects stored for the authenticated user.
-     * Each project summary includes the ID, name, list of data sources, and total component count.
+     * @param handle - Handle ID returned by fsOpen
+     * @param offset - Byte offset to read from
+     * @param length - Max bytes to read (default 4 MB). Empty Uint8Array indicates EOF.
+     * @returns The bytes read
+     */
+    fsRead(handle: string, offset?: number, length?: number): Promise<Uint8Array>;
+    /**
+     * Write data to an open write handle.
      *
-     * @returns Promise resolving to list result with success status, projects array, and count
-     * @throws Error if retrieval fails
+     * @param handle - Handle ID returned by fsOpen
+     * @param data - Raw bytes to write
+     * @returns Number of bytes written
+     */
+    fsWrite(handle: string, data: Uint8Array): Promise<number>;
+    /**
+     * Close a file handle.
      *
-     * @example
-     * ```typescript
-     * // List all projects
-     * const result = await client.getAllProjects();
-     * console.log(`Found ${result.count} projects:`);
-     * for (const project of result.projects) {
-     *   console.log(`- ${project.id}: ${project.name} (${project.totalComponents} components)`);
-     *   for (const source of project.sources) {
-     *     console.log(`  * ${source.name} (${source.provider})`);
-     *   }
-     * }
+     * @param handle - Handle ID returned by fsOpen
+     * @param mode - 'r' or 'w' (must match the mode used in fsOpen)
+     */
+    fsClose(handle: string, mode: 'r' | 'w'): Promise<void>;
+    /**
+     * Delete a file.
      *
-     * // Find specific project
-     * const result = await client.getAllProjects();
-     * const myProject = result.projects.find(p => p.id === 'proj-123');
-     * ```
+     * @param path - Relative path within the account store
+     * @throws Error if file does not exist or delete fails
+     */
+    fsDelete(path: string): Promise<void>;
+    /**
+     * List immediate children of a directory.
+     *
+     * @param path - Relative directory path (default: account root)
+     * @returns Directory entries with name and type (file or dir)
      */
-    getAllProjects(): Promise<{
-        success: boolean;
-        projects: Array<{
-            id: string;
+    fsListDir(path?: string): Promise<{
+        entries: Array<{
             name: string;
-            sources: Array<{
-                id: string;
-                provider: string;
-                name: string;
-            }>;
-            totalComponents: number;
+            type: 'file' | 'dir';
+            size?: number;
+            modified?: number;
         }>;
         count: number;
     }>;
     /**
-     * Save or update a template pipeline.
+     * Create a directory.
      *
-     * Stores a template pipeline configuration on the server. Templates are system-wide
-     * and accessible to all users. If the template already exists, it will be updated.
-     * Use expectedVersion to ensure you're updating the version you expect.
+     * @param path - Relative directory path
+     */
+    fsMkdir(path: string): Promise<void>;
+    /**
+     * Remove a directory.
      *
-     * @param options - Save template options
-     * @param options.templateId - Unique identifier for the template
-     * @param options.pipeline - Pipeline configuration object
-     * @param options.expectedVersion - Expected current version for atomic updates (optional)
-     * @returns Promise resolving to save result with success status, templateId, and new version
-     * @throws Error if save fails due to version mismatch, storage error, or invalid input
+     * @param path - Relative directory path
+     * @param recursive - If true, delete contents recursively (default: false)
+     * @throws Error if directory is not empty (when recursive is false) or delete fails
      */
-    saveTemplate(options: {
-        templateId: string;
-        pipeline: Record<string, any>;
-        expectedVersion?: string;
-    }): Promise<{
-        success: boolean;
-        template_id: string;
-        version: string;
-    }>;
+    fsRmdir(path: string, recursive?: boolean): Promise<void>;
     /**
-     * Retrieve a template by its ID.
+     * Get file or directory metadata.
+     *
+     * @param path - Relative path within the account store
+     * @returns Metadata including existence, type, size (bytes), and modified epoch timestamp (for files)
      */
-    getTemplate(options: {
-        templateId: string;
-    }): Promise<{
-        success: boolean;
-        pipeline: Record<string, any>;
-        version: string;
+    fsStat(path: string): Promise<{
+        exists: boolean;
+        type?: 'file' | 'dir';
+        size?: number;
+        modified?: number;
     }>;
     /**
-     * Delete a template by its ID.
+     * Rename a file or directory.
+     *
+     * On object stores this is implemented as copy + delete. For directories,
+     * all contents are moved recursively.
+     *
+     * @param oldPath - Current relative path within the account store
+     * @param newPath - New relative path within the account store
+     * @throws Error if oldPath does not exist or rename fails
      */
-    deleteTemplate(options: {
-        templateId: string;
-        expectedVersion?: string;
-    }): Promise<{
-        success: boolean;
-        message: string;
-    }>;
+    fsRename(oldPath: string, newPath: string): Promise<void>;
+    /** Read a file as a UTF-8 string. */
+    fsReadString(path: string): Promise<string>;
+    /** Write a UTF-8 string to a file. */
+    fsWriteString(path: string, text: string): Promise<void>;
+    /** Read a JSON file. */
+    fsReadJson<T = any>(path: string): Promise<T>;
+    /** Write an object as JSON. */
+    fsWriteJson(path: string, obj: any): Promise<void>;
     /**
-     * List all templates.
+     * Characters that are illegal in store paths and IDs on all supported
+     * platforms (Windows, Linux, macOS, and object-storage back-ends).
+     *
+     * `\x00` is the null byte; the rest are shell/filesystem metacharacters
+     * that would cause ambiguous or dangerous behaviour in path construction.
      */
-    getAllTemplates(): Promise<{
-        success: boolean;
-        templates: Array<{
-            id: string;
-            name: string;
-            sources: Array<{
-                id: string;
-                provider: string;
-                name: string;
-            }>;
-            totalComponents: number;
-        }>;
-        count: number;
-    }>;
+    private static readonly INVALID_PATH_CHARS;
     /**
-     * Save a log file for a source run.
+     * Validate a relative path intended for the account file store.
+     *
+     * Splits the path on `/` (after normalising backslashes) and checks every
+     * segment for path-traversal attempts (`..`) and forbidden characters.
+     * Empty segments (from leading/trailing/double slashes) are skipped because
+     * they carry no security risk on the server side.
+     *
+     * @param path - Relative path to validate (e.g. `.templates/my-pipe.json`)
+     * @throws Error if any segment is `..` or contains illegal characters
      */
-    saveLog(options: {
-        projectId: string;
-        source: string;
-        contents: Record<string, any>;
-    }): Promise<{
-        success: boolean;
-        filename: string;
-    }>;
+    private validateStorePath;
     /**
-     * Get a log file by source name and start time.
+     * Validate a single identifier (projectId, source, templateId, etc.) used
+     * to construct store paths.
+     *
+     * IDs must be non-empty strings that contain no path separators and no
+     * characters from the forbidden set. This prevents an ID from escaping its
+     * intended directory when interpolated into a path.
+     *
+     * @param value - The identifier string to validate
+     * @param name - Human-readable field name used in error messages (e.g. `"projectId"`)
+     * @throws Error if value is empty, contains path separators, or contains illegal characters
      */
-    getLog(options: {
-        projectId: string;
-        source: string;
-        startTime: number;
-    }): Promise<{
-        success: boolean;
-        contents: Record<string, any>;
-    }>;
+    private validateId;
     /**
-     * List log files for a project.
+     * Retrieve a server dashboard snapshot.
+     *
+     * Returns the current state of all connections, tasks, and aggregate
+     * metrics from the server. Requires 'task.monitor' permission.
+     *
+     * @returns DashboardResponse containing overview, connections, and tasks
      */
-    listLogs(options: {
-        projectId: string;
-        source?: string;
-        page?: number;
-    }): Promise<{
-        success: boolean;
-        logs: string[];
-        count: number;
-        total_count: number;
-        page: number;
-        total_pages: number;
-    }>;
+    getDashboard(): Promise<DashboardResponse>;
+    /**
+     * Start a cProfile profiling session on the server process or a pipeline.
+     *
+     * @param target  - Task token to profile a pipeline subprocess, or
+     *                  undefined/null to profile the server process itself.
+     * @param session - Optional human-readable session name.
+     * @returns Status object with session info and start time.
+     */
+    cprofileStart(target?: string | null, session?: string): Promise<CProfileStatusResponse>;
     /**
-     * Send an arbitrary DAP command with command name, arguments, and optional token.
+     * Stop the active cProfile profiling session.
      *
-     * This is a convenience method for callers that don't want to construct
-     * full DAPMessage objects. It builds the request internally and delegates
-     * to the underlying request() method.
+     * @param target - Task token if profiling a pipeline, or undefined for server.
+     * @returns Result with session name and runtime.
+     */
+    cprofileStop(target?: string | null): Promise<CProfileStopResponse>;
+    /**
+     * Get the current cProfile profiling status.
      *
-     * @param command - The DAP command name (e.g., 'rrext_services', 'rrext_monitor')
-     * @param args - Optional arguments for the command
-     * @param token - Optional task/session token
-     * @param timeout - Optional per-request timeout in ms
-     * @returns The response DAPMessage from the server
+     * @param target - Task token if querying a pipeline, or undefined for server.
+     * @returns Status indicating active/inactive, owner, runtime.
      */
-    dapRequest(command: string, args?: Record<string, unknown>, token?: string, timeout?: number): Promise<DAPMessage>;
+    cprofileStatus(target?: string | null): Promise<CProfileStatusResponse>;
+    /**
+     * Get the full cProfile report from the last completed session.
+     *
+     * @param target - Task token if querying a pipeline, or undefined for server.
+     * @returns Object containing the full pstats text report.
+     */
+    cprofileReport(target?: string | null): Promise<CProfileReportResponse>;
     /**
      * Async disposal support for 'await using' pattern.
      * Equivalent to Python's __aexit__
@@ -797,7 +1012,7 @@ export declare class RocketRideClient extends DAPClient {
      * }
      * ```
      */
-    getServices(): Promise<Record<string, unknown>>;
+    getServices(): Promise<ServicesResponse>;
     /**
      * Retrieve a specific service definition from the server.
      *
@@ -820,7 +1035,7 @@ export declare class RocketRideClient extends DAPClient {
      * }
      * ```
      */
-    getService(service: string): Promise<Record<string, unknown> | undefined>;
+    getService(service: string): Promise<ServiceDefinition | undefined>;
     /**
      * Get connection information (TypeScript-specific convenience)
      */
@@ -833,6 +1048,74 @@ export declare class RocketRideClient extends DAPClient {
      * Get API key (for debugging/validation)
      */
     getApiKey(): string | undefined;
+    /**
+     * Lazily-initialised account API namespace.
+     *
+     * Provides typed methods for managing the authenticated user's profile,
+     * API keys, organization, members, and teams.
+     *
+     * @example
+     * ```typescript
+     * const profile = await client.account.getProfile();
+     * ```
+     */
+    get account(): AccountApi;
+    /**
+     * Lazily-initialised billing API namespace.
+     *
+     * Provides typed methods for managing subscriptions, Stripe checkout
+     * sessions, billing portal access, and compute credit wallets.
+     *
+     * @example
+     * ```typescript
+     * const details = await client.billing.getDetails(orgId);
+     * ```
+     */
+    get billing(): BillingApi;
+    /**
+     * Lazily-initialised database API namespace.
+     *
+     * Provides direct SQL/Cypher execution against database pipelines, bypassing
+     * the LLM translation layer that {@link RocketRideClient.chat} uses.
+     *
+     * @example
+     * ```typescript
+     * const result = await client.database.query({ token, sql: 'SELECT 1' });
+     * ```
+     */
+    get database(): DatabaseApi;
+    /**
+     * Lazily-initialised deploy API namespace.
+     *
+     * Provides typed methods for managing server-side pipeline deployments:
+     * add, remove, list, status, and update.
+     *
+     * @example
+     * ```typescript
+     * const rec = await client.deploy.add(pipeline, { schedule: '0/15 * * * *' });
+     * ```
+     */
+    get deploy(): DeployApi;
+    /**
+     * Sends a DAP command, unwraps the response body, and throws on failure.
+     *
+     * This is the single public entry point for all typed DAP operations.
+     * The {@link AccountApi} and {@link BillingApi} namespaces delegate here.
+     *
+     * If an `onTrace` callback was provided in the constructor config, it is
+     * invoked before the request (TraceType.Request) and after completion
+     * (TraceType.Success or TraceType.Error).
+     *
+     * @param command - DAP command name (e.g. "rrext_account_me").
+     * @param args    - Key/value arguments forwarded in the request.
+     * @param options - Optional token (for task-scoped calls) and timeout in ms.
+     * @returns The `body` field of a successful DAP response.
+     * @throws Error if the server signals failure.
+     */
+    call<T = any>(command: string, args?: Record<string, unknown>, options?: {
+        token?: string;
+        timeout?: number;
+    }): Promise<T>;
 }
 export { RocketRideClient as default };
 //# sourceMappingURL=client.d.ts.map