@pixelbyte-software/pixcode 1.53.7 → 1.53.9

package/server/index.js

@@ -43,13 +43,19 @@ const DAEMON_COMMAND_CONTEXT = {
 };
 
 function resolveMonacoAssetsPath() {
+    const appParent = path.dirname(APP_ROOT);
+    const appGrandparent = path.dirname(appParent);
     const candidates = [
         path.join(APP_ROOT, 'node_modules', 'monaco-editor', 'min', 'vs'),
+        path.join(appParent, 'node_modules', 'monaco-editor', 'min', 'vs'),
+        path.join(appParent, 'monaco-editor', 'min', 'vs'),
+        path.join(appGrandparent, 'node_modules', 'monaco-editor', 'min', 'vs'),
+        path.join(appGrandparent, 'monaco-editor', 'min', 'vs'),
     ];
 
     try {
         const monacoPackagePath = require.resolve('monaco-editor/package.json', {
-            paths: [APP_ROOT, __dirname],
+            paths: [APP_ROOT, appParent, appGrandparent, __dirname, process.cwd()],
         });
         candidates.push(path.join(path.dirname(monacoPackagePath), 'min', 'vs'));
     } catch {
@@ -1012,6 +1018,11 @@ const ptySessionsMap = new Map();
 const PTY_SESSION_TIMEOUT = 30 * 60 * 1000;
 const COMPLETED_PTY_SESSION_TTL = 5 * 60 * 1000;
 const SHELL_URL_PARSE_BUFFER_LIMIT = 32768;
+const SHELL_OUTPUT_FLUSH_MAX_CHARS = 128 * 1024;
+const SHELL_WS_BACKPRESSURE_LIMIT = 8 * 1024 * 1024;
+const PTY_SESSION_BUFFER_MAX_BYTES = Number.parseInt(process.env.PIXCODE_PTY_BUFFER_MAX_BYTES || '', 10) || (2 * 1024 * 1024);
+const SHELL_INPUT_CHUNK_CHARS = 4096;
+const SHELL_PENDING_INPUT_MAX_BYTES = 2 * 1024 * 1024;
 const SHELL_CLI_PROVIDERS = new Set(['claude', 'codex', 'cursor', 'gemini', 'qwen', 'opencode']);
 import { stripAnsiSequences, normalizeDetectedUrl, extractUrlsFromText, shouldAutoOpenUrlFromOutput } from './utils/url-detection.js';
 
@@ -1156,12 +1167,23 @@ function resolveProviderTerminalState(session, provider, output) {
 
 function appendPtySessionBuffer(session, data) {
     if (!session) return;
-    if (session.buffer.length < 5000) {
-        session.buffer.push(data);
-    } else {
-        session.buffer.shift();
-        session.buffer.push(data);
+    let value = String(data || '');
+    if (!value) return;
+
+    let valueBytes = Buffer.byteLength(value, 'utf8');
+    if (valueBytes > PTY_SESSION_BUFFER_MAX_BYTES) {
+        value = value.slice(-PTY_SESSION_BUFFER_MAX_BYTES);
+        valueBytes = Buffer.byteLength(value, 'utf8');
+    }
+
+    session.buffer.push(value);
+    session.bufferBytes = (session.bufferBytes || 0) + valueBytes;
+
+    while (session.buffer.length > 0 && session.bufferBytes > PTY_SESSION_BUFFER_MAX_BYTES) {
+        const removed = session.buffer.shift();
+        session.bufferBytes -= Buffer.byteLength(String(removed || ''), 'utf8');
     }
+    if (session.bufferBytes < 0) session.bufferBytes = 0;
 }
 
 function normalizeTerminalStartupInput(input) {
@@ -1258,6 +1280,26 @@ function writeTerminalStartupInput(session, startupInput, reason, delayMs = 500)
     queueTerminalStartupInput(session, startupInput, reason, delayMs);
 }
 
+function splitTerminalInput(data) {
+    const value = String(data || '');
+    if (!value) return [];
+    const chunks = [];
+    for (let index = 0; index < value.length; index += SHELL_INPUT_CHUNK_CHARS) {
+        chunks.push(value.slice(index, index + SHELL_INPUT_CHUNK_CHARS));
+    }
+    return chunks;
+}
+
+function writeTerminalInputChunks(ptyProcess, data) {
+    if (!ptyProcess?.write) return false;
+    const chunks = splitTerminalInput(data);
+    if (chunks.length === 0) return false;
+    for (const chunk of chunks) {
+        ptyProcess.write(chunk);
+    }
+    return true;
+}
+
 function normalizeShellPermissionMode(value) {
     return typeof value === 'string' ? value.trim() : '';
 }
@@ -1541,7 +1583,7 @@ app.post('/api/shell/sessions/provider-input', authenticateToken, requireProject
 
     const data = submit ? normalizeTerminalStartupInput(input) : input;
     try {
-        matchedSession.pty.write(data);
+        writeTerminalInputChunks(matchedSession.pty, data);
         matchedSession.updatedAt = Date.now();
         res.json({
             ok: true,
@@ -3406,8 +3448,63 @@ function handleShellConnection(ws, request) {
     let urlDetectionBuffer = '';
     let outputBuffer = '';
     let outputFlushTimer = null;
+    let inputFlushTimer = null;
+    let pendingInputBytes = 0;
+    const pendingInputQueue = [];
     const announcedAuthUrls = new Set();
 
+    function getActiveShellPty() {
+        const session = ptySessionKey ? ptySessionsMap.get(ptySessionKey) : null;
+        return session?.pty || shellProcess;
+    }
+
+    function scheduleInputFlush(delayMs = 0) {
+        if (inputFlushTimer) return;
+        inputFlushTimer = setTimeout(flushPendingInput, delayMs);
+    }
+
+    function flushPendingInput() {
+        inputFlushTimer = null;
+        if (pendingInputQueue.length === 0) return;
+
+        const activePty = getActiveShellPty();
+        if (!activePty?.write) {
+            scheduleInputFlush(100);
+            return;
+        }
+
+        const chunk = pendingInputQueue.shift();
+        pendingInputBytes = Math.max(0, pendingInputBytes - Buffer.byteLength(chunk, 'utf8'));
+        try {
+            activePty.write(chunk);
+        } catch (error) {
+            console.error('Error writing to shell:', error);
+            pendingInputQueue.length = 0;
+            pendingInputBytes = 0;
+            return;
+        }
+
+        if (pendingInputQueue.length > 0) scheduleInputFlush(1);
+    }
+
+    function enqueueShellInput(data) {
+        const chunks = splitTerminalInput(data);
+        if (chunks.length === 0) return;
+
+        for (const chunk of chunks) {
+            pendingInputQueue.push(chunk);
+            pendingInputBytes += Buffer.byteLength(chunk, 'utf8');
+        }
+
+        while (pendingInputQueue.length > 0 && pendingInputBytes > SHELL_PENDING_INPUT_MAX_BYTES) {
+            const dropped = pendingInputQueue.shift();
+            pendingInputBytes -= Buffer.byteLength(String(dropped || ''), 'utf8');
+        }
+        if (pendingInputBytes < 0) pendingInputBytes = 0;
+
+        scheduleInputFlush();
+    }
+
     function flushOutputBuffer() {
         if (!outputBuffer || !ptySessionKey) {
             outputFlushTimer = null;
@@ -3424,7 +3521,17 @@ function handleShellConnection(ws, request) {
         appendPtySessionBuffer(session, rawData);
 
         if (session.ws && session.ws.readyState === WebSocket.OPEN) {
+            if (session.ws.bufferedAmount > SHELL_WS_BACKPRESSURE_LIMIT) {
+                session.droppedOutputBytes = (session.droppedOutputBytes || 0) + Buffer.byteLength(rawData, 'utf8');
+                return;
+            }
+
+            const droppedOutputBytes = session.droppedOutputBytes || 0;
+            session.droppedOutputBytes = 0;
             let outputData = rawData;
+            if (droppedOutputBytes > 0) {
+                outputData = `\r\n\x1b[33m[Pixcode] ${droppedOutputBytes} bytes of terminal output were skipped because the browser connection was backpressured.\x1b[0m\r\n${outputData}`;
+            }
 
             const cleanChunk = stripAnsiSequences(rawData);
             urlDetectionBuffer = `${urlDetectionBuffer}${cleanChunk}`.slice(-SHELL_URL_PARSE_BUFFER_LIMIT);
@@ -3786,6 +3893,8 @@ function handleShellConnection(ws, request) {
                         pty: shellProcess,
                         ws: ws,
                         buffer: [],
+                        bufferBytes: 0,
+                        droppedOutputBytes: 0,
                         timeoutId: null,
                         userId: ownerUserId,
                         projectPath,
@@ -3806,12 +3915,21 @@ function handleShellConnection(ws, request) {
                     if (terminalStartupInput && !isPlainShell) {
                         writeTerminalStartupInput(createdSession, terminalStartupInput, 'new provider session', 4500);
                     }
+                    scheduleInputFlush();
 
                     // Handle data output — batch rapid chunks so high-volume CLI
                     // output does not flood the WebSocket with one JSON frame per
                     // keystroke-sized chunk.
                     shellProcess.onData((data) => {
                         outputBuffer += data;
+                        if (outputBuffer.length >= SHELL_OUTPUT_FLUSH_MAX_CHARS) {
+                            if (outputFlushTimer) {
+                                clearTimeout(outputFlushTimer);
+                                outputFlushTimer = null;
+                            }
+                            flushOutputBuffer();
+                            return;
+                        }
                         if (!outputFlushTimer) {
                             outputFlushTimer = setTimeout(flushOutputBuffer, 8);
                         }
@@ -3878,16 +3996,7 @@ function handleShellConnection(ws, request) {
                 }
 
             } else if (data.type === 'input') {
-                // Send input to shell process
-                if (shellProcess && shellProcess.write) {
-                    try {
-                        shellProcess.write(data.data);
-                    } catch (error) {
-                        console.error('Error writing to shell:', error);
-                    }
-                } else {
-                    console.warn('No active shell process to send input to');
-                }
+                enqueueShellInput(data.data);
             } else if (data.type === 'resize') {
                 // Handle terminal resize
                 const session = ptySessionKey ? ptySessionsMap.get(ptySessionKey) : null;
@@ -3921,6 +4030,12 @@ function handleShellConnection(ws, request) {
             clearTimeout(outputFlushTimer);
             outputFlushTimer = null;
         }
+        if (inputFlushTimer) {
+            clearTimeout(inputFlushTimer);
+            inputFlushTimer = null;
+        }
+        pendingInputQueue.length = 0;
+        pendingInputBytes = 0;
 
         if (ptySessionKey) {
             const session = ptySessionsMap.get(ptySessionKey);

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

@@ -27,11 +27,14 @@ const TERMINAL_RUN_STATES = new Set(['completed', 'failed', 'canceled']);
 const CALLBACK_TTL_MS = 10 * 60 * 1000;
 const MAX_CALLBACK_ACTIONS = 1000;
 const MAX_TELEGRAM_TEXT = 3600;
+const MAX_ACTIVITY_OUTPUT_CHARS = 48_000;
+const MAX_SSE_BUFFER_CHARS = 256_000;
 const ACTIVITY_EDIT_THROTTLE_MS = 1200;
 const ACTIVITY_HEARTBEAT_MS = 8000;
 const INTENT_ROUTER_TIMEOUT_MS = 45_000;
 const callbackActions = new Map();
 const runMonitors = new Map();
+const activeLongTasks = new Map();
 
 const MODEL_FALLBACKS = Object.fromEntries(
   PROVIDERS.map((provider) => [provider, getStaticProviderModels(provider)]),
@@ -85,6 +88,14 @@ function truncate(text, max = MAX_TELEGRAM_TEXT) {
   return value.length > max ? `${value.slice(0, max - 20)}\n\n…truncated…` : value;
 }
 
+function appendBoundedText(current, chunk, maxChars = MAX_ACTIVITY_OUTPUT_CHARS) {
+  const nextChunk = String(chunk || '');
+  if (!nextChunk) return { text: current || '', truncated: false };
+  const combined = `${current || ''}${nextChunk}`;
+  if (combined.length <= maxChars) return { text: combined, truncated: false };
+  return { text: combined.slice(-maxChars), truncated: true };
+}
+
 function languageFor(link) {
   return SUPPORTED_LANGUAGES.includes(link?.language) ? link.language : 'en';
 }
@@ -313,6 +324,9 @@ async function localAgentStream(userId, body, onEvent) {
     const { done, value } = await reader.read();
     if (done) break;
     buffer += decoder.decode(value, { stream: true });
+    if (buffer.length > MAX_SSE_BUFFER_CHARS) {
+      buffer = buffer.slice(-MAX_SSE_BUFFER_CHARS);
+    }
     let boundary = buffer.indexOf('\n\n');
     while (boundary !== -1) {
       const block = buffer.slice(0, boundary);
@@ -360,6 +374,7 @@ function createActivityState({ lang, type = 'agent', provider, project, prompt,
     workflowId: null,
     events: [],
     output: '',
+    outputTruncated: false,
     error: null,
   };
 }
@@ -386,6 +401,13 @@ function trimTelegramOutput(text, max, suffix = '') {
   return `${value.slice(0, room).trim()}\n\n${ending}`;
 }
 
+function appendActivityOutput(activity, chunk) {
+  if (!activity) return;
+  const next = appendBoundedText(activity.output, chunk);
+  activity.output = next.text;
+  activity.outputTruncated = Boolean(activity.outputTruncated || next.truncated);
+}
+
 function renderActivity(activity, { finalText = null } = {}) {
   const output = finalText || activity.output;
   if (activity.type === 'agent' && output && !activity.error) {
@@ -393,7 +415,9 @@ function renderActivity(activity, { finalText = null } = {}) {
       return trimTelegramOutput(
         output,
         3400,
-        t(activity.lang, 'control.activity.outputTooLong'),
+        activity.outputTruncated
+          ? t(activity.lang, 'control.activity.outputHistoryTrimmed')
+          : t(activity.lang, 'control.activity.outputTooLong'),
       );
     }
 
@@ -839,13 +863,13 @@ function applyAgentStreamEvent(activity, event) {
   if (event.kind === 'stream_delta' || event.kind === 'text') {
     activity.status = 'running';
     activity.phase = t(activity.lang, 'control.activity.responding');
-    activity.output = `${activity.output}${extractTextFromEvent(event)}`;
+    appendActivityOutput(activity, extractTextFromEvent(event));
     return;
   }
   if (event.type === 'claude-response' && event.data?.type === 'assistant') {
     activity.status = 'running';
     activity.phase = t(activity.lang, 'control.activity.responding');
-    activity.output = `${activity.output}${extractTextFromEvent(event)}`;
+    appendActivityOutput(activity, extractTextFromEvent(event));
     return;
   }
   if (event.kind === 'tool_use') {
@@ -975,6 +999,47 @@ async function runAgent({ bot, chatId, link, prompt, activity = null }) {
   await editTelegramActivity({ bot, chatId, activity: active, force: true });
 }
 
+function longTaskKey(chatId) {
+  return String(chatId);
+}
+
+async function launchLongTelegramTask({ bot, chatId, link, kind, activity = null, task }) {
+  const key = longTaskKey(chatId);
+  const existing = activeLongTasks.get(key);
+  const lang = languageFor(link);
+  if (existing) {
+    await send(bot, chatId, t(lang, 'control.longTaskRunning', {
+      kind: existing.kind,
+      elapsed: formatElapsed(existing.startedAt),
+    }), {
+      editMessageId: activity?.messageId,
+      parse_mode: undefined,
+    });
+    return true;
+  }
+
+  const record = {
+    kind,
+    startedAt: Date.now(),
+  };
+  activeLongTasks.set(key, record);
+
+  Promise.resolve()
+    .then(task)
+    .catch(async (error) => {
+      console.error('[telegram-control] long task failed:', error);
+      await send(bot, chatId, t(lang, 'control.longTaskFailed'), {
+        editMessageId: activity?.messageId,
+        parse_mode: undefined,
+      }).catch(() => {});
+    })
+    .finally(() => {
+      if (activeLongTasks.get(key) === record) activeLongTasks.delete(key);
+    });
+
+  return true;
+}
+
 export async function runWorkflow({ bot, chatId, link, input, activity = null }) {
   const lang = languageFor(link);
   const state = getState(link.user_id);
@@ -1188,8 +1253,14 @@ async function handleRoutedIntent({ bot, chatId, link, text, activity }) {
   const editMessageId = activity?.messageId;
 
   if (intent.action === 'agent_prompt') {
-    await runAgent({ bot, chatId, link, prompt: intent.prompt || text, activity });
-    return true;
+    return launchLongTelegramTask({
+      bot,
+      chatId,
+      link,
+      kind: 'agent',
+      activity,
+      task: () => runAgent({ bot, chatId, link, prompt: intent.prompt || text, activity }),
+    });
   }
   if (intent.action === 'show_menu') {
     await showMainMenu({ bot, chatId, link, editMessageId });
@@ -1266,8 +1337,14 @@ async function handleRoutedIntent({ bot, chatId, link, text, activity }) {
     return true;
   }
   if (intent.action === 'run_workflow') {
-    await runWorkflow({ bot, chatId, link, input: intent.workflowInput || text, activity });
-    return true;
+    return launchLongTelegramTask({
+      bot,
+      chatId,
+      link,
+      kind: 'workflow',
+      activity,
+      task: () => runWorkflow({ bot, chatId, link, input: intent.workflowInput || text, activity }),
+    });
   }
   if (intent.action === 'show_sessions') {
     await showSessions({ bot, chatId, link, editMessageId });
@@ -1277,8 +1354,14 @@ async function handleRoutedIntent({ bot, chatId, link, text, activity }) {
     await startNewChat({ bot, chatId, link, editMessageId });
     return true;
   }
-  await runAgent({ bot, chatId, link, prompt: text, activity });
-  return true;
+  return launchLongTelegramTask({
+    bot,
+    chatId,
+    link,
+    kind: 'agent',
+    activity,
+    task: () => runAgent({ bot, chatId, link, prompt: text, activity }),
+  });
 }
 
 async function fetchRun(userId, runId) {
@@ -1493,12 +1576,22 @@ async function handleAwaitingInput({ bot, chatId, link, text }) {
   updateTelegramControlState(link.user_id, { awaiting: null });
 
   if (awaiting.type === 'agent_prompt') {
-    await runAgent({ bot, chatId, link, prompt: text });
-    return true;
+    return launchLongTelegramTask({
+      bot,
+      chatId,
+      link,
+      kind: 'agent',
+      task: () => runAgent({ bot, chatId, link, prompt: text }),
+    });
   }
   if (awaiting.type === 'workflow_prompt') {
-    await runWorkflow({ bot, chatId, link, input: text });
-    return true;
+    return launchLongTelegramTask({
+      bot,
+      chatId,
+      link,
+      kind: 'workflow',
+      task: () => runWorkflow({ bot, chatId, link, input: text }),
+    });
   }
   return false;
 }
@@ -1592,8 +1685,13 @@ async function handleCommand({ bot, chatId, link, text }) {
       await send(bot, chatId, t(lang, 'control.sendAgentPrompt'));
       return true;
     }
-    await runAgent({ bot, chatId, link, prompt: argText });
-    return true;
+    return launchLongTelegramTask({
+      bot,
+      chatId,
+      link,
+      kind: 'agent',
+      task: () => runAgent({ bot, chatId, link, prompt: argText }),
+    });
   }
   if (command === '/workflow' || command === '/orchestrate') {
     if (!argText) {
@@ -1601,8 +1699,13 @@ async function handleCommand({ bot, chatId, link, text }) {
       await send(bot, chatId, t(lang, 'control.sendWorkflowPrompt'));
       return true;
     }
-    await runWorkflow({ bot, chatId, link, input: argText });
-    return true;
+    return launchLongTelegramTask({
+      bot,
+      chatId,
+      link,
+      kind: 'workflow',
+      task: () => runWorkflow({ bot, chatId, link, input: argText }),
+    });
   }
   if (command === '/cancel') {
     if (!argText) {
@@ -1661,6 +1764,10 @@ export async function handleTelegramControlMessage(args) {
       await send(args.bot, chatId, t(languageFor(args.link), 'error.generic')).catch(() => {});
       return true;
     }
+  }).catch(async (error) => {
+    console.error('[telegram-control] message job failed:', error);
+    await send(args.bot, chatId, t(languageFor(args.link), 'error.generic')).catch(() => {});
+    return true;
   });
 }
 
@@ -1849,5 +1956,10 @@ export async function handleTelegramControlCallback(args) {
       await args.bot?.answerCallbackQuery(args.query?.id, { text: t(lang, 'error.generic') }).catch(() => {});
       await send(args.bot, chatId, t(lang, 'error.generic')).catch(() => {});
     }
+  }).catch(async (error) => {
+    console.error('[telegram-control] callback job failed:', error);
+    const lang = languageFor(args.link);
+    await args.bot?.answerCallbackQuery(args.query?.id, { text: t(lang, 'error.generic') }).catch(() => {});
+    await send(args.bot, chatId, t(lang, 'error.generic')).catch(() => {});
   });
 }

package/server/services/telegram/translations.js

@@ -140,7 +140,10 @@ const EN = {
   'control.activity.tokens': 'Tokens',
   'control.activity.liveFooter': 'Response is still streaming · {{elapsed}}',
   'control.activity.outputShortened': 'Telegram output was shortened while the run continues.',
+  'control.activity.outputHistoryTrimmed': 'Earlier response output was trimmed to protect memory. Open the Pixcode session for the full output.',
   'control.activity.outputTooLong': 'Long response shortened for Telegram. Open the session in Pixcode for the full output.',
+  'control.longTaskRunning': 'A {{kind}} task is already running in this chat · {{elapsed}}. You can still use /menu, /runs, or /settings.',
+  'control.longTaskFailed': 'The background Telegram task failed. Check Pixcode logs or try again.',
   'notification.taskDone': '✅ {{title}} — task completed.',
   'notification.taskFailed': '⚠️ {{title}} — task failed: {{error}}',
   'notification.actionRequired': '❗ {{title}} — action required.',
@@ -281,7 +284,10 @@ const TR = {
   'control.activity.tokens': 'Token',
   'control.activity.liveFooter': 'Yanıt devam ediyor · {{elapsed}}',
   'control.activity.outputShortened': 'Telegram çıktısı çalışma devam ederken kısaltıldı.',
+  'control.activity.outputHistoryTrimmed': 'Yanıtın önceki bölümü bellek koruması için kısaltıldı. Tam çıktı için Pixcode oturumunu aç.',
   'control.activity.outputTooLong': 'Uzun yanıt Telegram için kısaltıldı. Tam çıktı için Pixcode oturumunu aç.',
+  'control.longTaskRunning': 'Bu sohbette zaten bir {{kind}} işi çalışıyor · {{elapsed}}. /menu, /runs veya /settings yine çalışır.',
+  'control.longTaskFailed': 'Arka plandaki Telegram işi hata verdi. Pixcode loglarını kontrol et veya tekrar dene.',
   'notification.taskDone': '✅ {{title}} — görev tamamlandı.',
   'notification.taskFailed': '⚠️ {{title}} — görev başarısız: {{error}}',
   'notification.actionRequired': '❗ {{title}} — işlem gerekli.',