@pixelbyte-software/pixcode 1.42.4 → 1.43.0

package/server/modules/orchestration/workflows/workflow.routes.ts

@@ -6,9 +6,19 @@ import {
   type WorkflowReplayScope,
   buildWorkflowReplayPlan,
 } from '@/modules/orchestration/workflows/workflow-replay.js';
+import {
+  applyWorkflowTemplateToMetadata,
+  builtInWorkflowTemplates,
+  getWorkflowTemplate,
+} from '@/modules/orchestration/workflows/workflow-templates.js';
 import { workflowStore } from '@/modules/orchestration/workflows/workflow-store.js';
 import { buildWorkflowTrace } from '@/modules/orchestration/workflows/workflow-trace.js';
 import { findPixcodeAppRoot } from '@/modules/orchestration/workflows/workspace-target.js';
+import {
+  listPendingApprovals,
+  resolvePermissionApproval,
+  type ApprovalDecisionSource,
+} from '@/modules/orchestration/workflows/approval-queue.js';
 import {
   DEFAULT_PERMISSION_POLICY,
   PERMISSION_CAPABILITIES,
@@ -17,6 +27,7 @@ import {
   evaluatePermissionRequest,
   normalizePermissionPolicy,
 } from '@/modules/orchestration/security/permission-policy.js';
+import { dispatchWebhookEvent } from '@/services/webhooks.js';
 
 const TERMINAL_RUN_STATES = new Set(['completed', 'failed', 'canceled']);
 
@@ -130,6 +141,12 @@ export function createWorkflowRouter(): Router {
     res.json({ workflows: workflowStore.listWorkflows() });
   });
 
