flockbay 0.10.15 → 0.10.16

package/dist/lib.d.mts

@@ -1,32 +1,103 @@
-import { z } from 'zod';
 import { EventEmitter } from 'node:events';
 import { Socket } from 'socket.io-client';
-import { ExpoPushMessage } from 'expo-server-sdk';
+import { z } from 'zod';
+
+/**
+ * Common RPC types and interfaces for both session and machine clients
+ */
+/**
+ * Generic RPC handler function type
+ * @template TRequest - The request data type
+ * @template TResponse - The response data type
+ */
+type RpcHandler<TRequest = any, TResponse = any> = (data: TRequest) => TResponse | Promise<TResponse>;
+/**
+ * RPC request data from server
+ */
+interface RpcRequest {
+    method: string;
+    params: any;
+}
+/**
+ * Configuration for RPC handler manager
+ */
+interface RpcHandlerConfig {
+    scopePrefix: string;
+    logger?: (message: string, data?: any) => void;
+}
+
+/**
+ * Generic RPC handler manager for session and machine clients
+ * Manages RPC method registration and handler execution
+ */
+
+declare class RpcHandlerManager {
+    private handlers;
+    private readonly scopePrefix;
+    private readonly logger;
+    private socket;
+    constructor(config: RpcHandlerConfig);
+    /**
+     * Register an RPC handler for a specific method
+     * @param method - The method name (without prefix)
+     * @param handler - The handler function
+     */
+    registerHandler<TRequest = any, TResponse = any>(method: string, handler: RpcHandler<TRequest, TResponse>): void;
+    /**
+     * Handle an incoming RPC request
+     * @param request - The RPC request data
+     * @param callback - The response callback
+     */
+    handleRequest(request: RpcRequest): Promise<any>;
+    onSocketConnect(socket: Socket): void;
+    onSocketDisconnect(): void;
+    /**
+     * Get the number of registered handlers
+     */
+    getHandlerCount(): number;
+    /**
+     * Check if a handler is registered
+     * @param method - The method name (without prefix)
+     */
+    hasHandler(method: string): boolean;
+    /**
+     * Clear all handlers
+     */
+    clearHandlers(): void;
+    /**
+     * Get the prefixed method name
+     * @param method - The method name
+     */
+    private getPrefixedMethod;
+}
+
+declare class CoordinationLeaseGuard {
+    private readonly expiresByFile;
+    grant(files: string[], ttlMs?: number): {
+        granted: string[];
+        expiresAt: number;
+    };
+    has(filePath: string, nowMs?: number): boolean;
+    revoke(files: string[]): {
+        revoked: string[];
+    };
+    clear(): void;
+    /**
+     * Debug-only: return current granted files and expiry.
+     * This intentionally leaks coordination state for diagnosis (safe for prelaunch).
+     */
+    snapshot(nowMs?: number): Array<{
+        file: string;
+        expiresAt: number;
+        expiresInMs: number;
+    }>;
+}
 
 /**
  * Simplified schema that only validates fields actually used in the codebase
  * while preserving all other fields through passthrough()
  */
 
-declare const UsageSchema: z.ZodObject<{
-    input_tokens: z.ZodNumber;
-    cache_creation_input_tokens: z.ZodOptional<z.ZodNumber>;
-    cache_read_input_tokens: z.ZodOptional<z.ZodNumber>;
-    output_tokens: z.ZodNumber;
-    service_tier: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
-    input_tokens: z.ZodNumber;
-    cache_creation_input_tokens: z.ZodOptional<z.ZodNumber>;
-    cache_read_input_tokens: z.ZodOptional<z.ZodNumber>;
-    output_tokens: z.ZodNumber;
-    service_tier: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
-    input_tokens: z.ZodNumber;
-    cache_creation_input_tokens: z.ZodOptional<z.ZodNumber>;
-    cache_read_input_tokens: z.ZodOptional<z.ZodNumber>;
-    output_tokens: z.ZodNumber;
-    service_tier: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-}, z.ZodTypeAny, "passthrough">>;
 declare const RawJSONLinesSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
     type: z.ZodLiteral<"user">;
     isSidechain: z.ZodOptional<z.ZodBoolean>;
