@pixelbyte-software/pixcode 1.36.4 → 1.38.0

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/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/v138-desktop-release-hardening.mjs

@@ -0,0 +1,69 @@
+#!/usr/bin/env node
+import fs from 'node:fs';
+
+function readText(path) {
+  return fs.readFileSync(path, 'utf8');
+}
+
+function readJson(path) {
+  return JSON.parse(readText(path));
+}
+
+function assertIncludes(path, patterns) {
+  const content = readText(path);
+  for (const pattern of patterns) {
+    if (!content.includes(pattern)) {
+      throw new Error(`${path} is missing required release-hardening text: ${pattern}`);
+    }
+  }
+}
+
+const rootPackage = readJson('package.json');
+const desktopPackage = readJson('desktop/package.json');
+const bundledPixcodeVersion = desktopPackage.dependencies?.['@pixelbyte-software/pixcode'];
+
+if (desktopPackage.version !== rootPackage.version) {
+  throw new Error(`desktop package version ${desktopPackage.version} does not match root ${rootPackage.version}`);
+}
+
+if (bundledPixcodeVersion !== rootPackage.version) {
+  throw new Error(`desktop bundled pixcode version ${bundledPixcodeVersion} does not match root ${rootPackage.version}`);
+}
+
+assertIncludes('README.md', [
+  'macOS Gatekeeper: "Pixcode is damaged"',
+  'Fix Gatekeeper.command',
+  'xattr -dr com.apple.quarantine',
+  'unsigned',
+]);
+
+assertIncludes('README.tr.md', [
+  'macOS Gatekeeper: "Pixcode hasar görmüş"',
+  'Fix Gatekeeper.command',
+  'xattr -dr com.apple.quarantine',
+  'imzalı/notarize değil',
+]);
+
+assertIncludes('desktop/README.md', [
+  'macOS Gatekeeper fix',
+  'Fix Gatekeeper.command',
+  'xattr -dr com.apple.quarantine',
+  'unsigned',
+]);
+
+assertIncludes('desktop/electron-builder.yml', [
+  'Pixcode-Setup-${version}.${ext}',
+  'Pixcode-${version}-${arch}.${ext}',
+  'target: AppImage',
+  'build-resources/Fix Gatekeeper.command',
+  'identity: null',
+]);
+
+assertIncludes('desktop/build-resources/Fix Gatekeeper.command', [
+  'Pixcode Gatekeeper Fix',
+  'xattr -cr "$APP_PATH"',
+  'com.apple.quarantine',
+  'open "$APP_PATH"',
+]);
+
+console.log('v1.38 desktop release hardening smoke passed');

package/scripts/smoke/v138-diagnostics.mjs

@@ -0,0 +1,63 @@
+#!/usr/bin/env node
+import { collectDiagnostics } from '../../server/services/diagnostics.js';
+
+const diagnostics = collectDiagnostics({
+  now: new Date('2026-05-10T00:00:00.000Z'),
+  env: {
+    NODE_ENV: 'test',
+    SERVER_PORT: '3001',
+    GITHUB_TOKEN: 'ghp_super_secret_value',
+    NPM_TOKEN: 'npm_super_secret_value',
+    TELEGRAM_BOT_TOKEN: 'telegram_super_secret_value',
+  },
+  uptime: 42,
+  memoryUsage: () => ({
+    rss: 10,
+    heapTotal: 20,
+    heapUsed: 5,
+    external: 1,
+    arrayBuffers: 0,
+  }),
+  versions: {
+    node: '22.0.0',
+    v8: '12.0.0',
+  },
+  platform: 'linux',
+  arch: 'x64',
+  installMode: 'git',
+  serverVersion: '1.38.0',
+  wsClientCount: 3,
+});
+
+const raw = JSON.stringify(diagnostics);
+for (const secret of ['ghp_super_secret_value', 'npm_super_secret_value', 'telegram_super_secret_value']) {
+  if (raw.includes(secret)) {
+    throw new Error(`diagnostics leaked secret value: ${secret}`);
+  }
+}
+
+if (diagnostics.status !== 'ok') {
+  throw new Error(`expected ok diagnostics status, got ${diagnostics.status}`);
+}
+
+if (diagnostics.timestamp !== '2026-05-10T00:00:00.000Z') {
+  throw new Error(`unexpected diagnostics timestamp ${diagnostics.timestamp}`);
+}
+
+if (diagnostics.version !== '1.38.0' || diagnostics.installMode !== 'git') {
+  throw new Error('diagnostics did not include injected version/install mode');
+}
+
+if (diagnostics.websocket.clients !== 3) {
+  throw new Error(`expected 3 websocket clients, got ${diagnostics.websocket.clients}`);
+}
+
+if (diagnostics.environment.GITHUB_TOKEN !== '[redacted]') {
+  throw new Error('GITHUB_TOKEN was not redacted');
+}
+
+if (diagnostics.environment.NODE_ENV !== 'test') {
+  throw new Error('safe environment value was not preserved');
+}
+
+console.log('v1.38 diagnostics smoke passed');

