@pixelbyte-software/pixcode 1.36.3 → 1.37.0

package/scripts/smoke/orchestration-user-facing-output.mjs

@@ -0,0 +1,25 @@
+#!/usr/bin/env node
+
+import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+
+const source = readFileSync('server/modules/orchestration/workflows/workflow-runner.ts', 'utf8');
+
+assert.ok(
+  source.includes('userFacingTaskText'),
+  'Workflow runner should normalize A2A task output into user-facing text.',
+);
+assert.ok(
+  !source.includes('`${message.role}: ${message.text}`'),
+  'Workflow runner must not prefix final/user-facing output with raw A2A roles like agent:.',
+);
+assert.ok(
+  source.includes('Do not expose internal prompts, memory lookup, skill/tool instructions, raw agent logs, or role prefixes like "agent:" and "user:".'),
+  'Agent-team final report prompt should explicitly block internal process leakage.',
+);
+assert.ok(
+  source.includes('Do not mention internal instructions, memory files, skill use, or tool protocol unless the user explicitly asks.'),
+  'Agent-team worker prompts should discourage internal process leakage.',
+);
+
+console.log('orchestration user-facing output smoke passed');

package/scripts/smoke/shell-manual-disconnect.mjs

@@ -0,0 +1,30 @@
+#!/usr/bin/env node
+
+import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+
+const connectionSource = readFileSync('src/components/shell/hooks/useShellConnection.ts', 'utf8');
+const runtimeSource = readFileSync('src/components/shell/hooks/useShellRuntime.ts', 'utf8');
+
+assert.ok(
+  connectionSource.includes('manualDisconnectRef'),
+  'Shell connection should track manual disconnects separately from socket closes.',
+);
+assert.ok(
+  connectionSource.includes('manualDisconnectRef.current = true'),
+  'Manual disconnect should disable auto-reconnect.',
+);
+assert.ok(
+  connectionSource.includes('manualDisconnectRef.current = false'),
+  'Explicit connect should re-enable connection attempts.',
+);
+assert.ok(
+  connectionSource.includes('manualDisconnectRef.current'),
+  'Auto-connect effect should check the manual disconnect guard.',
+);
+assert.ok(
+  runtimeSource.includes('disconnectFromShell(false)'),
+  'Internal project/session/restart disconnects should not set the manual disconnect guard.',
+);
+
+console.log('shell manual disconnect smoke passed');

package/scripts/smoke/side-panel-editor-layout.mjs

@@ -0,0 +1,34 @@
+#!/usr/bin/env node
+
+import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+
+const mainSource = readFileSync('src/components/main-content/view/MainContent.tsx', 'utf8');
+const editorSource = readFileSync('src/components/code-editor/view/EditorSidebar.tsx', 'utf8');
+
+assert.ok(
+  mainSource.includes('SIDE_PANEL_MAX_WIDTH = 50'),
+  'Side panel split width should be capped at half of the main surface.',
+);
+assert.ok(
+  mainSource.includes('dockEditorInsideFilesPanel'),
+  'Files tab should dock the editor inside the files side panel.',
+);
+assert.ok(
+  mainSource.includes('showSidePanelSplit)'),
+  'Side panel split should remain active even when a file editor is open.',
+);
+assert.ok(
+  mainSource.includes('!dockEditorInsideFilesPanel &&'),
+  'Global editor sidebar should not render when the editor is docked inside the files panel.',
+);
+assert.ok(
+  mainSource.includes('max-w-[50%]'),
+  'The file list column inside the files panel should be capped at 50%.',
+);
+assert.ok(
+  editorSource.includes("useFlexLayout ? 'flex-1' : ''"),
+  'EditorSidebar should fill inline docked space when fillSpace is enabled.',
+);
+
+console.log('side panel editor layout smoke passed');

package/scripts/smoke/static-root-routing.mjs

