@realtimex/sdk 2.0.31 → 2.0.33

package/README.md

@@ -19,10 +19,41 @@ const workspaces = await client.request("listWorkspaces");
 `REALTIMEX_BASE_URL`. Desktop and `dev:all` runtimes propagate the resolved
 dynamic `/cli` endpoint; the SDK does not guess a localhost port.
 
+## Webhook endpoint management
+
+Webhook endpoints can be managed through the generated authenticated client.
+These control-plane operations require an authenticated, user-bound session
+credential.
+
+```js
+const { createRealtimeXClient } = require("@realtimex/sdk");
+
+const client = createRealtimeXClient({
+  baseUrl: process.env.REALTIMEX_BASE_URL,
+  token: process.env.REALTIMEX_AUTH_TOKEN,
+});
+
+const created = await client.createWebhookEndpoint({
+  name: "Build tasks",
+  workspaceId: 7,
+  secret: process.env.REALTIMEX_WEBHOOK_SECRET,
+  dispatchMode: "trigger_agent",
+});
+
+await client.listWebhookDeliveries({
+  endpointId: created.endpoint.id,
+  limit: 25,
+});
+```
+
+The `secret` field is write-only. Endpoint responses report
+`secretConfigured`; they never contain the plaintext secret, ciphertext, or a
+secret-storage reference. Deletion additionally requires
+`{ confirmDestructive: true }`.
+
 ## Public webhook task delivery
 
 Use a separate webhook client to trigger an existing public webhook endpoint.