package/scripts/smoke/v138-issue-planner.mjs

@@ -0,0 +1,33 @@
+#!/usr/bin/env node
+import { buildPayload } from '../github/create-v1.38-issues.mjs';
+
+const payload = buildPayload();
+
+if (payload.version !== '1.38') {
+  throw new Error(`expected version 1.38, got ${payload.version}`);
+}
+
+if (!Array.isArray(payload.issues) || payload.issues.length !== 7) {
+  throw new Error(`expected 7 child issues, got ${payload.issues?.length}`);
+}
+
+if (!payload.epic || !payload.epic.title.includes('v1.38')) {
+  throw new Error('missing v1.38 epic payload');
+}
+
+const expectedKeys = ['remote', 'api', 'telegram', 'taskmaster', 'plugins', 'desktop', 'observability'];
+for (const key of expectedKeys) {
+  const issue = payload.issues.find(item => item.key === key);
+  if (!issue) {
+    throw new Error(`missing issue key ${key}`);
+  }
+  if (!issue.title || !issue.body.includes('## Acceptance Criteria')) {
+    throw new Error(`issue ${key} is missing title or acceptance criteria`);
+  }
+}
+
+if (!payload.trackingReplacements || payload.trackingReplacements.length !== 8) {
+  throw new Error('expected replacement plan for 7 issues plus epic');
+}
+
+console.log('v1.38 issue planner smoke passed');

package/server/database/db.js