@@ -0,0 +1,21 @@
+#!/usr/bin/env node
+
+import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+
+const source = readFileSync('server/index.js', 'utf8');
+const distStatic = "app.use(express.static(path.join(APP_ROOT, 'dist')";
+const publicStatic = "app.use(express.static(path.join(APP_ROOT, 'public')";
+
+const distIndex = source.indexOf(distStatic);
+const publicIndex = source.indexOf(publicStatic);
+
+assert.ok(distIndex !== -1, 'dist static middleware is missing');
+assert.ok(publicIndex !== -1, 'public static middleware is missing');
+assert.ok(distIndex < publicIndex, 'dist static middleware must run before public');
+assert.ok(
+  source.slice(publicIndex, publicIndex + 160).includes('index: false'),
+  'public static middleware must not serve public/index.html for /',
+);
+
+console.log('static root routing smoke passed');

package/scripts/smoke/strict-handoff-compact.mjs

@@ -0,0 +1,60 @@
+#!/usr/bin/env node
+
+import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+
+const source = readFileSync('server/modules/orchestration/workflows/workflow-runner.ts', 'utf8');
+const types = readFileSync('server/modules/orchestration/workflows/workflow.types.ts', 'utf8');
+const panel = readFileSync('src/components/orchestration/workflows/WorkflowRunPanel.tsx', 'utf8');
+
+assert.ok(
+  types.includes('internal?: boolean'),
+  'Workflow nodes/runs should carry an internal flag so init/compact packets stay out of user-facing output.',
+);
+
+assert.ok(
+  source.includes('handoffInitPrompt('),
+  'Strict handoff should create an internal init prompt before each agent work step.',
+);
+
+assert.ok(
+  source.includes('handoffCompactPrompt('),
+  'Strict handoff should create an internal compact prompt after each agent work step.',
+);
+
+assert.ok(
+  source.includes("safeAgentNodeId(agent, index, 'init')"),
+  'Sequential handoff should create a per-agent init node.',
+);
+
+assert.ok(
+  source.includes("safeAgentNodeId(agent, index, 'work')"),
+  'Sequential handoff should create a per-agent work node.',
+);
+
+assert.ok(
+  source.includes("safeAgentNodeId(agent, index, 'compact')"),
+  'Sequential handoff should create a per-agent compact node.',
+);
+
+assert.ok(
+  /inputs:\s*index === 0\s*\?\s*\[\]\s*:\s*\[safeAgentNodeId\(agents\[index - 1\], index - 1, 'compact'\)\]/m.test(source),
+  'Each init node after the first must depend on the previous agent compact node.',
+);
+
+assert.ok(
+  /inputs:\s*\[initNodeId\]/m.test(source),
+  'Each work node must depend on its init node.',
+);
+
+assert.ok(
+  /inputs:\s*\[workNodeId\]/m.test(source),
+  'Each compact node must depend on its work node.',
+);
+
+assert.ok(
+  panel.includes('visibleNodeRuns'),
+  'Workflow UI should filter internal init/compact node runs from visible output.',
+);
+
+console.log('strict handoff compact smoke passed');

package/scripts/smoke/taskmaster-execution-telegram.mjs