+  router.get('/workflows/templates', (_req, res) => {
+    res.json({
+      templates: builtInWorkflowTemplates,
+    });
+  });
+
   router.get('/workflows/context', (_req, res) => {
     res.json({
       appRoot: findPixcodeAppRoot(),
@@ -243,6 +260,55 @@ export function createWorkflowRouter(): Router {
     });
   });
 
+  router.get('/workflows/approvals', (req, res) => {
+    res.json({
+      pendingApprovals: listPendingApprovals({
+        projectId: readOptionalString(req.query.projectId),
+        includeResolved: readBooleanFlag(req.query.includeResolved),
+      }),
+    });
+  });
+
+  router.post('/workflows/approvals/:approvalId', (req, res) => {
+    const allow = req.body?.allow === true;
+    const deny = req.body?.allow === false;
+    if (!allow && !deny) {
+      res.status(400).json({
+        error: {
+          code: 'PERMISSION_DECISION_REQUIRED',
+          message: 'Approval queue decisions require allow=true or allow=false.',
+        },
+      });
+      return;
+    }
+
+    const source = ['ui', 'telegram', 'api'].includes(req.body?.source)
+      ? req.body.source as ApprovalDecisionSource
+      : 'api';
+    const result = resolvePermissionApproval({
+      approvalId: req.params.approvalId,
+      allow,
+      source,
+      resolvedBy: readRequestUserId(req),
+      message: readOptionalString(req.body?.message),
+    });
+    if (!result) {
+      res.status(404).json({ error: { code: 'APPROVAL_NOT_FOUND', message: req.params.approvalId } });
+      return;
+    }
+
+    dispatchWebhookEvent({
+      type: 'approval.resolved',
+      payload: {
+        approvalId: req.params.approvalId,
+        allow,
+        source,
+        runId: result.runId,
+      },
+    });
+    res.json(result);
+  });
+
   router.post('/workflows/runs/:runId/permission-approvals/:requestId', (req, res) => {
     const run = workflowStore.getRun(req.params.runId);
     if (!run) {
@@ -274,6 +340,15 @@ export function createWorkflowRouter(): Router {
     }
 
     workflowStore.setRun(run);
+    dispatchWebhookEvent({
+      type: 'approval.resolved',
+      payload: {
+        approvalId: req.params.requestId,
+        allow,
+        source: 'ui',
+        runId: run.id,
+      },
+    });
     res.json({
       runId: run.id,
       pendingApprovals: readRunArray(run, 'pendingPermissionApprovals')
@@ -348,6 +423,14 @@ export function createWorkflowRouter(): Router {
           },
         },
       );
+      dispatchWebhookEvent({
+        type: 'run.started',
+        payload: {
+          runId: replayRun.id,
+          workflowId: replayRun.workflowId,
+          replayOf: run.id,
+        },
+      });
       res.status(202).json({
         run: replayRun,
         replayPlan,
@@ -413,6 +496,13 @@ export function createWorkflowRouter(): Router {
       res.status(404).json({ error: { code: 'RUN_NOT_FOUND', message: req.params.runId } });
       return;
     }
+    dispatchWebhookEvent({
+      type: 'run.canceled',
+      payload: {
+        runId: run.id,
+        workflowId: run.workflowId,
+      },
+    });
     res.json(run);
   });
 
@@ -432,6 +522,14 @@ export function createWorkflowRouter(): Router {
           workflowName: workflow.name,
         },
       );
+      dispatchWebhookEvent({
+        type: 'run.started',
+        payload: {
+          runId: run.id,
+          workflowId: run.workflowId,
+          workflowName: workflow.name,
+        },
+      });
       res.status(202).json(run);
     } catch (error) {
       res.status(400).json({
@@ -443,5 +541,46 @@ export function createWorkflowRouter(): Router {
     }
   });
 
+  router.post('/workflows/templates/:templateId/runs', (req, res) => {
+    const template = getWorkflowTemplate(req.params.templateId);
+    if (!template) {
+      res.status(404).json({ error: { code: 'WORKFLOW_TEMPLATE_NOT_FOUND', message: req.params.templateId } });
+      return;
+    }
+    const workflow = workflowStore.getWorkflow(template.workflowId);
+    if (!workflow) {
+      res.status(404).json({ error: { code: 'WORKFLOW_NOT_FOUND', message: template.workflowId } });
+      return;
+    }
+
+    try {
+      const run = workflowRunner.start(
+        workflow,
+        typeof req.body?.input === 'string' ? req.body.input : '',
+        {
+          ...applyWorkflowTemplateToMetadata(template, readMetadata(req.body)),
+          userId: readRequestUserId(req),
+          workflowName: workflow.name,
+        },
+      );
+      dispatchWebhookEvent({
+        type: 'run.started',
+        payload: {
+          runId: run.id,
+          workflowId: run.workflowId,
+          templateId: template.id,
+        },
+      });
+      res.status(202).json(run);
+    } catch (error) {
+      res.status(400).json({
+        error: {
+          code: 'WORKFLOW_TEMPLATE_START_FAILED',
+          message: error instanceof Error ? error.message : String(error),
+        },
+      });
+    }
+  });
+
   return router;
 }

package/server/routes/public-api.js

@@ -1,6 +1,11 @@
 import express from 'express';
 
-import { buildOpenApiFragment, buildPublicApiManifest } from '../services/public-api-manifest.js';
+import {
+  buildCurlCookbook,
+  buildOpenApiFragment,
+  buildPublicApiManifest,
+  buildTypeScriptSdkStarter,
+} from '../services/public-api-manifest.js';
 
 const router = express.Router();
 
@@ -18,4 +23,12 @@ router.get('/openapi', (req, res) => {
   res.json(buildOpenApiFragment({ baseUrl: requestBaseUrl(req) }));
 });
 
+router.get('/sdk/typescript', (req, res) => {
+  res.type('text/typescript').send(buildTypeScriptSdkStarter({ baseUrl: requestBaseUrl(req) }));
+});
+
+router.get('/cookbook', (req, res) => {
+  res.json(buildCurlCookbook({ baseUrl: requestBaseUrl(req) }));
+});
+
 export default router;

package/server/routes/remote.js

@@ -5,6 +5,10 @@ import {
   getPublicRemoteConnectionConfig,
   saveRemoteConnectionConfig,
 } from '../services/remote-connection.js';
+import {
+  buildControlRoomSnapshot,
+  buildMobileConsoleLayout,
+} from '../services/control-room.js';
 
 const router = express.Router();
 
@@ -30,4 +34,22 @@ router.post('/check', async (req, res) => {
   }
 });
 
+router.get('/control-room', async (_req, res) => {
+  try {
+    res.json({
+      success: true,
+      controlRoom: await buildControlRoomSnapshot(),
+    });
+  } catch (error) {
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+router.get('/console-layout', (_req, res) => {
+  res.json({
+    success: true,
+    layout: buildMobileConsoleLayout(),
+  });
+});
+
 export default router;

package/server/routes/webhooks.js

@@ -0,0 +1,63 @@
+import express from 'express';
+
+import {
+  PIXCODE_WEBHOOK_EVENT_TYPES,
+  deleteWebhook,
+  deliverWebhookEvent,
+  listWebhooks,
+  upsertWebhook,
+} from '../services/webhooks.js';
+
+const router = express.Router();
+
+router.get('/', (_req, res) => {
+  res.json({
+    success: true,
+    eventTypes: PIXCODE_WEBHOOK_EVENT_TYPES,
+    webhooks: listWebhooks(),
+  });
+});
+
+router.post('/', (req, res) => {
+  try {
+    const webhook = upsertWebhook(req.body || {});
+    res.status(201).json({ success: true, webhook });
+  } catch (error) {
+    res.status(400).json({ success: false, error: error.message });
+  }
+});
+
+router.patch('/:id', (req, res) => {
+  try {
+    const webhook = upsertWebhook({ ...(req.body || {}), id: req.params.id });
+    res.json({ success: true, webhook });
+  } catch (error) {
+    res.status(400).json({ success: false, error: error.message });
+  }
+});
+
+router.delete('/:id', (req, res) => {
+  if (!deleteWebhook(req.params.id)) {
+    res.status(404).json({ success: false, error: 'Webhook not found.' });
+    return;
+  }
+  res.json({ success: true });
+});
+
+router.post('/test', async (req, res) => {
+  try {
+    const result = await deliverWebhookEvent({
+      type: req.body?.type || 'run.completed',
+      payload: {
+        test: true,
+        message: 'Pixcode webhook test delivery',
+        sentBy: req.user?.id ?? null,
+      },
+    });
+    res.json({ success: true, result });
+  } catch (error) {
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+export default router;

package/server/services/control-room.js

@@ -0,0 +1,102 @@
+import { listPendingApprovals, workflowStore } from '../modules/orchestration/index.js';
+import { getProjects } from '../projects.js';
+
+import { listWebhooks } from './webhooks.js';
+
+const TERMINAL_RUN_STATES = new Set(['completed', 'failed', 'canceled']);
+
+function projectPath(project) {
+  return project.fullPath || project.path || '';
+}
+
+function runBelongsToProject(run, project) {
+  const projectId = run.metadata?.projectId;
+  const path = run.metadata?.projectPath;
+  return projectId === project.name || path === projectPath(project);
+}
+
+function countSessions(project) {
+  return [
+    project.sessions,
+    project.codexSessions,
+    project.cursorSessions,
+    project.geminiSessions,
+    project.qwenSessions,
+    project.opencodeSessions,
+  ].reduce((total, sessions) => total + (Array.isArray(sessions) ? sessions.length : 0), 0);
+}
+
+function summarizeProject(project, runs, approvals) {
+  const projectRuns = runs.filter((run) => runBelongsToProject(run, project));
+  const runningRuns = projectRuns.filter((run) => !TERMINAL_RUN_STATES.has(run.status));
+  const failedRuns = projectRuns.filter((run) => run.status === 'failed');
+  const projectApprovals = approvals.filter((approval) => (
+    approval.runId && projectRuns.some((run) => run.id === approval.runId)
+  ));
+
+  return {
+    id: project.name,
+    name: project.displayName || project.name,
+    path: projectPath(project),
+    sessionCount: countSessions(project),
+    activeRunCount: runningRuns.length,
+    failedRunCount: failedRuns.length,
+    pendingApprovalCount: projectApprovals.length,
+    latestRuns: projectRuns.slice(0, 4).map((run) => ({
+      id: run.id,
+      workflowId: run.workflowId,
+      status: run.status,
+      startedAt: run.startedAt,
+      finishedAt: run.finishedAt,
+    })),
+  };
+}
+
+export async function buildControlRoomSnapshot({ maxProjects = 4 } = {}) {
+  const projects = await getProjects();
+  const runs = workflowStore.listRuns();
+  const pendingApprovals = listPendingApprovals();
+  const webhooks = listWebhooks();
+  const projectCards = projects
+    .map((project) => summarizeProject(project, runs, pendingApprovals))
+    .sort((a, b) => (
+      b.pendingApprovalCount - a.pendingApprovalCount ||
+      b.activeRunCount - a.activeRunCount ||
+      b.failedRunCount - a.failedRunCount ||
+      a.name.localeCompare(b.name)
+    ))
+    .slice(0, maxProjects);
+
+  return {
+    protocol: 'pixcode.control-room.v1',
+    generatedAt: new Date().toISOString(),
+    maxProjects,
+    mobileFirst: true,
+    totals: {
+      projects: projects.length,
+      activeRuns: runs.filter((run) => !TERMINAL_RUN_STATES.has(run.status)).length,
+      failedRuns: runs.filter((run) => run.status === 'failed').length,
+      pendingApprovals: pendingApprovals.length,
+      webhooks: webhooks.length,
+      enabledWebhooks: webhooks.filter((webhook) => webhook.enabled).length,
+    },
+    projects: projectCards,
+    approvals: pendingApprovals.slice(0, 20),
+    webhooks,
+  };
+}
+
+export function buildMobileConsoleLayout() {
+  return {
+    protocol: 'pixcode.remote-console-layout.v1',
+    mobileFirst: true,
+    sections: [
+      { id: 'projects', title: 'Projects', priority: 1 },
+      { id: 'approvals', title: 'Approval queue', priority: 2 },
+      { id: 'runs', title: 'Runs', priority: 3 },
+      { id: 'webhooks', title: 'Webhooks', priority: 4 },
+      { id: 'api', title: 'API SDK', priority: 5 },
+    ],
+    maxVisibleProjects: 4,
+  };
+}

package/server/services/public-api-manifest.js

@@ -13,6 +13,7 @@ const API_GROUPS = [
   { id: 'diagnostics', title: 'Diagnostics', basePath: '/api/diagnostics', scopes: ['diagnostics:read'] },
   { id: 'remote', title: 'Remote connection', basePath: '/api/remote', scopes: ['remote:read', 'remote:write'] },
   { id: 'telegram', title: 'Telegram control', basePath: '/api/telegram', scopes: ['telegram:read', 'telegram:write'] },
+  { id: 'webhooks', title: 'Outbound webhooks', basePath: '/api/webhooks', scopes: ['webhooks:read', 'webhooks:write'] },
   { id: 'plugins', title: 'Plugins and MCP tools', basePath: '/api/plugins', scopes: ['plugins:read', 'plugins:write'] },
 ];
 
@@ -48,6 +49,103 @@ export function buildPublicApiManifest({ baseUrl = '' } = {}) {
         title: 'Fetch diagnostics bundle',
         curl: `curl -H "X-API-Key: px_your_key" ${origin || 'http://127.0.0.1:3001'}/api/diagnostics/bundle`,
       },
+      {
+        title: 'Read the mobile remote control room',
+        curl: `curl -H "X-API-Key: px_your_key" ${origin || 'http://127.0.0.1:3001'}/api/remote/control-room`,
+      },
+      {
+        title: 'Register an outbound webhook',
+        curl: `curl -X POST -H "Content-Type: application/json" -H "X-API-Key: px_your_key" -d '{"name":"CI listener","url":"https://example.com/pixcode","events":["run.completed","approval.needed"]}' ${origin || 'http://127.0.0.1:3001'}/api/webhooks`,
+      },
+    ],
+  };
+}
+
+export function buildTypeScriptSdkStarter({ baseUrl = '' } = {}) {
+  const origin = String(baseUrl || 'http://127.0.0.1:3001').replace(/\/+$/, '');
+  return `export type PixcodeRun = {
+  id: string;
+  workflowId: string;
+  status: 'queued' | 'running' | 'completed' | 'failed' | 'canceled';
+};
+
+export class PixcodeClient {
+  constructor(
+    private readonly apiKey: string,
+    private readonly baseUrl = '${origin}',
+  ) {}
+
+  private async request<T>(path: string, init: RequestInit = {}): Promise<T> {
+    const response = await fetch(new URL(path, this.baseUrl), {
+      ...init,
+      headers: {
+        'Content-Type': 'application/json',
+        'X-API-Key': this.apiKey,
+        ...(init.headers || {}),
+      },
+    });
+    if (!response.ok) throw new Error(\`Pixcode API \${response.status}: \${await response.text()}\`);
+    return response.json() as Promise<T>;
+  }
+
+  projects() {
+    return this.request<{ projects: unknown[] }>('/api/projects');
+  }
+
+  controlRoom() {
+    return this.request<{ success: true; controlRoom: unknown }>('/api/remote/control-room');
+  }
+
+  approvals() {
+    return this.request<{ pendingApprovals: unknown[] }>('/api/orchestration/workflows/approvals');
+  }
+
+  decideApproval(approvalId: string, allow: boolean) {
+    return this.request(\`/api/orchestration/workflows/approvals/\${encodeURIComponent(approvalId)}\`, {
+      method: 'POST',
+      body: JSON.stringify({ allow, source: 'api' }),
+    });
+  }
+
+  startWorkflow(workflowId: string, input: string, metadata: Record<string, unknown> = {}) {
+    return this.request<PixcodeRun>(\`/api/orchestration/workflows/\${encodeURIComponent(workflowId)}/runs\`, {
+      method: 'POST',
+      body: JSON.stringify({ input, metadata }),
+    });
+  }
+}
+`;
+}
+
+export function buildCurlCookbook({ baseUrl = '' } = {}) {
+  const origin = String(baseUrl || 'http://127.0.0.1:3001').replace(/\/+$/, '');
+  return {
+    title: 'Pixcode Public API Cookbook',
+    variables: {
+      PIXCODE_URL: origin,
+      PIXCODE_API_KEY: 'px_your_key',
+    },
+    examples: [
+      {
+        title: 'List projects',
+        command: `curl -H "X-API-Key: $PIXCODE_API_KEY" "$PIXCODE_URL/api/projects"`,
+      },
+      {
+        title: 'Read the mobile control room',
+        command: `curl -H "X-API-Key: $PIXCODE_API_KEY" "$PIXCODE_URL/api/remote/control-room"`,
+      },
+      {
+        title: 'List pending approvals',
+        command: `curl -H "X-API-Key: $PIXCODE_API_KEY" "$PIXCODE_URL/api/orchestration/workflows/approvals"`,
+      },
+      {
+        title: 'Approve a pending action',
+        command: `curl -X POST -H "Content-Type: application/json" -H "X-API-Key: $PIXCODE_API_KEY" -d '{"allow":true,"source":"api"}' "$PIXCODE_URL/api/orchestration/workflows/approvals/approval_id"`,
+      },
+      {
+        title: 'Create a webhook',
+        command: `curl -X POST -H "Content-Type: application/json" -H "X-API-Key: $PIXCODE_API_KEY" -d '{"name":"CI listener","url":"https://example.com/pixcode","events":["run.completed","run.failed","approval.needed"]}' "$PIXCODE_URL/api/webhooks"`,
+      },
     ],
   };
 }

package/server/services/telegram/control-center.js

@@ -37,6 +37,10 @@ const CONTROL_COMMANDS = new Set([
   '/workflows',
   '/orchestration',
   '/runs',
+  '/approvals',
+  '/controlroom',
+  '/control-room',
+  '/webhooks',
   '/sessions',
   '/newchat',
   '/tasks',
@@ -203,6 +207,8 @@ function mainMenuKeyboard(lang) {
     [button(t(lang, 'control.button.projects'), 'projects'), button(t(lang, 'control.button.provider'), 'providers')],
     [button(t(lang, 'control.button.models'), 'models'), button(t(lang, 'control.button.workflows'), 'workflows')],
     [button(t(lang, 'control.button.tasks'), 'tasks'), button(t(lang, 'control.button.runs'), 'runs')],
+    [button(t(lang, 'control.button.approvals'), 'approvals'), button(t(lang, 'control.button.controlRoom'), 'control_room')],
+    [button(t(lang, 'control.button.webhooks'), 'webhooks')],
     [button(t(lang, 'control.button.sessions'), 'sessions'), button(t(lang, 'control.button.newChat'), 'new_chat')],
     [button(t(lang, 'control.button.install'), 'install_menu'), button(t(lang, 'control.button.auth'), 'auth_menu')],
     [button(t(lang, 'control.button.settings'), 'settings')],
@@ -338,6 +344,82 @@ async function showRuns({ bot, chatId, link, editMessageId }) {
   });
 }
 
+async function showApprovalQueue({ bot, chatId, link, editMessageId }) {
+  const lang = languageFor(link);
+  const data = await localApi(link.user_id, '/api/orchestration/workflows/approvals');
+  const approvals = Array.isArray(data?.pendingApprovals) ? data.pendingApprovals : [];
+  if (approvals.length === 0) {
+    await send(bot, chatId, t(lang, 'control.noApprovals'), { editMessageId });
+    return;
+  }
+
+  const keyboard = [];
+  const lines = approvals.slice(0, 8).map((approval, index) => {
+    const label = compact(approval.summary || approval.reason || approval.id, 70);
+    keyboard.push([
+      button(t(lang, 'control.button.approve'), 'approval_decide', { approvalId: approval.id, allow: true }),
+      button(t(lang, 'control.button.deny'), 'approval_decide', { approvalId: approval.id, allow: false }),
+    ]);
+    return `${index + 1}. ${label}\nRun: ${approval.runId}`;
+  });
+  keyboard.push([button(t(lang, 'control.button.refresh'), 'approvals'), button(t(lang, 'control.button.mainMenu'), 'menu')]);
+  await send(bot, chatId, `${t(lang, 'control.approvalQueue')}\n\n${lines.join('\n\n')}`, {
+    editMessageId,
+    reply_markup: { inline_keyboard: keyboard },
+  });
+}
+
+async function showControlRoom({ bot, chatId, link, editMessageId }) {
+  const lang = languageFor(link);
+  const data = await localApi(link.user_id, '/api/remote/control-room');
+  const snapshot = data?.controlRoom || data;
+  const projects = Array.isArray(snapshot?.projects) ? snapshot.projects : [];
+  const totals = snapshot?.totals || {};
+  const lines = projects.map((project, index) => [
+    `${index + 1}. ${compact(project.name || project.id, 44)}`,
+    `Runs: ${project.activeRunCount || 0} active / ${project.failedRunCount || 0} failed`,
+    `Approvals: ${project.pendingApprovalCount || 0}`,
+  ].join('\n'));
+  await send(bot, chatId, [
+    t(lang, 'control.controlRoomTitle'),
+    '',
+    `Projects: ${totals.projects || 0}`,
+    `Active runs: ${totals.activeRuns || 0}`,
+    `Pending approvals: ${totals.pendingApprovals || 0}`,
+    '',
+    lines.join('\n\n') || t(lang, 'control.noProjects'),
+  ].join('\n'), {
+    editMessageId,
+    reply_markup: {
+      inline_keyboard: [
+        [button(t(lang, 'control.button.approvals'), 'approvals'), button(t(lang, 'control.button.runs'), 'runs')],
+        [button(t(lang, 'control.button.mainMenu'), 'menu')],
+      ],
+    },
+  });
+}
+
+async function showWebhookMenu({ bot, chatId, link, editMessageId }) {
+  const lang = languageFor(link);
+  const data = await localApi(link.user_id, '/api/webhooks');
+  const webhooks = Array.isArray(data?.webhooks) ? data.webhooks : [];
+  const lines = webhooks.slice(0, 10).map((webhook, index) => (
+    `${index + 1}. ${webhook.enabled ? 'on' : 'off'} ${compact(webhook.name || webhook.url, 50)}\n${compact(webhook.events?.join(', ') || webhook.url, 90)}`
+  ));
+  await send(bot, chatId, [
+    t(lang, 'control.webhookTitle'),
+    '',
+    lines.join('\n\n') || t(lang, 'control.noWebhooks'),
+  ].join('\n'), {
+    editMessageId,
+    reply_markup: {
+      inline_keyboard: [
+        [button(t(lang, 'control.button.refresh'), 'webhooks'), button(t(lang, 'control.button.mainMenu'), 'menu')],
+      ],
+    },
+  });
+}
+
 async function showSessions({ bot, chatId, link, editMessageId }) {
   const lang = languageFor(link);
   const state = getState(link.user_id);
@@ -783,6 +865,18 @@ async function handleCommand({ bot, chatId, link, text }) {
     await showRuns({ bot, chatId, link });
     return true;
   }
+  if (command === '/approvals') {
+    await showApprovalQueue({ bot, chatId, link });
+    return true;
+  }
+  if (command === '/controlroom' || command === '/control-room') {
+    await showControlRoom({ bot, chatId, link });
+    return true;
+  }
+  if (command === '/webhooks') {
+    await showWebhookMenu({ bot, chatId, link });
+    return true;
+  }
   if (command === '/sessions') {
     await showSessions({ bot, chatId, link });
     return true;
@@ -927,6 +1021,9 @@ export async function handleTelegramControlCallback({ bot, query, link }) {
   if (action === 'models_refresh') return showModelMenu({ bot, chatId, link, refresh: true, editMessageId });
   if (action === 'workflows') return showWorkflowMenu({ bot, chatId, link, editMessageId });
   if (action === 'runs') return showRuns({ bot, chatId, link, editMessageId });
+  if (action === 'approvals') return showApprovalQueue({ bot, chatId, link, editMessageId });
+  if (action === 'control_room') return showControlRoom({ bot, chatId, link, editMessageId });
+  if (action === 'webhooks') return showWebhookMenu({ bot, chatId, link, editMessageId });
   if (action === 'sessions') return showSessions({ bot, chatId, link, editMessageId });
   if (action === 'new_chat') return startNewChat({ bot, chatId, link, editMessageId });
   if (action === 'tasks') return showTaskMasterTasks({ bot, chatId, link, editMessageId });
@@ -989,6 +1086,22 @@ export async function handleTelegramControlCallback({ bot, query, link }) {
     await send(bot, chatId, t(languageFor(link), 'control.runStatus', { runId: run.id, status: run.status }), { editMessageId });
     return;
   }
+  if (action === 'approval_decide') {
+    const result = await localApi(link.user_id, `/api/orchestration/workflows/approvals/${encodeURIComponent(payload.approvalId)}`, {
+      method: 'POST',
+      body: {
+        allow: payload.allow === true,
+        source: 'telegram',
+      },
+    });
+    const lang = languageFor(link);
+    await send(bot, chatId, t(lang, 'control.approvalDecided', {
+      approvalId: payload.approvalId,
+      status: payload.allow === true ? 'approved' : 'denied',
+      runId: result?.runId || '',
+    }), { editMessageId });
+    return showApprovalQueue({ bot, chatId, link });
+  }
   if (action === 'task_run') return runTaskMasterTask({ bot, chatId, link, taskId: payload.taskId });
   if (action === 'install_provider') return startCliInstall({ bot, chatId, link, provider: payload.provider });
   if (action === 'auth_provider') {