-Webhook endpoint creation and editing remain in RealtimeX settings.
 
 ```js
 const { createRealtimeXWebhookClient } = require("@realtimex/sdk");

package/index.d.ts

@@ -151,6 +151,29 @@ export interface CreateChannelOptions extends RealtimeXRequestOptions {
   body?: CreateChannelBody;
 }
 
+export type CreateLocalAppParams = Record<string, never>;
+export type CreateLocalAppQuery = Record<string, never>;
+export type CreateLocalAppHeaders = Record<string, never>;
+export type CreateLocalAppBody = {
+  displayName: string;
+  description?: string;
+  sourceType: "source" | "npx" | "uvx";
+  sourcePath?: string;
+  packageInput?: string;
+  homeUrl?: string;
+  env?: {
+  [key: string]: string;
+};
+  tags?: Array<string>;
+};
+export type CreateLocalAppResponse = Record<string, unknown>;
+export interface CreateLocalAppOptions extends RealtimeXRequestOptions {
+  params?: CreateLocalAppParams;
+  query?: CreateLocalAppQuery;
+  headers?: CreateLocalAppHeaders & Record<string, string>;
+  body?: CreateLocalAppBody;
+}
+
 export type CreateThreadParams = {
   workspaceSlug: string;
 };
@@ -169,6 +192,41 @@ export interface CreateThreadOptions extends RealtimeXRequestOptions {
   body?: CreateThreadBody;
 }
 
+export type CreateWebhookEndpointParams = Record<string, never>;
+export type CreateWebhookEndpointQuery = Record<string, never>;
+export type CreateWebhookEndpointHeaders = Record<string, never>;
+export type CreateWebhookEndpointBody = {
+  name: string;
+  workspaceId: number;
+  preset?: string;
+  enabled?: boolean;
+  secret: string;
+  signatureHeader?: string;
+  signaturePrefix?: string;
+  timestampHeader?: string;
+  deliveryIdHeader?: string;
+  eventTypeHeader?: string;
+  sourceHeader?: string;
+  allowedSourcePaths?: Array<string>;
+  replayWindowSeconds?: number;
+  payloadSizeLimitBytes?: number;
+  dispatchMode?: "record_only" | "send_to_thread" | "trigger_agent" | "trigger_flow";
+  triggerFlowId?: string;
+  agentTask?: Record<string, unknown>;
+  persistPayloadMode?: "none" | "attachment";
+  payloadStorageWorkspaceId?: number;
+  payloadStorageSubpath?: string;
+  dispatchInstruction?: string;
+  includePayloadPreview?: boolean;
+};
+export type CreateWebhookEndpointResponse = Record<string, unknown>;
+export interface CreateWebhookEndpointOptions extends RealtimeXRequestOptions {
+  params?: CreateWebhookEndpointParams;
+  query?: CreateWebhookEndpointQuery;
+  headers?: CreateWebhookEndpointHeaders & Record<string, string>;
+  body?: CreateWebhookEndpointBody;
+}
+
 export type CreateWorkspaceParams = Record<string, never>;
 export type CreateWorkspaceQuery = Record<string, never>;
 export type CreateWorkspaceHeaders = {
@@ -238,6 +296,22 @@ export interface DeleteChannelOptions extends RealtimeXRequestOptions {
   body?: DeleteChannelBody;
 }
 
+export type DeleteLocalAppParams = {
+  appId: string;
+};
+export type DeleteLocalAppQuery = Record<string, never>;
+export type DeleteLocalAppHeaders = Record<string, never>;
+export type DeleteLocalAppBody = {
+  confirmDestructive: true;
+};
+export type DeleteLocalAppResponse = Record<string, unknown>;
+export interface DeleteLocalAppOptions extends RealtimeXRequestOptions {
+  params?: DeleteLocalAppParams;
+  query?: DeleteLocalAppQuery;
+  headers?: DeleteLocalAppHeaders & Record<string, string>;
+  body?: DeleteLocalAppBody;
+}
+
 export type DeleteThreadParams = {
   workspaceSlug: string;
   threadSlug: string;
@@ -255,6 +329,22 @@ export interface DeleteThreadOptions extends RealtimeXRequestOptions {
   body?: DeleteThreadBody;
 }
 
+export type DeleteWebhookEndpointParams = {
+  endpointId: string;
+};
+export type DeleteWebhookEndpointQuery = Record<string, never>;
+export type DeleteWebhookEndpointHeaders = Record<string, never>;
+export type DeleteWebhookEndpointBody = {
+  confirmDestructive: true;
+};
+export type DeleteWebhookEndpointResponse = Record<string, unknown>;
+export interface DeleteWebhookEndpointOptions extends RealtimeXRequestOptions {
+  params?: DeleteWebhookEndpointParams;
+  query?: DeleteWebhookEndpointQuery;
+  headers?: DeleteWebhookEndpointHeaders & Record<string, string>;
+  body?: DeleteWebhookEndpointBody;
+}
+
 export type DeleteWorkspaceParams = {
   workspaceSlug: string;
 };
@@ -355,6 +445,50 @@ export interface GetArtifactOptions extends RealtimeXRequestOptions {
   body?: GetArtifactBody;
 }
 
+export type GetLocalAppParams = {
+  appId: string;
+};
+export type GetLocalAppQuery = Record<string, never>;
+export type GetLocalAppHeaders = Record<string, never>;
+export type GetLocalAppBody = unknown;
+export type GetLocalAppResponse = Record<string, unknown>;
+export interface GetLocalAppOptions extends RealtimeXRequestOptions {
+  params?: GetLocalAppParams;
+  query?: GetLocalAppQuery;
+  headers?: GetLocalAppHeaders & Record<string, string>;
+  body?: GetLocalAppBody;
+}
+
+export type GetLocalAppLogsParams = {
+  appId: string;
+};
+export type GetLocalAppLogsQuery = {
+  limit?: number;
+};
+export type GetLocalAppLogsHeaders = Record<string, never>;
+export type GetLocalAppLogsBody = unknown;
+export type GetLocalAppLogsResponse = Record<string, unknown>;
+export interface GetLocalAppLogsOptions extends RealtimeXRequestOptions {
+  params?: GetLocalAppLogsParams;
+  query?: GetLocalAppLogsQuery;
+  headers?: GetLocalAppLogsHeaders & Record<string, string>;
+  body?: GetLocalAppLogsBody;
+}
+
+export type GetLocalAppStatusParams = {
+  appId: string;
+};
+export type GetLocalAppStatusQuery = Record<string, never>;
+export type GetLocalAppStatusHeaders = Record<string, never>;
+export type GetLocalAppStatusBody = unknown;
+export type GetLocalAppStatusResponse = Record<string, unknown>;
+export interface GetLocalAppStatusOptions extends RealtimeXRequestOptions {
+  params?: GetLocalAppStatusParams;
+  query?: GetLocalAppStatusQuery;
+  headers?: GetLocalAppStatusHeaders & Record<string, string>;
+  body?: GetLocalAppStatusBody;
+}
+
 export type GetPluginParams = {
   pluginId: string;
 };
@@ -407,6 +541,20 @@ export interface GetThreadOptions extends RealtimeXRequestOptions {
   body?: GetThreadBody;
 }
 
+export type GetWebhookEndpointParams = {
+  endpointId: string;
+};
+export type GetWebhookEndpointQuery = Record<string, never>;
+export type GetWebhookEndpointHeaders = Record<string, never>;
+export type GetWebhookEndpointBody = unknown;
+export type GetWebhookEndpointResponse = Record<string, unknown>;
+export interface GetWebhookEndpointOptions extends RealtimeXRequestOptions {
+  params?: GetWebhookEndpointParams;
+  query?: GetWebhookEndpointQuery;
+  headers?: GetWebhookEndpointHeaders & Record<string, string>;
+  body?: GetWebhookEndpointBody;
+}
+
 export type GetWorkspaceParams = {
   workspaceSlug: string;
 };
@@ -547,6 +695,18 @@ export interface ListLlmProvidersOptions extends RealtimeXRequestOptions {
   body?: ListLlmProvidersBody;
 }
 
+export type ListLocalAppsParams = Record<string, never>;
+export type ListLocalAppsQuery = Record<string, never>;
+export type ListLocalAppsHeaders = Record<string, never>;
+export type ListLocalAppsBody = unknown;
+export type ListLocalAppsResponse = Record<string, unknown>;
+export interface ListLocalAppsOptions extends RealtimeXRequestOptions {
+  params?: ListLocalAppsParams;
+  query?: ListLocalAppsQuery;
+  headers?: ListLocalAppsHeaders & Record<string, string>;
+  body?: ListLocalAppsBody;
+}
+
 export type ListPluginsParams = Record<string, never>;
 export type ListPluginsQuery = Record<string, never>;
 export type ListPluginsHeaders = {
@@ -610,6 +770,34 @@ export interface ListThreadsOptions extends RealtimeXRequestOptions {
   body?: ListThreadsBody;
 }
 
+export type ListWebhookDeliveriesParams = Record<string, never>;
+export type ListWebhookDeliveriesQuery = {
+  endpointId?: string;
+  limit?: number;
+  offset?: number;
+};
+export type ListWebhookDeliveriesHeaders = Record<string, never>;
+export type ListWebhookDeliveriesBody = unknown;
+export type ListWebhookDeliveriesResponse = Record<string, unknown>;
+export interface ListWebhookDeliveriesOptions extends RealtimeXRequestOptions {
+  params?: ListWebhookDeliveriesParams;
+  query?: ListWebhookDeliveriesQuery;
+  headers?: ListWebhookDeliveriesHeaders & Record<string, string>;
+  body?: ListWebhookDeliveriesBody;
+}
+
+export type ListWebhookEndpointsParams = Record<string, never>;
+export type ListWebhookEndpointsQuery = Record<string, never>;
+export type ListWebhookEndpointsHeaders = Record<string, never>;
+export type ListWebhookEndpointsBody = unknown;
+export type ListWebhookEndpointsResponse = Record<string, unknown>;
+export interface ListWebhookEndpointsOptions extends RealtimeXRequestOptions {
+  params?: ListWebhookEndpointsParams;
+  query?: ListWebhookEndpointsQuery;
+  headers?: ListWebhookEndpointsHeaders & Record<string, string>;
+  body?: ListWebhookEndpointsBody;
+}
+
 export type ListWorkspaceAgentSkillsParams = {
   workspaceSlug: string;
 };
@@ -857,6 +1045,20 @@ export interface RespondTerminalIdlePromptOptions extends RealtimeXRequestOption
   body?: RespondTerminalIdlePromptBody;
 }
 
+export type RestartLocalAppParams = {
+  appId: string;
+};
+export type RestartLocalAppQuery = Record<string, never>;
+export type RestartLocalAppHeaders = Record<string, never>;
+export type RestartLocalAppBody = unknown;
+export type RestartLocalAppResponse = Record<string, unknown>;
+export interface RestartLocalAppOptions extends RealtimeXRequestOptions {
+  params?: RestartLocalAppParams;
+  query?: RestartLocalAppQuery;
+  headers?: RestartLocalAppHeaders & Record<string, string>;
+  body?: RestartLocalAppBody;
+}
+
 export type ResumeArtifactParams = {
   artifactId: string;
 };
@@ -1177,6 +1379,22 @@ export interface SetHeartbeatTimezoneOptions extends RealtimeXRequestOptions {
   body?: SetHeartbeatTimezoneBody;
 }
 
+export type SetLocalAppEnabledParams = {
+  appId: string;
+};
+export type SetLocalAppEnabledQuery = Record<string, never>;
+export type SetLocalAppEnabledHeaders = Record<string, never>;
+export type SetLocalAppEnabledBody = {
+  enabled: boolean;
+};
+export type SetLocalAppEnabledResponse = Record<string, unknown>;
+export interface SetLocalAppEnabledOptions extends RealtimeXRequestOptions {
+  params?: SetLocalAppEnabledParams;
+  query?: SetLocalAppEnabledQuery;
+  headers?: SetLocalAppEnabledHeaders & Record<string, string>;
+  body?: SetLocalAppEnabledBody;
+}
+
 export type SetupHeartbeatTasksParams = Record<string, never>;
 export type SetupHeartbeatTasksQuery = {
   workspaceSlug?: string;
@@ -1314,6 +1532,20 @@ export interface StartChannelOptions extends RealtimeXRequestOptions {
   body?: StartChannelBody;
 }
 
+export type StartLocalAppParams = {
+  appId: string;
+};
+export type StartLocalAppQuery = Record<string, never>;
+export type StartLocalAppHeaders = Record<string, never>;
+export type StartLocalAppBody = unknown;
+export type StartLocalAppResponse = Record<string, unknown>;
+export interface StartLocalAppOptions extends RealtimeXRequestOptions {
+  params?: StartLocalAppParams;
+  query?: StartLocalAppQuery;
+  headers?: StartLocalAppHeaders & Record<string, string>;
+  body?: StartLocalAppBody;
+}
+
 export type StopBrowserSessionParams = {
   sessionName: string;
 };
@@ -1348,6 +1580,22 @@ export interface StopChannelOptions extends RealtimeXRequestOptions {
   body?: StopChannelBody;
 }
 
+export type StopLocalAppParams = {
+  appId: string;
+};
+export type StopLocalAppQuery = Record<string, never>;
+export type StopLocalAppHeaders = Record<string, never>;
+export type StopLocalAppBody = {
+  force?: boolean;
+};
+export type StopLocalAppResponse = Record<string, unknown>;
+export interface StopLocalAppOptions extends RealtimeXRequestOptions {
+  params?: StopLocalAppParams;
+  query?: StopLocalAppQuery;
+  headers?: StopLocalAppHeaders & Record<string, string>;
+  body?: StopLocalAppBody;
+}
+
 export type StopThreadTerminalSessionParams = Record<string, never>;
 export type StopThreadTerminalSessionQuery = Record<string, never>;
 export type StopThreadTerminalSessionHeaders = {
@@ -1378,6 +1626,22 @@ export interface TerminateTerminalSessionOptions extends RealtimeXRequestOptions
   body?: TerminateTerminalSessionBody;
 }
 
+export type TestWebhookEndpointParams = {
+  endpointId: string;
+};
+export type TestWebhookEndpointQuery = Record<string, never>;
+export type TestWebhookEndpointHeaders = Record<string, never>;
+export type TestWebhookEndpointBody = {
+  payload?: Record<string, unknown>;
+};
+export type TestWebhookEndpointResponse = Record<string, unknown>;
+export interface TestWebhookEndpointOptions extends RealtimeXRequestOptions {
+  params?: TestWebhookEndpointParams;
+  query?: TestWebhookEndpointQuery;
+  headers?: TestWebhookEndpointHeaders & Record<string, string>;
+  body?: TestWebhookEndpointBody;
+}
+
 export type TriggerWorkspaceHeartbeatParams = {
   workspaceSlug: string;
 };
@@ -1438,6 +1702,64 @@ export interface UpdateChannelOptions extends RealtimeXRequestOptions {
   body?: UpdateChannelBody;
 }
 
+export type UpdateLocalAppParams = {
+  appId: string;
+};
+export type UpdateLocalAppQuery = Record<string, never>;
+export type UpdateLocalAppHeaders = Record<string, never>;
+export type UpdateLocalAppBody = {
+  displayName?: string;
+  description?: string;
+  homeUrl?: string;
+  env?: {
+  [key: string]: string;
+};
+};
+export type UpdateLocalAppResponse = Record<string, unknown>;
+export interface UpdateLocalAppOptions extends RealtimeXRequestOptions {
+  params?: UpdateLocalAppParams;
+  query?: UpdateLocalAppQuery;
+  headers?: UpdateLocalAppHeaders & Record<string, string>;
+  body?: UpdateLocalAppBody;
+}
+
+export type UpdateWebhookEndpointParams = {
+  endpointId: string;
+};
+export type UpdateWebhookEndpointQuery = Record<string, never>;
+export type UpdateWebhookEndpointHeaders = Record<string, never>;
+export type UpdateWebhookEndpointBody = {
+  name?: string;
+  workspaceId?: number;
+  preset?: string;
+  enabled?: boolean;
+  secret?: string;
+  signatureHeader?: string;
+  signaturePrefix?: string;
+  timestampHeader?: string;
+  deliveryIdHeader?: string;
+  eventTypeHeader?: string;
+  sourceHeader?: string;
+  allowedSourcePaths?: Array<string>;
+  replayWindowSeconds?: number;
+  payloadSizeLimitBytes?: number;
+  dispatchMode?: "record_only" | "send_to_thread" | "trigger_agent" | "trigger_flow";
+  triggerFlowId?: string;
+  agentTask?: Record<string, unknown>;
+  persistPayloadMode?: "none" | "attachment";
+  payloadStorageWorkspaceId?: number;
+  payloadStorageSubpath?: string;
+  dispatchInstruction?: string;
+  includePayloadPreview?: boolean;
+};
+export type UpdateWebhookEndpointResponse = Record<string, unknown>;
+export interface UpdateWebhookEndpointOptions extends RealtimeXRequestOptions {
+  params?: UpdateWebhookEndpointParams;
+  query?: UpdateWebhookEndpointQuery;
+  headers?: UpdateWebhookEndpointHeaders & Record<string, string>;
+  body?: UpdateWebhookEndpointBody;
+}
+
 export type WorkspaceShellLayoutParams = Record<string, never>;
 export type WorkspaceShellLayoutQuery = Record<string, never>;
 export type WorkspaceShellLayoutHeaders = Record<string, never>;
@@ -1560,9 +1882,14 @@ export declare class RealtimeXClient {
   /** Create a chat channel in one exact workspace. Defaults to Telegram when plugin_type, channelType, and type are omitted. Use flat botToken and thread_id fields instead of nested config/settings. */
   createChannel(options?: CreateChannelOptions): Promise<CreateChannelResponse>;
   createChannel(workspaceSlug: string, body: CreateChannelBody, options?: Omit<CreateChannelOptions, 'params' | 'body'>): Promise<CreateChannelResponse>;
+  createLocalApp(options?: CreateLocalAppOptions): Promise<CreateLocalAppResponse>;
+  createLocalApp(body: CreateLocalAppBody, options?: Omit<CreateLocalAppOptions, 'body'>): Promise<CreateLocalAppResponse>;
   /** Create a thread in one workspace. The name is optional but recommended. */
   createThread(options?: CreateThreadOptions): Promise<CreateThreadResponse>;
   createThread(workspaceSlug: string, body: CreateThreadBody, options?: Omit<CreateThreadOptions, 'params' | 'body'>): Promise<CreateThreadResponse>;
+  /** Create a webhook endpoint in an accessible workspace. secret is a write-only input. */
+  createWebhookEndpoint(options?: CreateWebhookEndpointOptions): Promise<CreateWebhookEndpointResponse>;
+  createWebhookEndpoint(body: CreateWebhookEndpointBody, options?: Omit<CreateWebhookEndpointOptions, 'body'>): Promise<CreateWebhookEndpointResponse>;
   /** Create a workspace. Requires a human-readable workspace name. */
   createWorkspace(options?: CreateWorkspaceOptions): Promise<CreateWorkspaceResponse>;
   createWorkspace(body: CreateWorkspaceBody, options?: Omit<CreateWorkspaceOptions, 'body'>): Promise<CreateWorkspaceResponse>;
@@ -1575,9 +1902,14 @@ export declare class RealtimeXClient {
   /** Delete one chat channel by exact channel id. */
   deleteChannel(options?: DeleteChannelOptions): Promise<DeleteChannelResponse>;
   deleteChannel(channelId: string, options?: Omit<DeleteChannelOptions, 'params'>): Promise<DeleteChannelResponse>;
+  deleteLocalApp(options?: DeleteLocalAppOptions): Promise<DeleteLocalAppResponse>;
+  deleteLocalApp(appId: string, body: DeleteLocalAppBody, options?: Omit<DeleteLocalAppOptions, 'params' | 'body'>): Promise<DeleteLocalAppResponse>;
   /** Delete one thread by exact workspace slug and exact thread slug. */
   deleteThread(options?: DeleteThreadOptions): Promise<DeleteThreadResponse>;
   deleteThread(params: DeleteThreadParams, options?: Omit<DeleteThreadOptions, 'params'>): Promise<DeleteThreadResponse>;
+  /** Permanently delete a visible webhook endpoint. confirmDestructive must be true. */
+  deleteWebhookEndpoint(options?: DeleteWebhookEndpointOptions): Promise<DeleteWebhookEndpointResponse>;
+  deleteWebhookEndpoint(endpointId: string, body: DeleteWebhookEndpointBody, options?: Omit<DeleteWebhookEndpointOptions, 'params' | 'body'>): Promise<DeleteWebhookEndpointResponse>;
   /** Delete one workspace by exact workspace slug. */
   deleteWorkspace(options?: DeleteWorkspaceOptions): Promise<DeleteWorkspaceResponse>;
   deleteWorkspace(workspaceSlug: string, options?: Omit<DeleteWorkspaceOptions, 'params'>): Promise<DeleteWorkspaceResponse>;
@@ -1596,6 +1928,13 @@ export declare class RealtimeXClient {
   /** Get one public artifact by artifact id. */
   getArtifact(options?: GetArtifactOptions): Promise<GetArtifactResponse>;
   getArtifact(artifactId: string, options?: Omit<GetArtifactOptions, 'params'>): Promise<GetArtifactResponse>;
+  getLocalApp(options?: GetLocalAppOptions): Promise<GetLocalAppResponse>;
+  getLocalApp(appId: string, options?: Omit<GetLocalAppOptions, 'params'>): Promise<GetLocalAppResponse>;
+  /** Read bounded recent desktop logs. Each entry is capped at 4 KiB and secret-bearing configuration is omitted. */
+  getLocalAppLogs(options?: GetLocalAppLogsOptions): Promise<GetLocalAppLogsResponse>;
+  getLocalAppLogs(appId: string, options?: Omit<GetLocalAppLogsOptions, 'params'>): Promise<GetLocalAppLogsResponse>;
+  getLocalAppStatus(options?: GetLocalAppStatusOptions): Promise<GetLocalAppStatusResponse>;
+  getLocalAppStatus(appId: string, options?: Omit<GetLocalAppStatusOptions, 'params'>): Promise<GetLocalAppStatusResponse>;
   /** Get one installed plugin with its config schema (keys, labels, types, defaults) and current non-secret configuration values. Secret (password-type) values are never returned; secretConfigState reports whether each one is set. Use a plugin id, name, or displayName from list-plugins. */
   getPlugin(options?: GetPluginOptions): Promise<GetPluginResponse>;
   getPlugin(pluginId: string, options?: Omit<GetPluginOptions, 'params'>): Promise<GetPluginResponse>;
@@ -1605,6 +1944,9 @@ export declare class RealtimeXClient {
   /** Get one thread by exact workspace slug and exact thread slug. */
   getThread(options?: GetThreadOptions): Promise<GetThreadResponse>;
   getThread(params: GetThreadParams, options?: Omit<GetThreadOptions, 'params'>): Promise<GetThreadResponse>;
+  /** Get one visible webhook endpoint by endpoint id. The response reports secretConfigured but never returns the secret. */
+  getWebhookEndpoint(options?: GetWebhookEndpointOptions): Promise<GetWebhookEndpointResponse>;
+  getWebhookEndpoint(endpointId: string, options?: Omit<GetWebhookEndpointOptions, 'params'>): Promise<GetWebhookEndpointResponse>;
   /** Get one workspace by exact workspace slug. */
   getWorkspace(options?: GetWorkspaceOptions): Promise<GetWorkspaceResponse>;
   getWorkspace(workspaceSlug: string, options?: Omit<GetWorkspaceOptions, 'params'>): Promise<GetWorkspaceResponse>;
@@ -1628,6 +1970,7 @@ export declare class RealtimeXClient {
   listLlmModels(provider: string, options?: Omit<ListLlmModelsOptions, 'params'>): Promise<ListLlmModelsResponse>;
   /** List supported LLM providers. Use provider ids from this response when configuring workspace or thread LLM settings. */
   listLlmProviders(options?: ListLlmProvidersOptions): Promise<ListLlmProvidersResponse>;
+  listLocalApps(options?: ListLocalAppsOptions): Promise<ListLocalAppsResponse>;
   /** List installed plugins with enabled state and runtime load status. Use returned ids with enable-plugin, disable-plugin, and reload-plugin. */
   listPlugins(options?: ListPluginsOptions): Promise<ListPluginsResponse>;
   /** List terminal CLI agents that can be used with open-terminal-session. This is the same compact agent catalog returned by prepare.agents. */
@@ -1638,6 +1981,11 @@ export declare class RealtimeXClient {
   /** List threads for one exact workspace slug. */
   listThreads(options?: ListThreadsOptions): Promise<ListThreadsResponse>;
   listThreads(workspaceSlug: string, options?: Omit<ListThreadsOptions, 'params'>): Promise<ListThreadsResponse>;
+  /** List bounded delivery metadata for visible webhook endpoints. Raw headers, bodies, signatures, and payload fields are omitted. */
+  listWebhookDeliveries(options?: ListWebhookDeliveriesOptions): Promise<ListWebhookDeliveriesResponse>;
+  listWebhookDeliveries(query?: ListWebhookDeliveriesQuery, options?: Omit<ListWebhookDeliveriesOptions, 'query'>): Promise<ListWebhookDeliveriesResponse>;
+  /** List webhook endpoints visible to the authenticated user. Secrets are never returned. */
+  listWebhookEndpoints(options?: ListWebhookEndpointsOptions): Promise<ListWebhookEndpointsResponse>;
   /** List published agent skills with enabled/disabled state for one exact workspace slug. */
   listWorkspaceAgentSkills(options?: ListWorkspaceAgentSkillsOptions): Promise<ListWorkspaceAgentSkillsResponse>;
   listWorkspaceAgentSkills(workspaceSlug: string, options?: Omit<ListWorkspaceAgentSkillsOptions, 'params'>): Promise<ListWorkspaceAgentSkillsResponse>;
@@ -1673,6 +2021,8 @@ export declare class RealtimeXClient {
   /** Send one constrained response action to an exact idle terminal session only when its PTY event sequence is unchanged. */
   respondTerminalIdlePrompt(options?: RespondTerminalIdlePromptOptions): Promise<RespondTerminalIdlePromptResponse>;
   respondTerminalIdlePrompt(sessionId: string, body: RespondTerminalIdlePromptBody, options?: Omit<RespondTerminalIdlePromptOptions, 'params' | 'body'>): Promise<RespondTerminalIdlePromptResponse>;
+  restartLocalApp(options?: RestartLocalAppOptions): Promise<RestartLocalAppResponse>;
+  restartLocalApp(appId: string, body: RestartLocalAppBody, options?: Omit<RestartLocalAppOptions, 'params' | 'body'>): Promise<RestartLocalAppResponse>;
   /** Resume one paused artifact by artifact id. */
   resumeArtifact(options?: ResumeArtifactOptions): Promise<ResumeArtifactResponse>;
   resumeArtifact(artifactId: string, options?: Omit<ResumeArtifactOptions, 'params'>): Promise<ResumeArtifactResponse>;
@@ -1721,6 +2071,8 @@ export declare class RealtimeXClient {
   /** Set workspace or global ambient-agent heartbeat timezone, for example Asia/Saigon or UTC. */
   setHeartbeatTimezone(options?: SetHeartbeatTimezoneOptions): Promise<SetHeartbeatTimezoneResponse>;
   setHeartbeatTimezone(body: SetHeartbeatTimezoneBody, options?: Omit<SetHeartbeatTimezoneOptions, 'body'>): Promise<SetHeartbeatTimezoneResponse>;
+  setLocalAppEnabled(options?: SetLocalAppEnabledOptions): Promise<SetLocalAppEnabledResponse>;
+  setLocalAppEnabled(appId: string, body: SetLocalAppEnabledBody, options?: Omit<SetLocalAppEnabledOptions, 'params' | 'body'>): Promise<SetLocalAppEnabledResponse>;
   /** Set up HEARTBEAT.md task instructions for a workspace or global ambient agent. Returns the target path, template, file path, and concise editing instructions. */
   setupHeartbeatTasks(options?: SetupHeartbeatTasksOptions): Promise<SetupHeartbeatTasksResponse>;
   setupHeartbeatTasks(query?: SetupHeartbeatTasksQuery, options?: Omit<SetupHeartbeatTasksOptions, 'query'>): Promise<SetupHeartbeatTasksResponse>;
@@ -1739,17 +2091,24 @@ export declare class RealtimeXClient {
   /** Start one chat channel by exact channel id. */
   startChannel(options?: StartChannelOptions): Promise<StartChannelResponse>;
   startChannel(channelId: string, options?: Omit<StartChannelOptions, 'params'>): Promise<StartChannelResponse>;
+  startLocalApp(options?: StartLocalAppOptions): Promise<StartLocalAppResponse>;
+  startLocalApp(appId: string, body: StartLocalAppBody, options?: Omit<StartLocalAppOptions, 'params' | 'body'>): Promise<StartLocalAppResponse>;
   /** Gracefully stop an existing named RealTimeX Browser session. */
   stopBrowserSession(options?: StopBrowserSessionOptions): Promise<StopBrowserSessionResponse>;
   stopBrowserSession(sessionName: string, body: StopBrowserSessionBody, options?: Omit<StopBrowserSessionOptions, 'params' | 'body'>): Promise<StopBrowserSessionResponse>;
   /** Stop one chat channel by exact channel id. */
   stopChannel(options?: StopChannelOptions): Promise<StopChannelResponse>;
   stopChannel(channelId: string, options?: Omit<StopChannelOptions, 'params'>): Promise<StopChannelResponse>;
+  stopLocalApp(options?: StopLocalAppOptions): Promise<StopLocalAppResponse>;
+  stopLocalApp(appId: string, body: StopLocalAppBody, options?: Omit<StopLocalAppOptions, 'params' | 'body'>): Promise<StopLocalAppResponse>;
   /** Interrupt the selected or current chat-linked terminal session for one exact thread without closing the underlying terminal session. This uses the same stop dispatcher as channel /stop commands. */
   stopThreadTerminalSession(options?: StopThreadTerminalSessionOptions): Promise<StopThreadTerminalSessionResponse>;
   /** Terminate a terminal runtime session by detaching any controller and closing the underlying PTY session. */
   terminateTerminalSession(options?: TerminateTerminalSessionOptions): Promise<TerminateTerminalSessionResponse>;
   terminateTerminalSession(sessionId: string, options?: Omit<TerminateTerminalSessionOptions, 'params'>): Promise<TerminateTerminalSessionResponse>;
+  /** Submit an optional JSON payload as a signed test delivery through a visible webhook endpoint. */
+  testWebhookEndpoint(options?: TestWebhookEndpointOptions): Promise<TestWebhookEndpointResponse>;
+  testWebhookEndpoint(endpointId: string, body: TestWebhookEndpointBody, options?: Omit<TestWebhookEndpointOptions, 'params' | 'body'>): Promise<TestWebhookEndpointResponse>;
   /** Trigger the default HEARTBEAT.md task for a workspace immediately. Falls back to the legacy heartbeat executor when no tasks are defined. */
   triggerWorkspaceHeartbeat(options?: TriggerWorkspaceHeartbeatOptions): Promise<TriggerWorkspaceHeartbeatResponse>;
   triggerWorkspaceHeartbeat(workspaceSlug: string, body: TriggerWorkspaceHeartbeatBody, options?: Omit<TriggerWorkspaceHeartbeatOptions, 'params' | 'body'>): Promise<TriggerWorkspaceHeartbeatResponse>;
@@ -1759,6 +2118,11 @@ export declare class RealtimeXClient {
   /** Update one chat channel by exact channel id. Only channel writable fields are changed. */
   updateChannel(options?: UpdateChannelOptions): Promise<UpdateChannelResponse>;
   updateChannel(channelId: string, body: UpdateChannelBody, options?: Omit<UpdateChannelOptions, 'params' | 'body'>): Promise<UpdateChannelResponse>;
+  updateLocalApp(options?: UpdateLocalAppOptions): Promise<UpdateLocalAppResponse>;
+  updateLocalApp(appId: string, body: UpdateLocalAppBody, options?: Omit<UpdateLocalAppOptions, 'params' | 'body'>): Promise<UpdateLocalAppResponse>;
+  /** Update a visible webhook endpoint. Passing secret rotates it; the value is never returned. */
+  updateWebhookEndpoint(options?: UpdateWebhookEndpointOptions): Promise<UpdateWebhookEndpointResponse>;
+  updateWebhookEndpoint(endpointId: string, body: UpdateWebhookEndpointBody, options?: Omit<UpdateWebhookEndpointOptions, 'params' | 'body'>): Promise<UpdateWebhookEndpointResponse>;
   /** Verify workspace navigation, title-bar containment, Files dock behavior, and action contrast at desktop and compact viewports. */
   workspaceShellLayout(options?: WorkspaceShellLayoutOptions): Promise<WorkspaceShellLayoutResponse>;
   workspaceShellLayout(body: WorkspaceShellLayoutBody, options?: Omit<WorkspaceShellLayoutOptions, 'body'>): Promise<WorkspaceShellLayoutResponse>;

package/index.js

@@ -70,6 +70,14 @@ const operations = {
     ],
     "hasBody": true
   },
+  "createLocalApp": {
+    "method": "POST",
+    "path": "/create-local-app",
+    "pathParams": [],
+    "queryParams": [],
+    "headerParams": [],
+    "hasBody": true
+  },
   "createThread": {
     "method": "POST",
     "path": "/create-thread/{workspaceSlug}",
@@ -82,6 +90,14 @@ const operations = {
     ],
     "hasBody": true
   },
+  "createWebhookEndpoint": {
+    "method": "POST",
+    "path": "/create-webhook-endpoint",
+    "pathParams": [],
+    "queryParams": [],
+    "headerParams": [],
+    "hasBody": true
+  },
   "createWorkspace": {
     "method": "POST",
     "path": "/create-workspace",
@@ -129,6 +145,16 @@ const operations = {
     ],
     "hasBody": false
   },
+  "deleteLocalApp": {
+    "method": "DELETE",
+    "path": "/delete-local-app/{appId}",
+    "pathParams": [
+      "appId"
+    ],
+    "queryParams": [],
+    "headerParams": [],
+    "hasBody": true
+  },
   "deleteThread": {
     "method": "DELETE",
     "path": "/delete-thread/{workspaceSlug}/{threadSlug}",
@@ -142,6 +168,16 @@ const operations = {
     ],
     "hasBody": false
   },
+  "deleteWebhookEndpoint": {
+    "method": "DELETE",
+    "path": "/delete-webhook-endpoint/{endpointId}",
+    "pathParams": [
+      "endpointId"
+    ],
+    "queryParams": [],
+    "headerParams": [],
+    "hasBody": true
+  },
   "deleteWorkspace": {
     "method": "DELETE",
     "path": "/delete-workspace/{workspaceSlug}",
@@ -218,6 +254,38 @@ const operations = {
     ],
     "hasBody": false
   },
+  "getLocalApp": {
+    "method": "GET",
+    "path": "/get-local-app/{appId}",
+    "pathParams": [
+      "appId"
+    ],
+    "queryParams": [],
+    "headerParams": [],
+    "hasBody": false
+  },
+  "getLocalAppLogs": {
+    "method": "GET",
+    "path": "/get-local-app-logs/{appId}",
+    "pathParams": [
+      "appId"
+    ],
+    "queryParams": [
+      "limit"
+    ],
+    "headerParams": [],
+    "hasBody": false
+  },
+  "getLocalAppStatus": {
+    "method": "GET",
+    "path": "/get-local-app-status/{appId}",
+    "pathParams": [
+      "appId"
+    ],
+    "queryParams": [],
+    "headerParams": [],
+    "hasBody": false
+  },
   "getPlugin": {
     "method": "GET",
     "path": "/get-plugin/{pluginId}",
@@ -258,6 +326,16 @@ const operations = {
     ],
     "hasBody": false
   },
+  "getWebhookEndpoint": {
+    "method": "GET",
+    "path": "/get-webhook-endpoint/{endpointId}",
+    "pathParams": [
+      "endpointId"
+    ],
+    "queryParams": [],
+    "headerParams": [],
+    "hasBody": false
+  },
   "getWorkspace": {
     "method": "GET",
     "path": "/get-workspace/{workspaceSlug}",
@@ -352,6 +430,14 @@ const operations = {
     ],
     "hasBody": false
   },
+  "listLocalApps": {
+    "method": "GET",
+    "path": "/list-local-apps",
+    "pathParams": [],
+    "queryParams": [],
+    "headerParams": [],
+    "hasBody": false
+  },
   "listPlugins": {
     "method": "GET",
     "path": "/list-plugins",
@@ -399,6 +485,26 @@ const operations = {
     ],
     "hasBody": false
   },
+  "listWebhookDeliveries": {
+    "method": "GET",
+    "path": "/list-webhook-deliveries",
+    "pathParams": [],
+    "queryParams": [
+      "endpointId",
+      "limit",
+      "offset"
+    ],
+    "headerParams": [],
+    "hasBody": false
+  },
+  "listWebhookEndpoints": {
+    "method": "GET",
+    "path": "/list-webhook-endpoints",
+    "pathParams": [],
+    "queryParams": [],
+    "headerParams": [],
+    "hasBody": false
+  },
   "listWorkspaceAgentSkills": {
     "method": "GET",
     "path": "/list-workspace-agent-skills/{workspaceSlug}",
@@ -541,6 +647,16 @@ const operations = {
     ],
     "hasBody": true
   },
+  "restartLocalApp": {
+    "method": "POST",
+    "path": "/restart-local-app/{appId}",
+    "pathParams": [
+      "appId"
+    ],
+    "queryParams": [],
+    "headerParams": [],
+    "hasBody": true
+  },
   "resumeArtifact": {
     "method": "POST",
     "path": "/resume-artifact/{artifactId}",
@@ -712,6 +828,16 @@ const operations = {
     ],
     "hasBody": true
   },
+  "setLocalAppEnabled": {
+    "method": "POST",
+    "path": "/set-local-app-enabled/{appId}",
+    "pathParams": [
+      "appId"
+    ],
+    "queryParams": [],
+    "headerParams": [],
+    "hasBody": true
+  },
   "setupHeartbeatTasks": {
     "method": "GET",
     "path": "/setup-heartbeat-tasks",
@@ -783,6 +909,16 @@ const operations = {
     ],
     "hasBody": false
   },
+  "startLocalApp": {
+    "method": "POST",
+    "path": "/start-local-app/{appId}",
+    "pathParams": [
+      "appId"
+    ],
+    "queryParams": [],
+    "headerParams": [],
+    "hasBody": true
+  },
   "stopBrowserSession": {
     "method": "POST",
     "path": "/stop-browser-session/{sessionName}",
@@ -807,6 +943,16 @@ const operations = {
     ],
     "hasBody": false
   },
+  "stopLocalApp": {
+    "method": "POST",
+    "path": "/stop-local-app/{appId}",
+    "pathParams": [
+      "appId"
+    ],
+    "queryParams": [],
+    "headerParams": [],
+    "hasBody": true
+  },
   "stopThreadTerminalSession": {
     "method": "POST",
     "path": "/stop-thread-terminal-session",
@@ -829,6 +975,16 @@ const operations = {
     ],
     "hasBody": false
   },
+  "testWebhookEndpoint": {
+    "method": "POST",
+    "path": "/test-webhook-endpoint/{endpointId}",
+    "pathParams": [
+      "endpointId"
+    ],
+    "queryParams": [],
+    "headerParams": [],
+    "hasBody": true
+  },
   "triggerWorkspaceHeartbeat": {
     "method": "POST",
     "path": "/trigger-workspace-heartbeat/{workspaceSlug}",
@@ -865,6 +1021,26 @@ const operations = {
     ],
     "hasBody": true
   },
+  "updateLocalApp": {
+    "method": "POST",
+    "path": "/update-local-app/{appId}",
+    "pathParams": [
+      "appId"
+    ],
+    "queryParams": [],
+    "headerParams": [],
+    "hasBody": true
+  },
+  "updateWebhookEndpoint": {
+    "method": "POST",
+    "path": "/update-webhook-endpoint/{endpointId}",
+    "pathParams": [
+      "endpointId"
+    ],
+    "queryParams": [],
+    "headerParams": [],
+    "hasBody": true
+  },
   "workspaceShellLayout": {
     "method": "POST",
     "path": "/workspace-shell-layout",
@@ -1340,6 +1516,13 @@ class RealtimeXClient {
     );
   }
 
+  createLocalApp(...args) {
+    return this.request(
+      "createLocalApp",
+      normalizeOperationOptions(operations["createLocalApp"], args)
+    );
+  }
+
   createThread(...args) {
     return this.request(
       "createThread",
@@ -1347,6 +1530,13 @@ class RealtimeXClient {
     );
   }
 
+  createWebhookEndpoint(...args) {
+    return this.request(
+      "createWebhookEndpoint",
+      normalizeOperationOptions(operations["createWebhookEndpoint"], args)
+    );
+  }
+
   createWorkspace(...args) {
     return this.request(
       "createWorkspace",
@@ -1375,6 +1565,13 @@ class RealtimeXClient {
     );
   }
 
+  deleteLocalApp(...args) {
+    return this.request(
+      "deleteLocalApp",
+      normalizeOperationOptions(operations["deleteLocalApp"], args)
+    );
+  }
+
   deleteThread(...args) {
     return this.request(
       "deleteThread",
@@ -1382,6 +1579,13 @@ class RealtimeXClient {
     );
   }
 
+  deleteWebhookEndpoint(...args) {
+    return this.request(
+      "deleteWebhookEndpoint",
+      normalizeOperationOptions(operations["deleteWebhookEndpoint"], args)
+    );
+  }
+
   deleteWorkspace(...args) {
     return this.request(
       "deleteWorkspace",
@@ -1424,6 +1628,27 @@ class RealtimeXClient {
     );
   }
 
+  getLocalApp(...args) {
+    return this.request(
+      "getLocalApp",
+      normalizeOperationOptions(operations["getLocalApp"], args)
+    );
+  }
+
+  getLocalAppLogs(...args) {
+    return this.request(
+      "getLocalAppLogs",
+      normalizeOperationOptions(operations["getLocalAppLogs"], args)
+    );
+  }
+
+  getLocalAppStatus(...args) {
+    return this.request(
+      "getLocalAppStatus",
+      normalizeOperationOptions(operations["getLocalAppStatus"], args)
+    );
+  }
+
   getPlugin(...args) {
     return this.request(
       "getPlugin",
@@ -1445,6 +1670,13 @@ class RealtimeXClient {
     );
   }
 
+  getWebhookEndpoint(...args) {
+    return this.request(
+      "getWebhookEndpoint",
+      normalizeOperationOptions(operations["getWebhookEndpoint"], args)
+    );
+  }
+
   getWorkspace(...args) {
     return this.request(
       "getWorkspace",
@@ -1508,6 +1740,13 @@ class RealtimeXClient {
     );
   }
 
+  listLocalApps(...args) {
+    return this.request(
+      "listLocalApps",
+      normalizeOperationOptions(operations["listLocalApps"], args)
+    );
+  }
+
   listPlugins(...args) {
     return this.request(
       "listPlugins",
@@ -1536,6 +1775,20 @@ class RealtimeXClient {
     );
   }
 
+  listWebhookDeliveries(...args) {
+    return this.request(
+      "listWebhookDeliveries",
+      normalizeOperationOptions(operations["listWebhookDeliveries"], args)
+    );
+  }
+
+  listWebhookEndpoints(...args) {
+    return this.request(
+      "listWebhookEndpoints",
+      normalizeOperationOptions(operations["listWebhookEndpoints"], args)
+    );
+  }
+
   listWorkspaceAgentSkills(...args) {
     return this.request(
       "listWorkspaceAgentSkills",
@@ -1620,6 +1873,13 @@ class RealtimeXClient {
     );
   }
 
+  restartLocalApp(...args) {
+    return this.request(
+      "restartLocalApp",
+      normalizeOperationOptions(operations["restartLocalApp"], args)
+    );
+  }
+
   resumeArtifact(...args) {
     return this.request(
       "resumeArtifact",
@@ -1732,6 +1992,13 @@ class RealtimeXClient {
     );
   }
 
+  setLocalAppEnabled(...args) {
+    return this.request(
+      "setLocalAppEnabled",
+      normalizeOperationOptions(operations["setLocalAppEnabled"], args)
+    );
+  }
+
   setupHeartbeatTasks(...args) {
     return this.request(
       "setupHeartbeatTasks",
@@ -1774,6 +2041,13 @@ class RealtimeXClient {
     );
   }
 
+  startLocalApp(...args) {
+    return this.request(
+      "startLocalApp",
+      normalizeOperationOptions(operations["startLocalApp"], args)
+    );
+  }
+
   stopBrowserSession(...args) {
     return this.request(
       "stopBrowserSession",
@@ -1788,6 +2062,13 @@ class RealtimeXClient {
     );
   }
 
+  stopLocalApp(...args) {
+    return this.request(
+      "stopLocalApp",
+      normalizeOperationOptions(operations["stopLocalApp"], args)
+    );
+  }
+
   stopThreadTerminalSession(...args) {
     return this.request(
       "stopThreadTerminalSession",
@@ -1802,6 +2083,13 @@ class RealtimeXClient {
     );
   }
 
+  testWebhookEndpoint(...args) {
+    return this.request(
+      "testWebhookEndpoint",
+      normalizeOperationOptions(operations["testWebhookEndpoint"], args)
+    );
+  }
+
   triggerWorkspaceHeartbeat(...args) {
     return this.request(
       "triggerWorkspaceHeartbeat",
@@ -1823,6 +2111,20 @@ class RealtimeXClient {
     );
   }
 
+  updateLocalApp(...args) {
+    return this.request(
+      "updateLocalApp",
+      normalizeOperationOptions(operations["updateLocalApp"], args)
+    );
+  }
+
+  updateWebhookEndpoint(...args) {
+    return this.request(
+      "updateWebhookEndpoint",
+      normalizeOperationOptions(operations["updateWebhookEndpoint"], args)
+    );
+  }
+
   workspaceShellLayout(...args) {
     return this.request(
       "workspaceShellLayout",
@@ -1848,5 +2150,5 @@ module.exports = {
   createRealtimeXClient,
   createRealtimeXWebhookClient,
   operations,
-  version: "2.0.31",
+  version: "2.0.33",
 };

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@realtimex/sdk",
-    "version": "2.0.31",
+    "version": "2.0.33",
     "description": "RealtimeX runtime SDK package and moderator agent skill assets.",
     "private": false,
     "main": "./index.js",

package/skills/realtimex-moderator-sdk/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: realtimex-moderator-sdk
-description: "Use the RealTimeX API through the generated CLI for workspace, thread, terminal-agent sessions, channel (Telegram, Zalo, Discord), skills, plugins and send messages, setup personality, heartbeat tasks operations, publish and manage artifacts, run tour guide to setup working dir."
+description: "Use the RealTimeX API through the generated CLI for workspace, thread, terminal-agent sessions, channel (Telegram, Zalo, Discord), skills, plugins, webhook endpoint management and delivery inspection, send messages, setup personality, heartbeat tasks operations, publish and manage artifacts, run tour guide to setup working dir."
 author: ""
 license: "Apache-2.0"
 argument-hint: "<command> [args] | install cli"
@@ -20,15 +20,15 @@ This skill drives the `realtimex-pp-cli` binary. Verify the CLI is installed and
 
 1. Install or reinstall the pinned version via npm:
    ```bash
