@pixelbyte-software/pixcode 1.36.3 → 1.37.0

package/server/routes/taskmaster.js

@@ -17,6 +17,12 @@ import express from 'express';
 import { orchestrationTaskService } from '@/modules/orchestration/tasks/orchestration-task.service.js';
 
 import { extractProjectDirectory } from '../projects.js';
+import {
+    cancelInstallJob,
+    createInstallJob,
+    getInstallJob,
+    snapshotDonePayload
+} from '../services/install-jobs.js';
 import { broadcastTaskMasterProjectUpdate, broadcastTaskMasterTasksUpdate } from '../utils/taskmaster-websocket.js';
 import { detectTaskMasterMCPServer } from '../utils/mcp-detector.js';
 
@@ -144,6 +150,17 @@ async function readTaskMasterTasks(projectName) {
     return { projectPath, transformedTasks, currentTag };
 }
 
+function taskMasterExecutionDescription(task) {
+    return [
+        task.description ? `Description:\n${task.description}` : '',
+        task.details ? `Details:\n${task.details}` : '',
+        task.testStrategy ? `Test strategy:\n${task.testStrategy}` : '',
+        Array.isArray(task.dependencies) && task.dependencies.length
+            ? `Dependencies: ${task.dependencies.join(', ')}`
+            : '',
+    ].filter(Boolean).join('\n\n');
+}
+
 // API Routes
 
 /**
@@ -181,6 +198,121 @@ router.get('/installation-status', async (req, res) => {
     }
 });
 
+/**
+ * POST /api/taskmaster/install
+ * Install TaskMaster CLI into Pixcode's sandboxed CLI bin.
+ */
+router.post('/install', async (req, res) => {
+    try {
+        const job = createInstallJob({
+            provider: 'taskmaster',
+            installCmd: 'npm install -g task-master',
+            packageName: 'task-master'
+        });
+
+        res.json({
+            success: true,
+            jobId: job.id,
+            provider: 'taskmaster',
+            packageName: 'task-master',
+            startedAt: job.startedAt
+        });
+    } catch (error) {
+        console.error('TaskMaster install start error:', error);
+        res.status(500).json({
+            success: false,
+            error: 'Failed to start TaskMaster install',
+            message: error.message
+        });
+    }
+});
+
+/**
+ * GET /api/taskmaster/install/:jobId/stream
+ * Replay and stream TaskMaster install output.
+ */
+router.get('/install/:jobId/stream', async (req, res) => {
+    const job = getInstallJob(req.params.jobId);
+    if (!job || job.provider !== 'taskmaster') {
+        return res.status(404).json({
+            success: false,
+            error: 'Install job not found or already expired'
+        });
+    }
+
+    res.setHeader('Content-Type', 'text/event-stream');
+    res.setHeader('Cache-Control', 'no-cache, no-transform');
+    res.setHeader('Connection', 'keep-alive');
+    res.setHeader('X-Accel-Buffering', 'no');
+    if (typeof res.flushHeaders === 'function') res.flushHeaders();
+
+    let closed = false;
+    const write = (event, payload) => {
+        if (closed) return;
+        try {
+            res.write(`event: ${event}\n`);
+            res.write(`data: ${JSON.stringify(payload)}\n\n`);
+        } catch {
+            // Socket is gone.
+        }
+    };
+
+    try { res.write(': start\n\n'); } catch { /* noop */ }
+    const heartbeat = setInterval(() => {
+        if (!closed) {
+            try { res.write(': ping\n\n'); } catch { /* noop */ }
+        }
+    }, 5000);
+
+    for (const entry of job.logs) {
+        write('log', { stream: entry.stream, chunk: entry.chunk });
+    }
+
+    const cleanup = () => {
+        if (closed) return;
+        closed = true;
+        clearInterval(heartbeat);
+        job.emitter.off('log', onLog);
+        job.emitter.off('done', onDone);
+    };
+    const onLog = (entry) => {
+        write('log', { stream: entry.stream, chunk: entry.chunk });
+    };
+    const onDone = (payload) => {
+        write('done', payload);
+        cleanup();
+        try { res.end(); } catch { /* noop */ }
+    };
+
+    if (job.status !== 'running') {
+        write('done', snapshotDonePayload(job));
+        cleanup();
+        try { res.end(); } catch { /* noop */ }
+        return;
+    }
+
+    job.emitter.on('log', onLog);
+    job.emitter.once('done', onDone);
+
+    req.on('close', cleanup);
+});
+
+/**
+ * DELETE /api/taskmaster/install/:jobId
+ * Cancel a running TaskMaster install job.
+ */
+router.delete('/install/:jobId', async (req, res) => {
+    const job = getInstallJob(req.params.jobId);
+    if (!job || job.provider !== 'taskmaster') {
+        return res.status(404).json({
+            success: false,
+            error: 'Install job not found'
+        });
+    }
+
+    res.json({ success: true, cancelled: cancelInstallJob(req.params.jobId) });
+});
+
 /**
  * GET /api/taskmaster/tasks/:projectName
  * Load actual tasks from .taskmaster/tasks/tasks.json
@@ -230,6 +362,75 @@ router.get('/tasks/:projectName', async (req, res) => {
     }
 });
 
+/**
+ * POST /api/taskmaster/execute/:projectName/:taskId
+ * Import a TaskMaster task into orchestration and dispatch it to a CLI agent.
+ */
+router.post('/execute/:projectName/:taskId', async (req, res) => {
+    try {
+        const { projectName, taskId } = req.params;
+        const adapterId = typeof req.body?.adapterId === 'string'
+            ? req.body.adapterId
+            : typeof req.body?.provider === 'string'
+                ? req.body.provider
+                : '';
+        const model = typeof req.body?.model === 'string' ? req.body.model : undefined;
+        const permissionMode = typeof req.body?.permissionMode === 'string' ? req.body.permissionMode : undefined;
+        const isolation = ['host', 'worktree', 'docker'].includes(req.body?.isolation)
+            ? req.body.isolation
+            : 'worktree';
+        const projectId = typeof req.body?.projectId === 'string' ? req.body.projectId : projectName;
+
+        if (!adapterId) {
+            return res.status(400).json({
+                success: false,
+                error: 'Missing adapterId',
+                message: 'adapterId or provider is required'
+            });
+        }
+
+        const { projectPath, transformedTasks } = await readTaskMasterTasks(projectName);
+        const task = transformedTasks.find((candidate) => String(candidate.id) === String(taskId));
+        if (!task) {
+            return res.status(404).json({
+                success: false,
+                error: 'TaskMaster task not found',
+                message: `Task "${taskId}" was not found in project "${projectName}"`
+            });
+        }
+
+        const orchestrationTask = orchestrationTaskService.upsertFromTaskMaster({
+            projectId,
+            taskmasterId: String(task.id),
+            title: `TaskMaster #${task.id}: ${task.title}`,
+            description: taskMasterExecutionDescription(task)
+        });
+
+        const dispatchedTask = await orchestrationTaskService.dispatch(orchestrationTask.id, {
+            adapterId,
+            isolation,
+            projectPath,
+            model,
+            permissionMode
+        });
+
+        res.json({
+            success: true,
+            projectName,
+            projectPath,
+            taskmasterTask: task,
+            task: dispatchedTask
+        });
+    } catch (error) {
+        console.error('TaskMaster execute error:', error);
+        res.status(500).json({
+            success: false,
+            error: 'Failed to execute TaskMaster task',
+            message: error.message
+        });
+    }
+});
+
 /**
  * POST /api/taskmaster/sync-orchestration/:projectName
  * One-way sync: TaskMaster -> Orchestration tasks

package/server/routes/telegram.js

@@ -33,6 +33,7 @@ router.get('/status', (req, res) => {
             language: link.language,
             notificationsEnabled: Boolean(link.notifications_enabled),
             bridgeEnabled: Boolean(link.bridge_enabled),
+            control: telegramLinksDb.getControlState(req.user.id),
             pairingCode: link.pairing_code,
             pairingExpiresAt: link.pairing_code_expires_at,
             verifiedAt: link.verified_at,
@@ -98,13 +99,27 @@ router.post('/pairing-code', (req, res) => {
 // PATCH /api/telegram/link — update language / toggles on the user's link
 router.patch('/link', (req, res) => {
   try {
-    const { language, notificationsEnabled, bridgeEnabled } = req.body || {};
+    const { language, notificationsEnabled, bridgeEnabled, controlEnabled, progressMode } = req.body || {};
     const payload = {};
     if (language !== undefined) payload.language = sanitizeLanguage(language);
     if (notificationsEnabled !== undefined) payload.notificationsEnabled = Boolean(notificationsEnabled);
     if (bridgeEnabled !== undefined) payload.bridgeEnabled = Boolean(bridgeEnabled);
     telegramLinksDb.updatePreferences(req.user.id, payload);
-    res.json({ success: true, link: telegramLinksDb.getByUserId(req.user.id) });
+
+    const controlPatch = {};
+    if (controlEnabled !== undefined) controlPatch.remoteControlEnabled = Boolean(controlEnabled);
+    if (progressMode !== undefined && ['final', 'steps', 'all'].includes(progressMode)) {
+      controlPatch.progressMode = progressMode;
+    }
+    if (Object.keys(controlPatch).length > 0) {
+      telegramLinksDb.updateControlState(req.user.id, controlPatch);
+    }
+
+    res.json({
+      success: true,
+      link: telegramLinksDb.getByUserId(req.user.id),
+      control: telegramLinksDb.getControlState(req.user.id),
+    });
   } catch (error) {
     console.error('telegram/link patch failed:', error);
     res.status(500).json({ error: 'Failed to update link' });

package/server/services/install-jobs.js

@@ -63,6 +63,7 @@ const PACKAGE_BINARIES = {
     '@google/gemini-cli': 'gemini',
     '@qwen-code/qwen-code': 'qwen',
     'opencode-ai': 'opencode',
+    'task-master': 'task-master',
 };
 
 /**

package/server/services/notification-orchestrator.js

@@ -23,6 +23,11 @@ const PROVIDER_LABELS = {
 
 const recentEventKeys = new Map();
 const DEDUPE_WINDOW_MS = 20000;
+let notificationWebSocketServer = null;
+
+function setNotificationWebSocketServer(wss) {
+  notificationWebSocketServer = wss;
+}
 
 const cleanupOldEventKeys = () => {
   const now = Date.now();
@@ -41,6 +46,22 @@ function shouldSendPush(preferences, event) {
   return webPushEnabled && eventEnabled;
 }
 
+function shouldSendInApp(preferences, event) {
+  const inAppEnabled = preferences?.channels?.inApp !== false;
+  const prefEventKey = KIND_TO_PREF_KEY[event.kind];
+  const eventEnabled = prefEventKey ? preferences?.events?.[prefEventKey] !== false : true;
+
+  return inAppEnabled && eventEnabled;
+}
+
+function shouldSendTelegram(preferences, event) {
+  const telegramEnabled = preferences?.channels?.telegram !== false;
+  const prefEventKey = KIND_TO_PREF_KEY[event.kind];
+  const eventEnabled = prefEventKey ? preferences?.events?.[prefEventKey] !== false : true;
+
+  return telegramEnabled && eventEnabled;
+}
+
 function isDuplicate(event) {
   cleanupOldEventKeys();
   const key = event.dedupeKey || `${event.provider}:${event.kind || 'info'}:${event.code || 'generic'}:${event.sessionId || 'none'}`;
@@ -149,6 +170,41 @@ function buildPushBody(event) {
   };
 }
 
+function buildNotificationPayload(event) {
+  const pushBody = buildPushBody(event);
+  return {
+    id: event.dedupeKey || `${event.provider || 'system'}:${event.kind || 'info'}:${event.code || 'generic'}:${event.sessionId || 'none'}:${event.createdAt}`,
+    title: pushBody.title,
+    body: pushBody.body,
+    kind: event.kind || 'info',
+    code: event.code || 'generic.info',
+    severity: event.severity || 'info',
+    provider: event.provider || null,
+    sessionId: event.sessionId || null,
+    createdAt: event.createdAt,
+    requiresUserAction: Boolean(event.requiresUserAction),
+    data: pushBody.data
+  };
+}
+
+function broadcastInAppNotification(userId, event) {
+  if (!notificationWebSocketServer || !userId || !event) {
+    return;
+  }
+
+  const message = JSON.stringify({
+    type: 'notification:event',
+    notification: buildNotificationPayload(event)
+  });
+  const normalizedUserId = String(userId);
+
+  notificationWebSocketServer.clients.forEach((client) => {
+    if (client.readyState === 1 && String(client.userId || '') === normalizedUserId) {
+      client.send(message);
+    }
+  });
+}
+
 async function sendWebPush(userId, event) {
   const subscriptions = pushSubscriptionsDb.getSubscriptions(userId);
   if (!subscriptions.length) return;
@@ -191,6 +247,14 @@ function notifyUserIfEnabled({ userId, event }) {
     return;
   }
 
+  if (shouldSendInApp(preferences, event)) {
+    try {
+      broadcastInAppNotification(userId, event);
+    } catch (err) {
+      console.error('In-app notification send error:', err);
+    }
+  }
+
   if (shouldSendPush(preferences, event)) {
     sendWebPush(userId, event).catch((err) => {
       console.error('Web push send error:', err);
@@ -203,14 +267,16 @@ function notifyUserIfEnabled({ userId, event }) {
   const providerLabel = PROVIDER_LABELS[event.provider] || event.provider || 'Session';
   const sessionTitle = event.meta?.sessionName || providerLabel;
   const errorText = event.meta?.error || '';
-  notifyTelegramUser({
-    userId,
-    kind: event.kind,
-    title: sessionTitle,
-    error: errorText,
-  }).catch((err) => {
-    console.warn('[telegram] notify failed:', err?.message || err);
-  });
+  if (shouldSendTelegram(preferences, event)) {
+    notifyTelegramUser({
+      userId,
+      kind: event.kind,
+      title: sessionTitle,
+      error: errorText,
+    }).catch((err) => {
+      console.warn('[telegram] notify failed:', err?.message || err);
+    });
+  }
 }
 
 function notifyRunStopped({ userId, provider, sessionId = null, stopReason = 'completed', sessionName = null }) {
@@ -247,6 +313,8 @@ function notifyRunFailed({ userId, provider, sessionId = null, error, sessionNam
 
 export {
   createNotificationEvent,
+  setNotificationWebSocketServer,
+  broadcastInAppNotification,
   notifyUserIfEnabled,
   notifyRunStopped,
   notifyRunFailed

package/server/services/telegram/bot.js

@@ -2,6 +2,13 @@ import { EventEmitter } from 'node:events';
 
 import { telegramConfigDb, telegramLinksDb } from '../../database/db.js';
 
+import {
+  getTelegramControlCommand,
+  handleTelegramControlCallback,
+  handleTelegramControlMessage,
+  isTelegramControlCommand,
+  showMainMenu,
+} from './control-center.js';
 import { t } from './translations.js';
 // Swapped in v1.32: previously `node-telegram-bot-api` which carried the
 // deprecated `request`/`har-validator`/`uuid@3` chain. TelegramHttpBot is
@@ -21,6 +28,10 @@ let bot = null;
 let botInfo = null; // { id, username, first_name }
 let lastError = null;
 
+export const setTelegramBotForTesting = (nextBot) => {
+  bot = nextBot;
+};
+
 // Subscribers (notification-orchestrator, future session bridge) use this to
 // react to events without importing the bot module directly.
 export const telegramEvents = new EventEmitter();
@@ -64,14 +75,14 @@ const parseMaybeCode = (text) => {
   return /^\d{6}$/.test(trimmed) ? trimmed : null;
 };
 
-const safeSend = async (chatId, text) => {
+const safeSend = async (chatId, text, extra = {}) => {
   if (!bot) return;
   try {
-    await bot.sendMessage(chatId, text, { parse_mode: 'Markdown' });
+    await bot.sendMessage(chatId, text, { parse_mode: 'Markdown', ...extra });
   } catch (err) {
     // Markdown parse errors from user input are common; retry plaintext.
     try {
-      await bot.sendMessage(chatId, text);
+      await bot.sendMessage(chatId, text, extra);
     } catch (fallbackErr) {
       console.warn('[telegram] sendMessage failed:', fallbackErr?.message || fallbackErr);
     }
@@ -98,19 +109,21 @@ const handlePairing = async (msg, code) => {
   telegramEvents.emit('paired', { userId: link.user_id, chatId: String(msg.chat.id), username: telegramUsername });
 
   await safeSend(msg.chat.id, t(language, 'pairing.success'));
+  await safeSend(msg.chat.id, t(language, 'control.onboarding'));
+  await showMainMenu({ bot, chatId: msg.chat.id, link: telegramLinksDb.getByUserId(link.user_id) });
 };
 
 const handleBridgeMessage = async (msg, existing) => {
   const language = existing.language || 'en';
 
+  const handled = await handleTelegramControlMessage({ bot, msg, link: existing, safeSend });
+  if (handled) return;
+
   if (!existing.bridge_enabled) {
     await safeSend(msg.chat.id, t(language, 'bridge.disabled'));
     return;
   }
 
-  // Fan out to subscribers (future: session-prompt bridge). We don't do the
-  // actual agent dispatch here to keep the bot service narrowly focused on
-  // Telegram I/O and let the rest of the server opt in.
   telegramEvents.emit('prompt', {
     userId: existing.user_id,
     chatId: String(msg.chat.id),
@@ -122,11 +135,43 @@ const handleBridgeMessage = async (msg, existing) => {
   await safeSend(msg.chat.id, t(language, 'bridge.queued'));
 };
 
+const handleCallbackQuery = async (query) => {
+  const chatId = query?.message?.chat?.id;
+  if (!chatId) return;
+  const existing = telegramLinksDb.getByChatId(String(chatId));
+  if (!existing) {
+    await bot?.answerCallbackQuery(query.id, { text: 'Pair Pixcode first.' }).catch(() => {});
+    return;
+  }
+  await handleTelegramControlCallback({ bot, query, link: existing, safeSend });
+};
+
 const handleMessage = async (msg) => {
   if (!msg?.chat?.id || !msg?.text) return;
 
   const existing = telegramLinksDb.getByChatId(String(msg.chat.id));
   if (existing) {
+    const language = existing.language || 'en';
+    const command = getTelegramControlCommand(msg.text);
+    if (command === '/start') {
+      await safeSend(msg.chat.id, t(language, 'control.onboarding'));
+      await showMainMenu({ bot, chatId: msg.chat.id, link: existing });
+      return;
+    }
+    if (command === '/help') {
+      await safeSend(msg.chat.id, t(language, 'control.help'));
+      return;
+    }
+    if (command === '/menu' || command === 'menu') {
+      await showMainMenu({ bot, chatId: msg.chat.id, link: existing });
+      return;
+    }
+
+    if (isTelegramControlCommand(msg.text)) {
+      await handleTelegramControlMessage({ bot, msg, link: existing });
+      return;
+    }
+
     // Paired user path: a 6-digit-only message is treated as noise (we keep
     // the already-paired binding); anything else is bridge traffic.
     const maybeCode = parseMaybeCode(msg.text);
@@ -157,6 +202,8 @@ const handleMessage = async (msg) => {
   await safeSend(msg.chat.id, t('en', 'pairing.stillNeeded'));
 };
 
+export const handleIncomingTelegramMessage = handleMessage;
+
 const wirePollingErrors = () => {
   if (!bot) return;
   bot.on('polling_error', (err) => {
@@ -213,6 +260,11 @@ export const startBot = async ({ token, persist = true } = {}) => {
       console.error('[telegram] handleMessage crashed:', err);
     });
   });
+  bot.on('callback_query', (query) => {
+    handleCallbackQuery(query).catch((err) => {
+      console.error('[telegram] handleCallbackQuery crashed:', err);
+    });
+  });
   wirePollingErrors();
 
   console.log(`[telegram] bot started as @${me.username}`);