@@ -0,0 +1,52 @@
+#!/usr/bin/env node
+
+import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+
+const taskmasterRoutes = readFileSync('server/routes/taskmaster.js', 'utf8');
+const taskService = readFileSync('server/modules/orchestration/tasks/orchestration-task.service.ts', 'utf8');
+const taskTypes = readFileSync('server/modules/orchestration/tasks/orchestration-task.types.ts', 'utf8');
+const telegramControl = readFileSync('server/services/telegram/control-center.js', 'utf8');
+const translations = readFileSync('server/services/telegram/translations.js', 'utf8');
+
+assert.ok(
+  taskmasterRoutes.includes("router.post('/execute/:projectName/:taskId'"),
+  'TaskMaster route should expose project/task execution endpoint.',
+);
+
+assert.ok(
+  taskmasterRoutes.includes('orchestrationTaskService.dispatch') && taskmasterRoutes.includes('model'),
+  'TaskMaster execution should dispatch through orchestration with model support.',
+);
+
+assert.ok(
+  taskService.includes('projectPath?: string') || taskTypes.includes('projectPath?: string'),
+  'Orchestration task dispatch should carry projectPath into A2A workspace metadata.',
+);
+
+assert.ok(
+  taskService.includes('model: input.model') && taskService.includes('projectPath: input.projectPath'),
+  'Task dispatch should forward selected model and project path to A2A.',
+);
+
+assert.ok(
+  telegramControl.includes("'/tasks'") && telegramControl.includes("'/task'"),
+  'Telegram control should register TaskMaster commands.',
+);
+
+assert.ok(
+  telegramControl.includes('showTaskMasterTasks') && telegramControl.includes('runTaskMasterTask'),
+  'Telegram control should list and execute TaskMaster tasks.',
+);
+
+assert.ok(
+  telegramControl.includes('/api/taskmaster/execute/') && telegramControl.includes('monitorA2ATask'),
+  'Telegram TaskMaster execution should call the backend and monitor the A2A task.',
+);
+
+assert.ok(
+  translations.includes('control.button.tasks') && translations.includes('control.taskStarted'),
+  'Telegram translations should include TaskMaster task controls.',
+);
+
+console.log('taskmaster execution telegram smoke passed');

package/scripts/smoke/taskmaster-onboarding.mjs

@@ -0,0 +1,52 @@
+#!/usr/bin/env node
+
+import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+
+const installJobs = readFileSync('server/services/install-jobs.js', 'utf8');
+const taskmasterRoutes = readFileSync('server/routes/taskmaster.js', 'utf8');
+const onboarding = readFileSync('src/components/onboarding/view/Onboarding.tsx', 'utf8');
+const stepProgress = readFileSync('src/components/onboarding/view/subcomponents/OnboardingStepProgress.tsx', 'utf8');
+const taskStep = readFileSync('src/components/onboarding/view/subcomponents/TaskSystemStep.tsx', 'utf8');
+
+assert.ok(
+  installJobs.includes("'task-master': 'task-master'"),
+  'TaskMaster package should be verified by the sandbox CLI installer.',
+);
+
+assert.ok(
+  taskmasterRoutes.includes("router.post('/install'"),
+  'TaskMaster routes should expose an authenticated install endpoint.',
+);
+
+assert.ok(
+  taskmasterRoutes.includes("router.get('/install/:jobId/stream'"),
+  'TaskMaster install should expose the same resilient log stream pattern as provider installs.',
+);
+
+assert.ok(
+  taskmasterRoutes.includes("provider: 'taskmaster'") && taskmasterRoutes.includes("packageName: 'task-master'"),
+  'TaskMaster install route should install the task-master npm package under the taskmaster job provider.',
+);
+
+assert.ok(
+  onboarding.includes('TaskSystemStep') && onboarding.includes('currentStep < 2'),
+  'Onboarding should include a third Task system step before completion.',
+);
+
+assert.ok(
+  onboarding.includes("localStorage.setItem('tasks-enabled'"),
+  'Onboarding should persist the user task-system choice.',
+);
+
+assert.ok(
+  stepProgress.includes('Task System'),
+  'Onboarding progress should show the Task System step.',
+);
+
+assert.ok(
+  taskStep.includes('/api/taskmaster/installation-status') && taskStep.includes('/api/taskmaster/install'),
+  'TaskSystemStep should check and install TaskMaster through the backend API.',
+);
+
+console.log('taskmaster onboarding smoke passed');

package/scripts/smoke/telegram-control.mjs