@@ -279,250 +350,42 @@ declare const RawJSONLinesSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
 }, z.ZodTypeAny, "passthrough">>]>;
 type RawJSONLines = z.infer<typeof RawJSONLinesSchema>;
 
-/**
- * Common RPC types and interfaces for both session and machine clients
- */
-/**
- * Generic RPC handler function type
- * @template TRequest - The request data type
- * @template TResponse - The response data type
- */
-type RpcHandler<TRequest = any, TResponse = any> = (data: TRequest) => TResponse | Promise<TResponse>;
-/**
- * RPC request data from server
- */
-interface RpcRequest {
-    method: string;
-    params: string;
-}
-/**
- * Configuration for RPC handler manager
- */
-interface RpcHandlerConfig {
-    scopePrefix: string;
-    encryptionKey: Uint8Array;
-    logger?: (message: string, data?: any) => void;
-}
-
-/**
- * Generic RPC handler manager for session and machine clients
- * Manages RPC method registration, encryption/decryption, and handler execution
- */
-
-declare class RpcHandlerManager {
-    private handlers;
-    private readonly scopePrefix;
-    private readonly encryptionKey;
-    private readonly logger;
-    private socket;
-    constructor(config: RpcHandlerConfig);
-    /**
-     * Register an RPC handler for a specific method
-     * @param method - The method name (without prefix)
-     * @param handler - The handler function
-     */
-    registerHandler<TRequest = any, TResponse = any>(method: string, handler: RpcHandler<TRequest, TResponse>): void;
-    /**
-     * Handle an incoming RPC request
-     * @param request - The RPC request data
-     * @param callback - The response callback
-     */
-    handleRequest(request: RpcRequest): Promise<any>;
-    onSocketConnect(socket: Socket): void;
-    onSocketDisconnect(): void;
-    /**
-     * Get the number of registered handlers
-     */
-    getHandlerCount(): number;
-    /**
-     * Check if a handler is registered
-     * @param method - The method name (without prefix)
-     */
-    hasHandler(method: string): boolean;
-    /**
-     * Clear all handlers
-     */
-    clearHandlers(): void;
-    /**
-     * Get the prefixed method name
-     * @param method - The method name
-     */
-    private getPrefixedMethod;
-}
-
-declare class CoordinationLeaseGuard {
-    private readonly expiresByFile;
-    grant(files: string[], ttlMs?: number): {
-        granted: string[];
-        expiresAt: number;
-    };
-    has(filePath: string, nowMs?: number): boolean;
-    revoke(files: string[]): {
-        revoked: string[];
-    };
-    clear(): void;
-    /**
-     * Debug-only: return current granted files and expiry.
-     * This intentionally leaks coordination state for diagnosis (safe for prelaunch).
-     */
-    snapshot(nowMs?: number): Array<{
-        file: string;
-        expiresAt: number;
-        expiresInMs: number;
-    }>;
-}
-
-declare class ApiSessionClient extends EventEmitter {
-    private readonly token;
-    readonly sessionId: string;
-    private metadata;
-    private metadataVersion;
-    private agentState;
-    private agentStateVersion;
-    private socket;
-    private pendingMessages;
-    private pendingMessageCallback;
-    private pendingOutboundMessages;
-    readonly rpcHandlerManager: RpcHandlerManager;
-    private agentStateLock;
-    private metadataLock;
-    private encryptionKey;
-    readonly coordinationLeaseGuard: CoordinationLeaseGuard;
-    private coordinationLedgerReadAt;
-    private docsIndexReadAt;
-    constructor(token: string, session: Session);
-    /**
-     * Returns the session client's bearer token for calling authenticated HTTP endpoints.
-     * Intended for internal integrations (e.g. uploading artifacts for this session).
-     */
-    getAuthToken(): string;
-    /**
-     * True when this session has workspaceProjectId/workItemId metadata
-     * (i.e. ledger tools are available and claim enforcement makes sense).
-     */
-    hasCoordinationContext(): boolean;
-    markCoordinationLedgerRead(atMs?: number): void;
-    getCoordinationLedgerReadAt(): number;
-    didReadCoordinationLedgerWithin(ms: number): boolean;
-    markDocsIndexRead(atMs?: number): void;
-    getDocsIndexReadAt(): number;
-    didReadDocsIndexWithin(ms: number): boolean;
-    private startCoordinationAutopilot;
-    private flushOutboundQueue;
-    private emitMessageOrQueue;
-    onUserMessage(callback: (data: UserMessage) => void): void;
-    /**
-     * Send message to session
-     * @param body - Message body (can be MessageContent or raw content for agent messages)
-     */
-    sendClaudeSessionMessage(body: RawJSONLines): void;
-    sendCodexMessage(body: any): void;
-    /**
-     * Send a generic agent message to the session.
-     * Works for any agent type (Gemini, Codex, Claude, etc.)
-     *
-     * @param agentType - The type of agent sending the message (e.g., 'gemini', 'codex', 'claude')
-     * @param body - The message payload
-     */
-    sendAgentMessage(agentType: 'gemini' | 'codex' | 'claude' | 'opencode', body: any): void;
-    sendSessionEvent(event: {
-        type: 'switch';
-        mode: 'local' | 'remote';
-    } | {
-        type: 'message';
-        message: string;
-    } | {
-        type: 'permission-mode-changed';
-        mode: 'default' | 'acceptEdits' | 'bypassPermissions' | 'plan';
-    } | {
-        type: 'ready';
-    }, id?: string): void;
-    /**
-     * Send a ping message to keep the connection alive
-     */
-    keepAlive(thinking: boolean, mode: 'local' | 'remote'): void;
-    /**
-     * Send session death message
-     */
-    sendSessionDeath(): void;
-    /**
-     * Send usage data to the server
-     */
-    sendUsageData(usage: Usage): void;
-    /**
-     * Update session metadata
-     * @param handler - Handler function that returns the updated metadata
-     */
-    updateMetadata(handler: (metadata: Metadata) => Metadata): void;
-    /**
-     * Update session agent state
-     * @param handler - Handler function that returns the updated agent state
-     */
-    updateAgentState(handler: (metadata: AgentState) => AgentState): void;
-    /**
-     * Wait for socket buffer to flush
-     */
-    flush(): Promise<void>;
-    close(): Promise<void>;
-}
-
-type PermissionMode = 'default' | 'acceptEdits' | 'bypassPermissions' | 'plan';
-
-/**
- * Usage data type from Claude
- */
-type Usage = z.infer<typeof UsageSchema>;
-/**
- * Session information
- */
-type Session = {
-    id: string;
-    seq: number;
-    encryptionKey: Uint8Array;
-    metadata: Metadata;
-    metadataVersion: number;
-    agentState: AgentState | null;
-    agentStateVersion: number;
-};
-/**
- * Machine metadata - static information (rarely changes)
- */
 declare const MachineMetadataSchema: z.ZodObject<{
-    host: z.ZodString;
-    platform: z.ZodString;
-    flockbayCliVersion: z.ZodString;
-    homeDir: z.ZodString;
-    flockbayHomeDir: z.ZodString;
-    flockbayLibDir: z.ZodString;
+    host: z.ZodOptional<z.ZodString>;
+    platform: z.ZodOptional<z.ZodString>;
+    flockbayCliVersion: z.ZodOptional<z.ZodString>;
+    homeDir: z.ZodOptional<z.ZodString>;
+    flockbayHomeDir: z.ZodOptional<z.ZodString>;
+    flockbayLibDir: z.ZodOptional<z.ZodString>;
+    displayName: z.ZodOptional<z.ZodString>;
     flockbayDevBypassUeGates: z.ZodOptional<z.ZodBoolean>;
 }, "strip", z.ZodTypeAny, {
-    host: string;
-    platform: string;
-    flockbayCliVersion: string;
-    homeDir: string;
-    flockbayHomeDir: string;
-    flockbayLibDir: string;
+    host?: string | undefined;
+    platform?: string | undefined;
+    flockbayCliVersion?: string | undefined;
+    homeDir?: string | undefined;
+    flockbayHomeDir?: string | undefined;
+    flockbayLibDir?: string | undefined;
+    displayName?: string | undefined;
     flockbayDevBypassUeGates?: boolean | undefined;
 }, {
-    host: string;
-    platform: string;
-    flockbayCliVersion: string;
-    homeDir: string;
-    flockbayHomeDir: string;
-    flockbayLibDir: string;
+    host?: string | undefined;
+    platform?: string | undefined;
+    flockbayCliVersion?: string | undefined;
+    homeDir?: string | undefined;
+    flockbayHomeDir?: string | undefined;
+    flockbayLibDir?: string | undefined;
+    displayName?: string | undefined;
     flockbayDevBypassUeGates?: boolean | undefined;
 }>;
 type MachineMetadata = z.infer<typeof MachineMetadataSchema>;