-   npm install -g @realtimex/pp-cli@2.0.31
+   npm install -g @realtimex/pp-cli@2.0.33
    ```
 2. Verify the exact version:
    ```bash
    realtimex-pp-cli --version
    ```
-   The output must be `realtimex-pp-cli 2.0.31`.
+   The output must be `realtimex-pp-cli 2.0.33`.
 
-If `--version` reports "command not found" after install, the npm global bin directory is not on `$PATH`. If it reports any version other than `2.0.31`, reinstall with the pinned npm command above. Do not proceed with skill commands until exact-version verification succeeds.
+If `--version` reports "command not found" after install, the npm global bin directory is not on `$PATH`. If it reports any version other than `2.0.33`, reinstall with the pinned npm command above. Do not proceed with skill commands until exact-version verification succeeds.
 
 * Always run first:
 
@@ -62,10 +62,18 @@ If `--version` reports "command not found" after install, the npm global bin dir
 
 - `realtimex-pp-cli create-channel <workspaceSlug>` — Create a chat channel in one exact workspace. Defaults to Telegram when plugin_type, channelType, and type are omitted.
 
+**create-local-app** — Manage create local app
+
+- `realtimex-pp-cli create-local-app` — Create local app
+
 **create-thread** — Manage create thread
 
 - `realtimex-pp-cli create-thread <workspaceSlug>` — Create a thread in one workspace. The name is optional but recommended.
 
+**create-webhook-endpoint** — Manage create webhook endpoint
+
+- `realtimex-pp-cli create-webhook-endpoint` — Create a webhook endpoint in an accessible workspace. secret is a write-only input.
+
 **create-workspace** — Manage create workspace
 
 - `realtimex-pp-cli create-workspace` — Create a workspace. Requires a human-readable workspace name.
@@ -82,10 +90,18 @@ If `--version` reports "command not found" after install, the npm global bin dir
 
 - `realtimex-pp-cli delete-channel <channelId>` — Delete one chat channel by exact channel id.
 
+**delete-local-app** — Manage delete local app
+
+- `realtimex-pp-cli delete-local-app <appId>` — Delete local app
+
 **delete-thread** — Manage delete thread
 
 - `realtimex-pp-cli delete-thread <workspaceSlug> <threadSlug>` — Delete one thread by exact workspace slug and exact thread slug.
 
+**delete-webhook-endpoint** — Manage delete webhook endpoint
+
+- `realtimex-pp-cli delete-webhook-endpoint <endpointId>` — Permanently delete a visible webhook endpoint. confirmDestructive must be true.
+
 **delete-workspace** — Manage delete workspace
 
 - `realtimex-pp-cli delete-workspace <workspaceSlug>` — Delete one workspace by exact workspace slug.
@@ -110,6 +126,18 @@ If `--version` reports "command not found" after install, the npm global bin dir
 
 - `realtimex-pp-cli get-artifact <artifactId>` — Get one public artifact by artifact id.
 
+**get-local-app** — Manage get local app
+
+- `realtimex-pp-cli get-local-app <appId>` — Get local app
+
+**get-local-app-logs** — Manage get local app logs
+
+- `realtimex-pp-cli get-local-app-logs <appId>` — Read bounded recent desktop logs. Each entry is capped at 4 KiB and secret-bearing configuration is omitted.
+
+**get-local-app-status** — Manage get local app status
+
+- `realtimex-pp-cli get-local-app-status <appId>` — Get local app status
+
 **get-plugin** — Manage get plugin
 
 - `realtimex-pp-cli get-plugin <pluginId>` — Get one installed plugin with its config schema (keys, labels, types, defaults)
@@ -122,6 +150,10 @@ If `--version` reports "command not found" after install, the npm global bin dir
 
 - `realtimex-pp-cli get-thread <workspaceSlug> <threadSlug>` — Get one thread by exact workspace slug and exact thread slug.
 
+**get-webhook-endpoint** — Manage get webhook endpoint
+
+- `realtimex-pp-cli get-webhook-endpoint <endpointId>` — Get one visible webhook endpoint by endpoint id. The response reports secretConfigured but never returns the secret.
+
 **get-workspace** — Manage get workspace
 
 - `realtimex-pp-cli get-workspace <workspaceSlug>` — Get one workspace by exact workspace slug.
@@ -158,6 +190,10 @@ If `--version` reports "command not found" after install, the npm global bin dir
 
 - `realtimex-pp-cli list-llm-providers` — List supported LLM providers. Use provider ids from this response when configuring workspace or thread LLM settings.
 
+**list-local-apps** — Manage list local apps
+
+- `realtimex-pp-cli list-local-apps` — List local apps
+
 **list-plugins** — Manage list plugins
 
 - `realtimex-pp-cli list-plugins` — List installed plugins with enabled state and runtime load status.
@@ -174,6 +210,14 @@ If `--version` reports "command not found" after install, the npm global bin dir
 
 - `realtimex-pp-cli list-threads <workspaceSlug>` — List threads for one exact workspace slug.
 
+**list-webhook-deliveries** — Manage list webhook deliveries
+
+- `realtimex-pp-cli list-webhook-deliveries` — List bounded delivery metadata for visible webhook endpoints.
+
+**list-webhook-endpoints** — Manage list webhook endpoints
+
+- `realtimex-pp-cli list-webhook-endpoints` — List webhook endpoints visible to the authenticated user. Secrets are never returned.
+
 **list-workspace-agent-skills** — Manage list workspace agent skills
 
 - `realtimex-pp-cli list-workspace-agent-skills <workspaceSlug>` — List published agent skills with enabled/disabled state for one exact workspace slug.
@@ -222,6 +266,10 @@ If `--version` reports "command not found" after install, the npm global bin dir
 
 - `realtimex-pp-cli respond-terminal-idle-prompt <sessionId>` — Send one constrained response action to an exact idle terminal session only when its PTY event sequence is unchanged.
 
+**restart-local-app** — Manage restart local app
+
+- `realtimex-pp-cli restart-local-app <appId>` — Restart local app
+
 **resume-artifact** — Manage resume artifact
 
 - `realtimex-pp-cli resume-artifact <artifactId>` — Resume one paused artifact by artifact id.
@@ -282,6 +330,10 @@ If `--version` reports "command not found" after install, the npm global bin dir
 
 - `realtimex-pp-cli set-heartbeat-timezone` — Set workspace or global ambient-agent heartbeat timezone, for example Asia/Saigon or UTC.
 
+**set-local-app-enabled** — Manage set local app enabled
+
+- `realtimex-pp-cli set-local-app-enabled <appId>` — Set local app enabled
+
 **set-workspace-default-agent** — Manage set workspace default agent
 
 - `realtimex-pp-cli set-workspace-default-agent <workspaceSlug>` — Set the default CLI agent for a workspace.
@@ -306,6 +358,10 @@ If `--version` reports "command not found" after install, the npm global bin dir
 
 - `realtimex-pp-cli start-channel <channelId>` — Start one chat channel by exact channel id.
 
+**start-local-app** — Manage start local app
+
+- `realtimex-pp-cli start-local-app <appId>` — Start local app
+
 **stop-browser-session** — Manage stop browser session
 
 - `realtimex-pp-cli stop-browser-session <sessionName>` — Gracefully stop an existing named RealTimeX Browser session.
@@ -314,6 +370,10 @@ If `--version` reports "command not found" after install, the npm global bin dir
 
 - `realtimex-pp-cli stop-channel <channelId>` — Stop one chat channel by exact channel id.
 
+**stop-local-app** — Manage stop local app
+
+- `realtimex-pp-cli stop-local-app <appId>` — Stop local app
+
 **stop-thread-terminal-session** — Manage stop thread terminal session
 
 - `realtimex-pp-cli stop-thread-terminal-session` — Interrupt the selected or current chat-linked terminal session for one exact thread without closing the underlying
@@ -322,6 +382,10 @@ If `--version` reports "command not found" after install, the npm global bin dir
 
 - `realtimex-pp-cli terminate-terminal-session <sessionId>` — Terminate a terminal runtime session by detaching any controller and closing the underlying PTY session.
 
+**test-webhook-endpoint** — Manage test webhook endpoint
+
+- `realtimex-pp-cli test-webhook-endpoint <endpointId>` — Submit an optional JSON payload as a signed test delivery through a visible webhook endpoint.
+
 **trigger-workspace-heartbeat** — Manage trigger workspace heartbeat
 
 - `realtimex-pp-cli trigger-workspace-heartbeat <workspaceSlug>` — Trigger the default HEARTBEAT.md task for a workspace immediately.
@@ -334,6 +398,14 @@ If `--version` reports "command not found" after install, the npm global bin dir
 
 - `realtimex-pp-cli update-channel <channelId>` — Update one chat channel by exact channel id. Only channel writable fields are changed.
 
+**update-local-app** — Manage update local app
+
+- `realtimex-pp-cli update-local-app <appId>` — Update local app
+
+**update-webhook-endpoint** — Manage update webhook endpoint
+
+- `realtimex-pp-cli update-webhook-endpoint <endpointId>` — Update a visible webhook endpoint. Passing secret rotates it; the value is never returned.
+
 **workspace-shell-layout** — Manage workspace shell layout
 
 - `realtimex-pp-cli workspace-shell-layout` — Verify workspace navigation, title-bar containment, Files dock behavior
@@ -464,9 +536,9 @@ Verify: `claude mcp list`
    ```bash
    realtimex-pp-cli --version
    ```
-   If the command is missing or the output is not exactly `realtimex-pp-cli 2.0.31`, reinstall the pinned version:
+   If the command is missing or the output is not exactly `realtimex-pp-cli 2.0.33`, reinstall the pinned version:
    ```bash
-   npm install -g @realtimex/pp-cli@2.0.31
+   npm install -g @realtimex/pp-cli@2.0.33
    ```
    Then run `realtimex-pp-cli --version` again and proceed only after exact-version verification succeeds.
 2. Match the user query to the best command from the Unique Capabilities and Command Reference above.
@@ -529,6 +601,13 @@ For `send-channel-file`:
 * In desktop/local runtime, the CLI should send the absolute local `filePath` to the server. The server validates the path against allowed storage/temp roots before sending through the channel. Base64 upload is fallback transport, not the preferred path.
 * The server validates the delivery context, active channel session, plugin state, runtime binding when supplied, and file size/type handling before delivery.
 
+For webhook endpoint management:
+
+* These operations require an authenticated, user-bound session credential.
+* Treat `secret` as write-only input for creation or rotation. Never expect, request, print, or persist a plaintext secret from endpoint responses.
+* Use `list-webhook-deliveries` for bounded metadata inspection. Raw request headers, signatures, bodies, and normalized payload fields are intentionally unavailable.
+* Pass `confirmDestructive=true` only after the user has explicitly requested permanent endpoint deletion.
+
 For workspace default-agent setup:
 
 * Use `prepare.agents` only.