@@ -0,0 +1,242 @@
+#!/usr/bin/env node
+
+import assert from 'node:assert/strict';
+import { mkdirSync, readFileSync, rmSync } from 'node:fs';
+import path from 'node:path';
+
+const runtimeDir = path.resolve('.pixcode-dev', 'smoke-telegram-control');
+mkdirSync(runtimeDir, { recursive: true });
+process.env.DATABASE_PATH = path.join(runtimeDir, 'auth.db');
+
+const checks = [
+  {
+    name: 'telegram bot wires the remote control center and callback queries',
+    file: 'server/services/telegram/bot.js',
+    test: (source) => (
+      source.includes('handleTelegramControlMessage')
+      && source.includes('handleTelegramControlCallback')
+      && source.includes("bot.on('callback_query'")
+    ),
+  },
+  {
+    name: 'telegram HTTP client polls callback queries and can answer them',
+    file: 'server/services/telegram/telegram-http-client.js',
+    test: (source) => (
+      source.includes("allowed_updates: ['message', 'callback_query']")
+      && source.includes('answerCallbackQuery')
+      && source.includes('editMessageText')
+      && source.includes("this.emit('callback_query'")
+    ),
+  },
+  {
+    name: 'telegram control center exposes provider, model, workflow, install, and settings actions',
+    file: 'server/services/telegram/control-center.js',
+    test: (source) => (
+      source.includes('showMainMenu')
+      && source.includes('showProviderMenu')
+      && source.includes('showModelMenu')
+      && source.includes('showWorkflowMenu')
+      && source.includes('runWorkflow')
+      && source.includes('startCliInstall')
+      && source.includes('updateTelegramControlState')
+      && source.includes('/api/agent')
+      && source.includes('/api/orchestration/workflows')
+    ),
+  },
+  {
+    name: 'telegram link state persists remote-control preferences',
+    file: 'server/database/db.js',
+    test: (source) => (
+      source.includes('telegram_control')
+      && source.includes('getControlState')
+      && source.includes('updateControlState')
+      && source.includes('remoteControlEnabled')
+    ),
+  },
+  {
+    name: 'telegram settings UI exposes remote-control toggles',
+    file: 'src/components/settings/view/tabs/telegram-settings/TelegramSettingsTab.tsx',
+    test: (source) => (
+      source.includes('controlEnabled')
+      && source.includes('progressMode')
+      && source.includes('telegram.control.title')
+      && source.includes('telegram.control.progressMode')
+    ),
+  },
+];
+
+const failures = [];
+
+for (const check of checks) {
+  let source = '';
+  try {
+    source = readFileSync(check.file, 'utf8');
+  } catch {
+    failures.push(`${check.name} (${check.file} missing)`);
+    continue;
+  }
+
+  if (!check.test(source)) failures.push(check.name);
+}
+
+try {
+  const {
+    handleTelegramControlCallback,
+    handleTelegramControlMessage,
+  } = await import('../../server/services/telegram/control-center.js');
+  const {
+    handleIncomingTelegramMessage,
+    setTelegramBotForTesting,
+  } = await import('../../server/services/telegram/bot.js');
+  const { telegramLinksDb } = await import('../../server/database/db.js');
+
+  const userId = 4242;
+  telegramLinksDb.unlink(userId);
+  telegramLinksDb.setPairingCode(userId, '123456', new Date(Date.now() + 600_000).toISOString(), 'tr');
+  telegramLinksDb.verify(userId, 'chat-4242', 'ali');
+
+  const sent = [];
+  const bot = {
+    sendMessage: async (chatId, text, extra = {}) => {
+      sent.push({ chatId, text, extra });
+      return { ok: true };
+    },
+  };
+
+  const link = telegramLinksDb.getByUserId(userId);
+  const expectReply = async (input, expectedFragment) => {
+    sent.length = 0;
+    const handled = await handleTelegramControlMessage({
+      bot,
+      msg: { chat: { id: 4242 }, text: input },
+      link,
+    });
+    assert.equal(handled, true, `${input} should be handled`);
+    assert.ok(sent.length > 0, `${input} should send at least one reply`);
+    assert.ok(
+      sent[0].text.includes(expectedFragment),
+      `${input} should include "${expectedFragment}" but got "${sent[0].text}"`,
+    );
+  };
+
+  await expectReply('/start', 'Pixcode Telegram kontrol merkezi');
+  await expectReply('/help', 'Komutlar:');
+  await expectReply('/start@Otobot', 'Pixcode Telegram kontrol merkezi');
+  await expectReply('/help@Otobot', 'Komutlar:');
+  await expectReply('/', 'Komutlar:');
+
+  const menuEvents = [];
+  const menuBot = {
+    sendMessage: async (chatId, text, extra = {}) => {
+      menuEvents.push({ type: 'send', chatId, text, extra });
+      return { ok: true, message_id: 77 };
+    },
+    editMessageText: async (text, extra = {}) => {
+      menuEvents.push({ type: 'edit', text, extra });
+      return { ok: true, message_id: extra.message_id };
+    },
+    answerCallbackQuery: async () => ({ ok: true }),
+  };
+  const findButton = (markup, predicate) => {
+    for (const row of markup?.inline_keyboard || []) {
+      for (const candidate of row) {
+        if (predicate(candidate)) return candidate;
+      }
+    }
+    return null;
+  };
+
+  menuEvents.length = 0;
+  await handleTelegramControlMessage({
+    bot: menuBot,
+    msg: { chat: { id: 4242 }, text: '/settings' },
+    link,
+  });
+  const settingsMenu = menuEvents.at(-1);
+  const languageButton = findButton(
+    settingsMenu.extra.reply_markup,
+    (candidate) => /language|dil/i.test(candidate.text),
+  );
+  assert.ok(languageButton, 'settings menu should expose a language button');
+
+  menuEvents.length = 0;
+  await handleTelegramControlCallback({
+    bot: menuBot,
+    query: {
+      id: 'query-language-menu',
+      data: languageButton.callback_data,
+      message: { chat: { id: 4242 }, message_id: 77 },
+    },
+    link,
+  });
+  assert.equal(menuEvents.length, 1, 'callback menus should replace the existing menu message');
+  assert.equal(menuEvents[0].type, 'edit', 'callback menus should use editMessageText');
+  const trButton = findButton(menuEvents[0].extra.reply_markup, (candidate) => candidate.text === 'tr');
+  assert.ok(trButton, 'language menu should include Turkish');
+
+  menuEvents.length = 0;
+  await handleTelegramControlCallback({
+    bot: menuBot,
+    query: {
+      id: 'query-language-tr',
+      data: trButton.callback_data,
+      message: { chat: { id: 4242 }, message_id: 77 },
+    },
+    link,
+  });
+  assert.equal(telegramLinksDb.getByUserId(userId).language, 'tr', 'language selection should persist');
+  assert.equal(menuEvents.length, 1, 'language selection should not send a confirmation plus a second menu');
+  assert.equal(menuEvents[0].type, 'edit', 'language selection should replace the menu in place');
+  assert.ok(
+    menuEvents[0].text.includes('Pixcode Telegram kontrol merkezi'),
+    `Turkish menu should render after selection, got "${menuEvents[0].text}"`,
+  );
+  assert.ok(
+    !menuEvents[0].text.includes('Project:'),
+    'Turkish menu should not keep English summary labels after language selection',
+  );
+
+  const botLevelMessages = [];
+  setTelegramBotForTesting({
+    sendMessage: async (chatId, text, extra = {}) => {
+      botLevelMessages.push({ chatId, text, extra });
+      return { ok: true };
+    },
+    answerCallbackQuery: async () => ({ ok: true }),
+  });
+
+  const expectBotReply = async (input, expectedFragment) => {
+    botLevelMessages.length = 0;
+    await handleIncomingTelegramMessage({
+      chat: { id: 'chat-4242' },
+      text: input,
+      message_id: 1,
+      from: { username: 'ali' },
+    });
+    assert.ok(botLevelMessages.length > 0, `${input} should reply from bot.js`);
+    assert.ok(
+      botLevelMessages[0].text.includes(expectedFragment),
+      `${input} should include "${expectedFragment}" but got "${botLevelMessages[0].text}"`,
+    );
+    assert.ok(
+      !botLevelMessages.some((entry) => entry.text.includes('Mesaj son oturumuna iletildi')),
+      `${input} should never hit the bridge queue reply`,
+    );
+  };
+
+  await expectBotReply('/start', 'Nasıl başlarsın');
+  await expectBotReply('/help', 'Komutlar:');
+
+  telegramLinksDb.unlink(userId);
+} catch (error) {
+  failures.push(error?.message || String(error));
+} finally {
+  rmSync(runtimeDir, { recursive: true, force: true });
+}
+
+if (failures.length > 0) {
+  console.error(`Telegram control smoke failed:\n- ${failures.join('\n- ')}`);
+  process.exit(1);
+}
+
+console.log('telegram control smoke passed');