@@ -493,7 +493,7 @@ const credentialsDb = {
 // Notification preferences
 // ---------------------------------------------------------------------------
 const DEFAULT_NOTIFICATION_PREFERENCES = {
-    channels: { inApp: false, webPush: false },
+    channels: { inApp: true, webPush: false, telegram: true, desktop: true },
     events: { actionRequired: true, stop: true, error: true, updates: true },
 };
 
@@ -501,8 +501,10 @@ const normalizeNotificationPreferences = (value) => {
     const source = value && typeof value === 'object' ? value : {};
     return {
         channels: {
-            inApp: source.channels?.inApp === true,
+            inApp: source.channels?.inApp !== false,
             webPush: source.channels?.webPush === true,
+            telegram: source.channels?.telegram !== false,
+            desktop: source.channels?.desktop !== false,
         },
         events: {
             actionRequired: source.events?.actionRequired !== false,

package/server/index.js

@@ -75,6 +75,7 @@ import geminiRoutes from './routes/gemini.js';
 import qwenRoutes from './routes/qwen.js';
 import pluginsRoutes from './routes/plugins.js';
 import messagesRoutes from './routes/messages.js';
+import diagnosticsRoutes from './routes/diagnostics.js';
 import providerRoutes from './modules/providers/provider.routes.js';
 import {
   createA2ARouter,
@@ -99,6 +100,7 @@ import {
 import { primeCliBinPath } from './services/install-jobs.js';
 import { startEnabledPluginServers, stopAllPlugins, getPluginPort } from './utils/plugin-process-manager.js';
 import { initializeDatabase, sessionNamesDb, applyCustomSessionNames } from './database/db.js';
+import { setNotificationWebSocketServer } from './services/notification-orchestrator.js';
 import { configureWebPush } from './services/vapid-keys.js';
 import { validateApiKey, authenticateToken, authenticateWebSocket } from './middleware/auth.js';
 import { IS_PLATFORM } from './constants/config.js';
@@ -319,6 +321,9 @@ const wss = new WebSocketServer({
 
 // Make WebSocket server available to routes
 app.locals.wss = wss;
+app.locals.installMode = installMode;
+app.locals.serverVersion = SERVER_VERSION;
+setNotificationWebSocketServer(wss);
 
 app.use(cors({ exposedHeaders: ['X-Refreshed-Token'] }));
 app.use(express.json({
@@ -389,6 +394,9 @@ app.use('/api/plugins', authenticateToken, pluginsRoutes);
 // Unified session messages route (protected)
 app.use('/api/sessions', authenticateToken, messagesRoutes);
 
+// Diagnostics API Routes (protected)
+app.use('/api/diagnostics', authenticateToken, diagnosticsRoutes);
+
 // Unified provider MCP routes (protected)
 app.use('/api/providers', authenticateToken, providerRoutes);
 
@@ -1813,6 +1821,7 @@ function handleChatConnection(ws, request) {
     console.log('[INFO] Chat WebSocket connected');
 
     // Add to connected clients for project updates
+    ws.userId = request?.user?.id ?? request?.user?.userId ?? null;
     connectedClients.add(ws);
 
     // Wrap WebSocket with writer for consistent interface with SSEStreamWriter

package/server/modules/orchestration/tasks/orchestration-task.routes.ts

@@ -48,11 +48,20 @@ export function createOrchestrationTaskRouter(): Router {
     try {
       const adapterId = typeof req.body?.adapterId === 'string' ? req.body.adapterId : '';
       const isolation = req.body?.isolation;
+      const projectPath = typeof req.body?.projectPath === 'string' ? req.body.projectPath : undefined;
+      const model = typeof req.body?.model === 'string' ? req.body.model : undefined;
+      const permissionMode = typeof req.body?.permissionMode === 'string' ? req.body.permissionMode : undefined;
       if (!adapterId) {
         res.status(400).json({ error: { code: 'ADAPTER_REQUIRED', message: 'adapterId is required' } });
         return;
       }
-      const task = await orchestrationTaskService.dispatch(req.params.id, { adapterId, isolation });
+      const task = await orchestrationTaskService.dispatch(req.params.id, {
+        adapterId,
+        isolation,
+        projectPath,
+        model,
+        permissionMode,
+      });
       res.json(task);
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);

package/server/modules/orchestration/tasks/orchestration-task.service.ts

@@ -71,6 +71,12 @@ class OrchestrationTaskService {
         },
         metadata: {
           isolation: input.isolation ?? 'worktree',
+          model: input.model,
+          permissionMode: input.permissionMode,
+          workspace: {
+            kind: input.isolation ?? 'worktree',
+            projectPath: input.projectPath,
+          },
           orchestrationTaskId: task.id,
           taskmasterId: task.taskmasterId,
         },
@@ -86,6 +92,7 @@ class OrchestrationTaskService {
     task.adapterId = input.adapterId;
     task.adapterSelector = input.adapterId;
     task.workspaceKind = input.isolation ?? 'worktree';
+    task.workspacePath = input.projectPath;
     task.state = 'in_progress';
     task.updatedAt = Date.now();
     this.store.set(task);

package/server/modules/orchestration/tasks/orchestration-task.types.ts

@@ -26,4 +26,7 @@ export interface CreateOrchestrationTaskInput {
 export interface DispatchOrchestrationTaskInput {
   adapterId: string;
   isolation?: 'host' | 'worktree' | 'docker';
+  projectPath?: string;
+  model?: string;
+  permissionMode?: string;
 }

package/server/modules/orchestration/workflows/workflow-runner.ts

@@ -299,6 +299,56 @@ function handoffPrompt(agent: AgentAssignment, role: AgentRole): string {
   ].filter(Boolean).join('\n');
 }
 
+function handoffInitPrompt(agent: AgentAssignment, index: number): string {
+  return [
+    `You are preparing ${agent.label} for a strict Pixcode handoff chain.`,
+    `This is internal step ${index + 1}.`,
+    'Create a compact init packet for the next visible work step.',
+    'Use the original user goal and any prior compact handoff packet included above.',
+    agent.instruction ? `The explicit assignment for this agent is: ${agent.instruction}` : '',
+    'Output only this internal init packet:',
+    '- user goal in one sentence',
+    '- prior agent handoff summary, if present',
+    '- this agent responsibility',
+    '- exact constraints and blockers this agent must respect',
+    privacyGuardPrompt(),
+    'Do not perform the task yet. Do not mention that this is hidden from the user.',
+    'Respond in the same language as the user request.',
+  ].filter(Boolean).join('\n');
+}
+
+function handoffWorkPrompt(agent: AgentAssignment, index: number): string {
+  return [
+    `You are ${agent.label} in a strict Pixcode handoff chain.`,
+    `This is visible work step ${index + 1}.`,
+    'The internal init packet above is your starting context. Do the assigned work now.',
+    agent.instruction
+      ? `Your explicit assignment from the user is: ${agent.instruction}`
+      : 'Use the init packet and original user goal to choose the next useful work for this step.',
+    rolePrompt(agent.role ?? 'implementation'),
+    privacyGuardPrompt(),
+    'Report only user-facing progress, changed files, commands, verification, blockers, and next actions.',
+    'Respond in the same language as the user request.',
+  ].filter(Boolean).join('\n');
+}
+
+function handoffCompactPrompt(agent: AgentAssignment, index: number): string {
+  return [
+    `You are compacting ${agent.label}'s strict handoff output for the next Pixcode agent.`,
+    `This is internal compact step ${index + 1}.`,
+    'Read the prior visible work output included above and create a compact handoff packet.',
+    'Output only this internal compact packet:',
+    '- Ben ne yaptım / What I did',
+    '- Dokunduğum alanlar / Touched areas',
+    '- Kanıt, komut veya çıktı / Evidence, commands, outputs',
+    '- Sonraki ajan şunu bilsin / What the next agent must know',
+    '- Bloker veya risk / Blockers or risks',
+    privacyGuardPrompt(),
+    'Do not include raw logs unless they are essential. Keep it concise and actionable.',
+    'Respond in the same language as the user request.',
+  ].join('\n');
+}
+
 function compactOutputForContext(text: string): string {
   if (text.length <= MAX_OUTPUT_CONTEXT_CHARS) {
     return text;
@@ -595,32 +645,89 @@ function expandSequentialHandoffWorkflow(workflow: Workflow, metadata?: Record<s
     throw new Error('Select at least one CLI agent.');
   }
 
+  const nodes: WorkflowNode[] = agents.flatMap((agent, index): WorkflowNode[] => {
+    const initNodeId = safeAgentNodeId(agent, index, 'init');
+    const workNodeId = safeAgentNodeId(agent, index, 'work');
+    const compactNodeId = safeAgentNodeId(agent, index, 'compact');
+
+    return [
+      {
+        id: initNodeId,
+        adapterId: agent.adapterId,
+        agentInstanceId: agent.instanceId,
+        agentLabel: `${agent.label} Init`,
+        assignment: agent.instruction,
+        stage: 'handoff_init',
+        model: agent.model,
+        permissionMode: agent.permissionMode,
+        toolsSettings: agent.toolsSettings,
+        prompt: handoffInitPrompt(agent, index),
+        inputs: index === 0 ? [] : [safeAgentNodeId(agents[index - 1], index - 1, 'compact')],
+        output: 'message',
+        onFail: 'abort',
+        internal: true,
+      },
+      {
+        id: workNodeId,
+        adapterId: agent.adapterId,
+        agentInstanceId: agent.instanceId,
+        agentLabel: agent.label,
+        assignment: agent.instruction,
+        stage: agent.role ?? 'implementation',
+        model: agent.model,
+        permissionMode: agent.permissionMode,
+        toolsSettings: agent.toolsSettings,
+        prompt: handoffWorkPrompt(agent, index),
+        inputs: [initNodeId],
+        output: 'both',
+        onFail: 'abort',
+      },
+      {
+        id: compactNodeId,
+        adapterId: agent.adapterId,
+        agentInstanceId: agent.instanceId,
+        agentLabel: `${agent.label} Compact`,
+        assignment: agent.instruction,
+        stage: 'handoff_compact',
+        model: agent.model,
+        permissionMode: agent.permissionMode,
+        toolsSettings: agent.toolsSettings,
+        prompt: handoffCompactPrompt(agent, index),
+        inputs: [workNodeId],
+        output: 'message',
+        onFail: 'abort',
+        internal: true,
+      },
+    ];
+  });
+  const reportAgent = agents[0];
+  const lastCompactNodeId = safeAgentNodeId(agents[agents.length - 1], agents.length - 1, 'compact');
+
   return {
     ...workflow,
-    nodes: agents.map((agent, index): WorkflowNode => ({
-      id: safeAgentNodeId(agent, index, 'handoff'),
-      adapterId: agent.adapterId,
-      agentInstanceId: agent.instanceId,
-      agentLabel: agent.label,
-      assignment: agent.instruction,
-      stage: agent.role ?? 'implementation',
-      model: agent.model,
-      permissionMode: agent.permissionMode,
-      toolsSettings: agent.toolsSettings,
-      prompt: [
-        `You are ${agent.label} in a sequential Pixcode handoff.`,
-        `This is step ${index + 1} of ${agents.length}.`,
-        agent.instruction
-          ? `Your explicit assignment from the user is: ${agent.instruction}`
-          : 'Use the prior step output and do the next most useful handoff step for the user goal.',
-        'Report changed files, commands, blockers, and the next handoff requirement.',
-        privacyGuardPrompt(),
-        'Respond in the same language as the user request.',
-      ].filter(Boolean).join('\n'),
-      inputs: index === 0 ? [] : [safeAgentNodeId(agents[index - 1], index - 1, 'handoff')],
-      output: 'both',
-      onFail: 'abort',
-    })),
+    nodes: [
+      ...nodes,
+      {
+        id: 'final_report',
+        adapterId: reportAgent.adapterId,
+        agentInstanceId: reportAgent.instanceId,
+        agentLabel: reportAgent.label,
+        stage: 'final_report',
+        model: reportAgent.model,
+        permissionMode: reportAgent.permissionMode,
+        toolsSettings: reportAgent.toolsSettings,
+        prompt: [
+          'Create the final user-facing result for this strict handoff run.',
+          'Use the final compact handoff packet and the original user goal.',
+          'Summarize what each visible agent did, what changed, verification, blockers, and next actions.',
+          'Do not expose internal init packets, compact packets, prompts, memory lookup, skill/tool instructions, raw agent logs, or role prefixes like "agent:" and "user:".',
+          'Respond in the same language as the user request.',
+        ].join('\n'),
+        inputs: [lastCompactNodeId],
+        output: 'message',
+        onFail: 'abort',
+      },
+    ],
   };
 }
 
@@ -772,6 +879,7 @@ function nodeRunFromNode(node: WorkflowNode): WorkflowNodeRun {
     permissionMode: node.permissionMode,
     timeoutMs: node.timeoutMs,
     stage: node.stage,
+    internal: node.internal,
     status: 'queued',
   };
 }

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

@@ -17,6 +17,7 @@ export interface WorkflowNode {
   toolsSettings?: Record<string, unknown>;
   isolation?: 'host' | 'worktree' | 'docker';
   timeoutMs?: number;
+  internal?: boolean;
 }
 
 export interface Workflow {
@@ -38,6 +39,7 @@ export interface WorkflowNodeRun {
   permissionMode?: string;
   timeoutMs?: number;
   stage?: string;
+  internal?: boolean;
   status: WorkflowNodeStatus;
   a2aTaskId?: string;
   startedAt?: number;

package/server/routes/diagnostics.js

@@ -0,0 +1,15 @@
+import express from 'express';
+
+import { collectDiagnostics } from '../services/diagnostics.js';
+
+const router = express.Router();
+
+router.get('/', (req, res) => {
+  res.json(collectDiagnostics({
+    installMode: req.app.locals.installMode,
+    serverVersion: req.app.locals.serverVersion,
+    wss: req.app.locals.wss,
+  }));
+});
+
+export default router;