-/**
- * Daemon state - dynamic runtime information (frequently updated)
- */
 declare const DaemonStateSchema: z.ZodObject<{
-    status: z.ZodUnion<[z.ZodEnum<["running", "shutting-down"]>, z.ZodString]>;
+    status: z.ZodString;
     pid: z.ZodOptional<z.ZodNumber>;
     httpPort: z.ZodOptional<z.ZodNumber>;
     startedAt: z.ZodOptional<z.ZodNumber>;
     shutdownRequestedAt: z.ZodOptional<z.ZodNumber>;
-    shutdownSource: z.ZodOptional<z.ZodUnion<[z.ZodEnum<["mobile-app", "cli", "os-signal", "unknown"]>, z.ZodString]>>;
+    shutdownSource: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
     status: string;
     pid?: number | undefined;
@@ -541,218 +404,63 @@ declare const DaemonStateSchema: z.ZodObject<{
 type DaemonState = z.infer<typeof DaemonStateSchema>;
 type Machine = {
     id: string;
-    dataEncryptionKey: string;
-    encryptionKey: Uint8Array;
-    metadata: MachineMetadata;
-    metadataVersion: number;
+    seq: number;
+    active: boolean;
+    activeAt: number | null;
+    createdAt: number | null;
+    updatedAt: number | null;
+    metadata: MachineMetadata | null;
     daemonState: DaemonState | null;
-    daemonStateVersion: number;
-};
-declare const UserMessageSchema: z.ZodObject<{
-    role: z.ZodLiteral<"user">;
-    content: z.ZodObject<{
-        type: z.ZodLiteral<"text">;
-        text: z.ZodString;
-    }, "strip", z.ZodTypeAny, {
-        type: "text";
-        text: string;
-    }, {
-        type: "text";
-        text: string;
-    }>;
-    localKey: z.ZodOptional<z.ZodString>;
-    meta: z.ZodOptional<z.ZodObject<{
-        sentFrom: z.ZodOptional<z.ZodString>;
-        permissionMode: z.ZodOptional<z.ZodString>;
-        model: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        customSystemPrompt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        appendSystemPrompt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        allowedTools: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString, "many">>>;
-        disallowedTools: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString, "many">>>;
-        displayText: z.ZodOptional<z.ZodString>;
-        attachments: z.ZodOptional<z.ZodObject<{
-            images: z.ZodOptional<z.ZodArray<z.ZodObject<{
-                mimeType: z.ZodString;
-                base64: z.ZodString;
-                name: z.ZodOptional<z.ZodString>;
-                width: z.ZodOptional<z.ZodNumber>;
-                height: z.ZodOptional<z.ZodNumber>;
-            }, "strip", z.ZodTypeAny, {
-                mimeType: string;
-                base64: string;
-                name?: string | undefined;
-                width?: number | undefined;
-                height?: number | undefined;
-            }, {
-                mimeType: string;
-                base64: string;
-                name?: string | undefined;
-                width?: number | undefined;
-                height?: number | undefined;
-            }>, "many">>;
-        }, "strip", z.ZodTypeAny, {
-            images?: {
-                mimeType: string;
-                base64: string;
-                name?: string | undefined;
-                width?: number | undefined;
-                height?: number | undefined;
-            }[] | undefined;
-        }, {
-            images?: {
-                mimeType: string;
-                base64: string;
-                name?: string | undefined;
-                width?: number | undefined;
-                height?: number | undefined;
-            }[] | undefined;
-        }>>;
-    }, "strip", z.ZodTypeAny, {
-        sentFrom?: string | undefined;
-        permissionMode?: string | undefined;
-        model?: string | null | undefined;
-        customSystemPrompt?: string | null | undefined;
-        appendSystemPrompt?: string | null | undefined;
-        allowedTools?: string[] | null | undefined;
-        disallowedTools?: string[] | null | undefined;
-        displayText?: string | undefined;
-        attachments?: {
-            images?: {
-                mimeType: string;
-                base64: string;
-                name?: string | undefined;
-                width?: number | undefined;
-                height?: number | undefined;
-            }[] | undefined;
-        } | undefined;
-    }, {
-        sentFrom?: string | undefined;
-        permissionMode?: string | undefined;
-        model?: string | null | undefined;
-        customSystemPrompt?: string | null | undefined;
-        appendSystemPrompt?: string | null | undefined;
-        allowedTools?: string[] | null | undefined;
-        disallowedTools?: string[] | null | undefined;
-        displayText?: string | undefined;
-        attachments?: {
-            images?: {
-                mimeType: string;
-                base64: string;
-                name?: string | undefined;
-                width?: number | undefined;
-                height?: number | undefined;
-            }[] | undefined;
-        } | undefined;
-    }>>;
-}, "strip", z.ZodTypeAny, {
-    content: {
-        type: "text";
-        text: string;
-    };
-    role: "user";
-    localKey?: string | undefined;
-    meta?: {
-        sentFrom?: string | undefined;
-        permissionMode?: string | undefined;
-        model?: string | null | undefined;
-        customSystemPrompt?: string | null | undefined;
-        appendSystemPrompt?: string | null | undefined;
-        allowedTools?: string[] | null | undefined;
-        disallowedTools?: string[] | null | undefined;
-        displayText?: string | undefined;
-        attachments?: {
-            images?: {
-                mimeType: string;
-                base64: string;
-                name?: string | undefined;
-                width?: number | undefined;
-                height?: number | undefined;
-            }[] | undefined;
-        } | undefined;
-    } | undefined;
-}, {
-    content: {
-        type: "text";
-        text: string;
-    };
-    role: "user";
-    localKey?: string | undefined;
-    meta?: {
-        sentFrom?: string | undefined;
-        permissionMode?: string | undefined;
-        model?: string | null | undefined;
-        customSystemPrompt?: string | null | undefined;
-        appendSystemPrompt?: string | null | undefined;
-        allowedTools?: string[] | null | undefined;
-        disallowedTools?: string[] | null | undefined;
-        displayText?: string | undefined;
-        attachments?: {
-            images?: {
-                mimeType: string;
-                base64: string;
-                name?: string | undefined;
-                width?: number | undefined;
-                height?: number | undefined;
-            }[] | undefined;
-        } | undefined;
-    } | undefined;
-}>;
-type UserMessage = z.infer<typeof UserMessageSchema>;
-type Metadata = {
-    path: string;
-    projectRootPath?: string;
-    host: string;
-    version?: string;
-    name?: string;
-    os?: string;
-    summary?: {
-        text: string;
-        updatedAt: number;
-    };
-    machineId?: string;
-    workspaceProjectId?: string;
-    featureId?: string;
-    workItemId?: string;
-    claudeSessionId?: string;
-    tools?: string[];
-    slashCommands?: string[];
-    homeDir: string;
-    flockbayHomeDir: string;
-    flockbayLibDir: string;
-    flockbayToolsDir: string;
-    startedFromDaemon?: boolean;
-    hostPid?: number;
-    startedBy?: 'daemon' | 'terminal';
-    lifecycleState?: 'running' | 'archiveRequested' | 'archived' | string;
-    lifecycleStateSince?: number;
-    archivedBy?: string;
-    archiveReason?: string;
-    flavor?: string;
 };
-type AgentState = {
-    controlledByUser?: boolean | null | undefined;
-    requests?: {
-        [id: string]: {
-            tool: string;
-            arguments: any;
-            createdAt: number;
-        };
-    };
-    completedRequests?: {
-        [id: string]: {
-            tool: string;
-            arguments: any;
-            createdAt: number;
-            completedAt: number;
-            status: 'canceled' | 'denied' | 'approved';
-            reason?: string;
-            mode?: PermissionMode;
-            decision?: 'approved' | 'approved_for_session' | 'denied' | 'abort';
-            allowTools?: string[];
-        };
-    };
+type AgentState = Record<string, any>;
+type Metadata = Record<string, any>;
+type Session = {
+    id: string;
+    seq: number;
+    active: boolean;
+    activeAt: number | null;
+    createdAt: number | null;
+    updatedAt: number | null;
+    metadata: Metadata | null;
+    metadataVersion: number;
+    agentState: AgentState | null;
+    agentStateVersion: number;
 };
 
+declare class ApiSessionClient extends EventEmitter {
+    private readonly token;
+    readonly sessionId: string;
+    private metadata;
+    private metadataVersion;
+    private agentState;
+    private agentStateVersion;
+    private socket;
+    readonly rpcHandlerManager: RpcHandlerManager;
+    readonly coordinationLeaseGuard: CoordinationLeaseGuard;
+    private coordinationLedgerLastReadAtMs;
+    private readonly outboundQueue;
+    constructor(token: string, session: Session);
+    connect(): void;
+    connectAndWait(timeoutMs?: number): Promise<void>;
+    disconnect(): void;
+    close(): void;
+    getAuthToken(): string;
+    listMessages(): Promise<any[]>;
+    markCoordinationLedgerRead(timeMs?: number): void;
+    getCoordinationLedgerLastReadAtMs(): number | null;
+    keepAlive(thinking: boolean, mode: 'local' | 'remote'): void;
+    sendSessionDeath(): void;
+    sendSessionEvent(event: any): void;
+    sendCodexMessage(body: any): void;
+    sendAgentMessage(agentType: 'gemini' | 'codex' | 'claude' | 'opencode', body: any): void;
+    sendClaudeSessionMessage(body: any): void;
+    private emitMessageOrQueue;
+    flush(): void;
+    onUserMessage(handler: (message: any) => void): () => void;
+    updateMetadata(handler: (metadata: Metadata) => Metadata): void;
+    updateAgentState(handler: (state: AgentState) => AgentState): void;
+}
+
 interface SpawnSessionOptions {
     machineId?: string;
     directory: string;
@@ -796,109 +504,88 @@ declare class ApiMachineClient {
     private socket;
     private keepAliveInterval;
     private rpcHandlerManager;
+    private connected;
+    private lastConnectError;
+    private lastDisconnectReason;
+    private lastHttpUpsertError;
+    private lastHttpUpsertStatus;
+    private lastHttpUpsertAt;
+    private readonly upsertBackoff;
     constructor(token: string, machine: Machine);
     setRPCHandlers({ spawnSession, stopSession, requestShutdown }: MachineRpcHandlers): void;
     /**
-     * Update machine metadata
-     * Currently unused, changes from the mobile client are more likely
-     * for example to set a custom name.
+     * Upsert machine record (metadata + daemon state) via HTTP (workspace-native V1).
      */
-    updateMachineMetadata(handler: (metadata: MachineMetadata | null) => MachineMetadata): Promise<void>;
+    private upsertMachineHttp;
     /**
-     * Update daemon state (runtime info) - similar to session updateAgentState
-     * Simplified without lock - relies on backoff for retry
+     * Update daemon state (runtime info) via HTTP upsert.
      */
     updateDaemonState(handler: (state: DaemonState | null) => DaemonState): Promise<void>;
+    /**
+     * Best-effort single attempt (no retries). Useful during shutdown.
+     */
+    updateDaemonStateOnce(handler: (state: DaemonState | null) => DaemonState): Promise<boolean>;
+    getStatusSnapshot(): {
+        connected: boolean;
+        lastConnectError: string | null;
+        lastDisconnectReason: string | null;
+        lastHttpUpsertError: string | null;
+        lastHttpUpsertStatus: number | null;
+        lastHttpUpsertAt: number | null;
+    };
     connect(): void;
     private startKeepAlive;
     private stopKeepAlive;
     shutdown(): void;
 }
 
-interface PushToken {
-    id: string;
-    token: string;
-    createdAt: number;
-    updatedAt: number;
-}
-declare class PushNotificationClient {
-    private readonly token;
-    private readonly baseUrl;
-    private readonly expo;
-    constructor(token: string, baseUrl?: string);
-    /**
-     * Fetch all push tokens for the authenticated user
-     */
-    fetchPushTokens(): Promise<PushToken[]>;
-    /**
-     * Send push notification via Expo Push API with retry
-     * @param messages - Array of push messages to send
-     */
-    sendPushNotifications(messages: ExpoPushMessage[]): Promise<void>;
-    /**
-     * Send a push notification to all registered devices for the user
-     * @param title - Notification title
-     * @param body - Notification body
-     * @param data - Additional data to send with the notification
-     */
-    sendToAllDevices(title: string, body: string, data?: Record<string, any>): void;
-}
-
 /**
  * Minimal persistence functions for Flockbay CLI
  *
  * Handles settings and private key storage in ~/.flockbay/
  */
 
-type Credentials = {
-    token: string;
-    encryption: {
-        type: 'dataKey';
-        publicKey: Uint8Array;
-        machineKey: Uint8Array;
-    };
+type WorkspaceAuth = {
+    machineToken: string;
+    orgId: string;
+    createdAtMs?: number;
 };
 
 declare class ApiClient {
-    static create(credential: Credentials): Promise<ApiClient>;
-    private readonly credential;
-    private readonly pushClient;
+    private readonly auth;
+    static create(auth: WorkspaceAuth): Promise<ApiClient>;
     private constructor();
-    /**
-     * Create a new session or load existing one with the given tag
-     */
+    private baseUrl;
+    createSession(opts: {
+        metadata: any;
+        state?: AgentState | null;
+    }): Promise<Session>;
     getOrCreateSession(opts: {
-        tag: string;
-        metadata: Metadata;
-        state: AgentState | null;
+        tag?: string | null;
+        metadata: any;
+        state?: AgentState | null;
     }): Promise<Session>;
-    /**
-     * Register or update machine with the server
-     * Returns the current machine state from the server with decrypted metadata and daemonState
-     */
+    getSessionById(sessionId: string): Promise<Session>;
+    upsertMachine(opts: {
+        machineId: string;
+        metadata: MachineMetadata;
+        daemonState?: DaemonState | null;
+    }): Promise<Machine>;
     getOrCreateMachine(opts: {
         machineId: string;
         metadata: MachineMetadata;
-        daemonState?: DaemonState;
+        daemonState?: DaemonState | null;
     }): Promise<Machine>;
-    /**
-     * Fetch an existing machine by id.
-     * Useful when the daemon needs the latest server-side machine metadata (e.g. dev toggles).
-     */
     getMachine(machineId: string): Promise<Machine>;
+    registerVendorToken(vendor: string, token: any): Promise<{
+        ok: true;
+    }>;
+    getVendorToken(vendor: string): Promise<any | null>;
+    push(): {
+        sendToAllDevices: (...args: any[]) => Promise<void>;
+    };
     sessionSyncClient(session: Session): ApiSessionClient;
     machineSyncClient(machine: Machine): ApiMachineClient;
-    push(): PushNotificationClient;
-    /**
-     * Register a vendor API token with the server
-     * The token is sent as a JSON string - server handles encryption
-     */
-    registerVendorToken(vendor: 'openai' | 'anthropic' | 'gemini', apiKey: any): Promise<void>;
-    /**
-     * Get vendor API token from the server
-     * Returns the token if it exists, null otherwise
-     */
-    getVendorToken(vendor: 'openai' | 'anthropic' | 'gemini'): Promise<any | null>;
 }
 
 /**
@@ -940,6 +627,7 @@ declare class Configuration {
     readonly serverUrl: string;
     readonly webappUrl: string;
     readonly isDaemonProcess: boolean;
+    readonly profile: string;
     readonly flockbayHomeDir: string;
     readonly logsDir: string;
     readonly settingsFile: string;