package/scripts/smoke/update-issue-progress.mjs

@@ -0,0 +1,69 @@
+#!/usr/bin/env node
+
+import assert from 'node:assert/strict';
+import { existsSync, readFileSync } from 'node:fs';
+
+const parserPath = 'src/components/version-upgrade/utils/releaseIssueProgress.ts';
+const componentPath = 'src/components/version-upgrade/view/ReleaseIssueProgress.tsx';
+const modalPath = 'src/components/version-upgrade/view/VersionUpgradeModal.tsx';
+const trackingPath = 'RELEASE_TRACKING_v1.37.md';
+
+assert.ok(existsSync(parserPath), 'Release issue progress parser should exist.');
+assert.ok(existsSync(componentPath), 'Release issue progress component should exist.');
+assert.ok(existsSync(trackingPath), 'v1.37 release tracking document should exist.');
+
+const parserSource = readFileSync(parserPath, 'utf8');
+assert.ok(
+  parserSource.includes('RELEASE_ISSUE_PROGRESS_MARKER'),
+  'Parser should expose a stable release-note marker for issue progress blocks.',
+);
+assert.ok(
+  parserSource.includes('extractIssueProgress'),
+  'Parser should export extractIssueProgress for release body parsing.',
+);
+assert.ok(
+  parserSource.includes('DEFAULT_V137_ISSUE_PROGRESS'),
+  'Parser should provide a v1.37 fallback issue map until the release body is published.',
+);
+assert.ok(
+  parserSource.includes('\\[([xX ~-])\\]') || parserSource.includes('[x]'),
+  'Parser should understand checked issue/task rows.',
+);
+
+const componentSource = readFileSync(componentPath, 'utf8');
+assert.ok(
+  componentSource.includes('extractIssueProgress'),
+  'Component should render parsed issue progress from release notes.',
+);
+assert.ok(
+  componentSource.includes('completedCount'),
+  'Component should summarize completed issue progress.',
+);
+assert.ok(
+  componentSource.includes("version?.startsWith('1.37')") || componentSource.includes('version.startsWith'),
+  'Component should only use the v1.37 fallback for v1.37 release notes.',
+);
+
+const modalSource = readFileSync(modalPath, 'utf8');
+assert.ok(
+  modalSource.includes('ReleaseIssueProgress'),
+  'Version modal should include release issue progress.',
+);
+assert.ok(
+  modalSource.includes('releaseInfo.body'),
+  'Version modal should pass release body text to the issue progress view.',
+);
+
+const trackingSource = readFileSync(trackingPath, 'utf8');
+for (const issueNumber of [6, 7, 8, 9, 10, 11, 12, 13, 14]) {
+  assert.ok(
+    trackingSource.includes(`#${issueNumber}`),
+    `Release tracking should mention issue #${issueNumber}.`,
+  );
+}
+assert.ok(
+  trackingSource.includes('<!-- pixcode:issue-progress -->'),
+  'Release tracking should include the issue-progress marker block used in release notes.',
+);
+
+console.log('update issue progress smoke passed');

package/scripts/smoke/version-modal-autoshow.mjs

@@ -0,0 +1,29 @@
+#!/usr/bin/env node
+
+import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+
+const source = readFileSync('src/components/sidebar/view/Sidebar.tsx', 'utf8');
+
+assert.ok(
+  source.includes('VERSION_RELEASE_NOTES_SEEN_KEY'),
+  'Sidebar should persist the latest equal-version release notes it auto-showed.',
+);
+assert.ok(
+  source.includes('localStorage.getItem(VERSION_RELEASE_NOTES_SEEN_KEY)'),
+  'Sidebar should read the seen release-notes version from localStorage.',
+);
+assert.ok(
+  source.includes('localStorage.setItem(VERSION_RELEASE_NOTES_SEEN_KEY, latestVersion)'),
+  'Sidebar should mark equal-version release notes as seen when auto-showing them.',
+);
+assert.ok(
+  source.includes('hasSeenCurrentReleaseNotes'),
+  'Sidebar should avoid auto-showing release notes when the current version was already seen.',
+);
+assert.ok(
+  source.includes('!hasSeenCurrentReleaseNotes'),
+  'The auto-show condition should be gated by the seen-version check.',
+);
+
+console.log('version modal autoshow smoke passed');

package/server/daemon-manager.js

@@ -95,15 +95,25 @@ function quoteSystemdArg(arg) {
     return `"${String(arg).replace(/(["\\$`])/g, '\\$1')}"`;
 }
 
-function resolveDaemonCliEntryPath(context = {}) {
+export function resolveDaemonCliEntryPath(context = {}) {
     const appRoot = context.appRoot || process.cwd();
     const explicitCliEntry = context.cliEntry ? path.resolve(context.cliEntry) : null;
     const argvCliEntry = process.argv[1] ? path.resolve(process.argv[1]) : null;
+    const distCliEntry = path.join(appRoot, 'dist-server', 'server', 'cli.js');
+    const sourceCliEntry = path.join(appRoot, 'server', 'cli.js');
+    const normalizeCliCandidate = (candidate) => {
+        if (!candidate) return null;
+        const resolved = path.resolve(candidate);
+        if (resolved === sourceCliEntry && fs.existsSync(distCliEntry)) {
+            return distCliEntry;
+        }
+        return resolved;
+    };
     const candidatePaths = [
-        explicitCliEntry,
-        argvCliEntry,
-        path.join(appRoot, 'dist-server', 'server', 'cli.js'),
-        path.join(appRoot, 'server', 'cli.js'),
+        normalizeCliCandidate(explicitCliEntry),
+        normalizeCliCandidate(argvCliEntry),
+        distCliEntry,
+        sourceCliEntry,
     ].filter(Boolean);
 
     const existingPath = candidatePaths.find(candidate => fs.existsSync(candidate));
@@ -111,7 +121,7 @@ function resolveDaemonCliEntryPath(context = {}) {
         return existingPath;
     }
 
-    return explicitCliEntry || argvCliEntry || path.join(appRoot, 'server', 'cli.js');
+    return normalizeCliCandidate(explicitCliEntry) || normalizeCliCandidate(argvCliEntry) || distCliEntry;
 }
 
 function hasPixcodeBinary() {
@@ -210,12 +220,7 @@ function parseDaemonArgs(args) {
 
 function buildDaemonExecStart({ appRoot, serverPort, databasePath, nodeExecPath, cliEntry }) {
     const nodeExec = nodeExecPath || process.execPath || 'node';
-    const cliCandidate = cliEntry
-        ? path.resolve(cliEntry)
-        : (process.argv[1] ? path.resolve(process.argv[1]) : path.join(appRoot, 'dist-server', 'server', 'cli.js'));
-    const resolvedCliEntry = fs.existsSync(cliCandidate)
-        ? cliCandidate
-        : path.join(appRoot, 'dist-server', 'server', 'cli.js');
+    const resolvedCliEntry = resolveDaemonCliEntryPath({ appRoot, cliEntry });
 
     const args = [nodeExec, resolvedCliEntry, 'start', '--port', String(serverPort)];
     if (databasePath) {