@pixelbyte-software/pixcode 1.34.0 → 1.35.0

package/scripts/smoke/orchestration-live-run.mjs

@@ -0,0 +1,176 @@
+#!/usr/bin/env node
+
+const baseUrl = process.env.PIXCODE_BASE_URL || 'http://127.0.0.1:3001';
+const apiKey = process.env.PIXCODE_API_KEY;
+const goal = process.env.PIXCODE_LIVE_GOAL;
+const timeoutMs = Number.parseInt(process.env.PIXCODE_LIVE_TIMEOUT_MS || '1200000', 10);
+const minAgentOutputs = Number.parseInt(process.env.PIXCODE_LIVE_MIN_AGENT_OUTPUTS || '2', 10);
+const workflowId = process.env.PIXCODE_LIVE_WORKFLOW_ID || 'agent_team';
+
+if (!apiKey) {
+  console.error('PIXCODE_API_KEY is required.');
+  process.exit(1);
+}
+
+if (!goal) {
+  console.error('PIXCODE_LIVE_GOAL is required.');
+  process.exit(1);
+}
+
+function parseJsonEnv(name) {
+  const raw = process.env[name];
+  if (!raw) {
+    throw new Error(`${name} is required.`);
+  }
+  try {
+    return JSON.parse(raw);
+  } catch (error) {
+    throw new Error(`${name} is not valid JSON: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+
+function assert(condition, message) {
+  if (!condition) throw new Error(message);
+}
+
+function headers(extra = {}) {
+  return {
+    authorization: `Bearer ${apiKey}`,
+    'content-type': 'application/json',
+    ...extra,
+  };
+}
+
+async function request(path, options = {}) {
+  const response = await fetch(`${baseUrl}${path}`, {
+    ...options,
+    headers: headers(options.headers || {}),
+  });
+  const text = await response.text();
+  const body = text ? JSON.parse(text) : null;
+  if (!response.ok) {
+    throw new Error(`${options.method || 'GET'} ${path} failed: ${response.status} ${text}`);
+  }
+  return body;
+}
+
+function terminal(status) {
+  return status === 'completed' || status === 'failed' || status === 'canceled';
+}
+
+function agentTextCount(run) {
+  return (run.nodeRuns || []).filter((node) =>
+    (node.messages || []).some((message) => message.role !== 'user' && message.text?.trim()) ||
+    Boolean(node.outputText?.trim()),
+  ).length;
+}
+
+function compactNodes(run) {
+  return (run.nodeRuns || []).map((node) => ({
+    nodeId: node.nodeId,
+    label: node.agentLabel,
+    status: node.status,
+    taskId: node.a2aTaskId,
+    messageCount: (node.messages || []).filter((message) => message.role !== 'user').length,
+    hasOutput: Boolean(node.outputText?.trim()),
+    error: node.error,
+  }));
+}
+
+async function cancelRun(runId) {
+  try {
+    await request(`/api/orchestration/workflows/runs/${encodeURIComponent(runId)}/cancel`, {
+      method: 'POST',
+      body: '{}',
+    });
+  } catch {
+    // Best-effort cleanup only.
+  }
+}
+
+async function main() {
+  const agents = parseJsonEnv('PIXCODE_LIVE_AGENTS_JSON');
+  assert(Array.isArray(agents) && agents.length > 0, 'PIXCODE_LIVE_AGENTS_JSON must be a non-empty array.');
+
+  const settings = process.env.PIXCODE_LIVE_SETTINGS_JSON
+    ? JSON.parse(process.env.PIXCODE_LIVE_SETTINGS_JSON)
+    : {};
+  const metadata = {
+    agents,
+    projectPath: process.env.PIXCODE_LIVE_PROJECT_PATH,
+    projectId: process.env.PIXCODE_LIVE_PROJECT_ID,
+    settings: {
+      maxParallelAgents: Number.parseInt(process.env.PIXCODE_LIVE_MAX_PARALLEL || '3', 10),
+      isolation: process.env.PIXCODE_LIVE_ISOLATION || 'host',
+      keepWorkspace: process.env.PIXCODE_LIVE_KEEP_WORKSPACE !== 'false',
+      ...settings,
+    },
+  };
+
+  const preview = await request(`/api/orchestration/workflows/${encodeURIComponent(workflowId)}/preview`, {
+    method: 'POST',
+    body: JSON.stringify({ metadata }),
+  });
+  assert(preview.nodeCount >= agents.length + 1, 'Preview did not expand enough nodes for the requested agents.');
+  console.log(JSON.stringify({ event: 'preview', nodeIds: preview.nodes.map((node) => node.id) }));
+
+  const started = await request(`/api/orchestration/workflows/${encodeURIComponent(workflowId)}/runs`, {
+    method: 'POST',
+    body: JSON.stringify({ input: goal, metadata }),
+  });
+  const runId = started.id;
+  assert(runId, 'Run id missing from start response.');
+  console.log(JSON.stringify({ event: 'started', runId, contextId: started.contextId }));
+
+  const deadline = Date.now() + timeoutMs;
+  let lastSignature = '';
+  let latest = started;
+  while (!terminal(latest.status) && Date.now() < deadline) {
+    await new Promise((resolve) => setTimeout(resolve, 5000));
+    latest = await request(`/api/orchestration/workflows/runs/${encodeURIComponent(runId)}`);
+    const nodes = compactNodes(latest);
+    const signature = JSON.stringify(nodes.map((node) => [
+      node.nodeId,
+      node.status,
+      node.messageCount,
+      node.hasOutput,
+      node.error,
+    ]));
+    if (signature !== lastSignature) {
+      lastSignature = signature;
+      console.log(JSON.stringify({
+        event: 'progress',
+        status: latest.status,
+        agentOutputs: agentTextCount(latest),
+        nodes,
+      }));
+    }
+  }
+
+  if (!terminal(latest.status)) {
+    await cancelRun(runId);
+    throw new Error(`Run ${runId} did not finish before ${timeoutMs}ms; canceled.`);
+  }
+
+  const outputCount = agentTextCount(latest);
+  if (outputCount < minAgentOutputs) {
+    throw new Error(`Expected at least ${minAgentOutputs} nodes with agent output; got ${outputCount}.`);
+  }
+
+  if (latest.status !== 'completed') {
+    throw new Error(`Run ended with ${latest.status}: ${JSON.stringify(compactNodes(latest))}`);
+  }
+
+  console.log(JSON.stringify({
+    event: 'completed',
+    runId,
+    contextId: latest.contextId,
+    outputCount,
+    nodes: compactNodes(latest),
+  }, null, 2));
+}
+
+main().catch((error) => {
+  console.error(error instanceof Error ? error.message : String(error));
+  process.exit(1);
+});

package/server/claude-sdk.js

@@ -12,12 +12,13 @@
  * - WebSocket message streaming
  */
 
-import { query } from '@anthropic-ai/claude-agent-sdk';
 import crypto from 'crypto';
-import { promises as fs } from 'fs';
+import { existsSync, readFileSync, promises as fs } from 'fs';
 import path from 'path';
 import os from 'os';
-import { CLAUDE_MODELS } from '../shared/modelConstants.js';
+
+import { query } from '@anthropic-ai/claude-agent-sdk';
+
 import {
   createNotificationEvent,
   notifyRunFailed,
@@ -140,6 +141,43 @@ function matchesToolPermission(entry, toolName, input) {
   return false;
 }
 
+function readClaudeSettingsEnv(filePath) {
+  try {
+    if (!existsSync(filePath)) return {};
+    const parsed = JSON.parse(readFileSync(filePath, 'utf8'));
+    const env = parsed?.env;
+    if (!env || typeof env !== 'object') return {};
+
+    return Object.fromEntries(
+      Object.entries(env)
+        .filter(([key, value]) =>
+          typeof value === 'string' &&
+          value.trim() &&
+          !key.startsWith('//'),
+        ),
+    );
+  } catch {
+    return {};
+  }
+}
+
+function loadClaudeSettingsEnv(cwd) {
+  const files = [
+    path.join(os.homedir(), '.claude', 'settings.json'),
+  ];
+  if (cwd) {
+    files.push(
+      path.join(cwd, '.claude', 'settings.json'),
+      path.join(cwd, '.claude', 'settings.local.json'),
+    );
+  }
+
+  return files.reduce((env, filePath) => ({
+    ...env,
+    ...readClaudeSettingsEnv(filePath),
+  }), {});
+}
+
 /**
  * Maps CLI options to SDK-compatible options format
  * @param {Object} options - CLI options
@@ -154,7 +192,7 @@ function mapCliOptionsToSDK(options = {}) {
   // Since claude-agent-sdk 0.2.113+, options.env REPLACES process.env in the subprocess
   // instead of overlaying it. Without spreading process.env here, users who rely on
   // ANTHROPIC_BASE_URL, HTTP(S)_PROXY, etc. would silently lose those settings.
-  sdkOptions.env = { ...process.env };
+  sdkOptions.env = { ...process.env, ...loadClaudeSettingsEnv(cwd) };
 
   // Claude Code on Windows hard-requires a POSIX bash (typically from Git
   // for Windows) and reads its path from CLAUDE_CODE_GIT_BASH_PATH. If the
@@ -228,9 +266,12 @@ function mapCliOptionsToSDK(options = {}) {
 
   sdkOptions.disallowedTools = settings.disallowedTools || [];
 
-  // Map model (default to sonnet)
-  // Valid models: sonnet, opus, haiku, opusplan, sonnet[1m]
-  sdkOptions.model = options.model || CLAUDE_MODELS.DEFAULT;
+  // Map model only when Pixcode explicitly passes one. If omitted, let
+  // Claude Code load the user's own project/user/local settings, including
+  // ~/.claude/settings.json "model".
+  if (typeof options.model === 'string' && options.model.trim()) {
+    sdkOptions.model = options.model.trim();
+  }
   // Model logged at query start below
 
   // Map system prompt configuration

package/server/cli.js

@@ -185,7 +185,7 @@ Examples:
   $ pixcode --port 8080            # Start on port 8080
   $ pixcode --no-daemon            # Force foreground mode
   $ sudo pixcode daemon install --mode system --port 3001
-  $ pixcode daemon install --mode user --port 3001 --frontend-port 5173
+  $ pixcode daemon install --mode user --port 3001 --single-port
   $ pixcode daemon doctor --mode system
   $ pixcode update --restart-daemon
   $ pixcode sandbox ~/my-project   # Run in a Docker sandbox
@@ -696,9 +696,8 @@ function printSystemDaemonActiveNotice(port) {
     console.log(`${c.info('[INFO]')} Logs: ${c.bright(logsCommand)}`);
 }
 
-function printUserDaemonActiveNotice(port, frontendPort) {
+function printUserDaemonActiveNotice(port) {
     const effectivePort = Number(port) || 3001;
-    const effectiveFrontendPort = Number(frontendPort) || 5173;
     const statusCommand = buildDaemonCliCommand(
         { subcommand: 'status', mode: 'user' },
         DAEMON_COMMAND_CONTEXT
@@ -712,8 +711,7 @@ function printUserDaemonActiveNotice(port, frontendPort) {
         DAEMON_COMMAND_CONTEXT
     );
     console.log(`${c.ok('[OK]')} User daemon is active for this account.`);
-    console.log(`${c.info('[INFO]')} Backend: ${c.bright(`http://localhost:${effectivePort}`)}`);
-    console.log(`${c.info('[INFO]')} Frontend: ${c.bright(`http://localhost:${effectiveFrontendPort}`)}`);
+    console.log(`${c.info('[INFO]')} UI: ${c.bright(`http://localhost:${effectivePort}`)}`);
     console.log(`${c.info('[INFO]')} Status: ${c.bright(statusCommand)}`);
     console.log(`${c.info('[INFO]')} Stop: ${c.bright(stopCommand)}`);
     console.log(`${c.info('[INFO]')} Logs: ${c.bright(logsCommand)}`);
@@ -725,7 +723,7 @@ function isSystemPermissionError(error) {
     return /(access denied|permission denied|must be root|interactive authentication required|not permitted|failed to connect to bus|operation not permitted|authentication is required|polkit)/i.test(message);
 }
 
-function buildAutoInstallArgs(mode, options, frontendPort) {
+function buildAutoInstallArgs(mode, options) {
     const args = ['install', `--mode=${mode}`];
     if (options.serverPort) {
         args.push('--port', String(options.serverPort));
@@ -733,9 +731,7 @@ function buildAutoInstallArgs(mode, options, frontendPort) {
     if (options.databasePath) {
         args.push('--database-path', String(options.databasePath));
     }
-    if (frontendPort) {
-        args.push('--frontend-port', String(frontendPort));
-    }
+    args.push('--single-port');
     return args;
 }
 
@@ -748,9 +744,8 @@ async function maybeAutoDaemonStart(options = {}) {
 
     process.env.PIXCODE_DAEMON_ATTEMPTED = '1';
     const daemonPort = Number(options.serverPort || process.env.SERVER_PORT || process.env.PORT || '3001');
-    const frontendPort = Number(process.env.VITE_PORT || '5173');
-    const systemArgs = buildAutoInstallArgs('system', options, frontendPort);
-    const userArgs = buildAutoInstallArgs('user', options, frontendPort);
+    const systemArgs = buildAutoInstallArgs('system', options);
+    const userArgs = buildAutoInstallArgs('user', options);
 
     try {
         console.log(`${c.info('[INFO]')} Linux detected. Enforcing system daemon mode for Pixcode...`);
@@ -773,7 +768,7 @@ async function maybeAutoDaemonStart(options = {}) {
                 {
                     subcommand: 'install',
                     mode: 'system',
-                    extraArgs: ['--port', String(daemonPort), '--frontend-port', String(frontendPort)],
+                    extraArgs: ['--port', String(daemonPort), '--single-port'],
                 },
                 DAEMON_COMMAND_CONTEXT
             );
@@ -793,20 +788,20 @@ async function maybeAutoDaemonStart(options = {}) {
                 defaultPort: process.env.SERVER_PORT || process.env.PORT || '3001',
                 color: c,
             });
-            printUserDaemonActiveNotice(daemonPort, frontendPort);
+            printUserDaemonActiveNotice(daemonPort);
             return true;
         } catch (userError) {
             const userHealthySoon = await waitForPortOpen(daemonPort);
             if (userHealthySoon) {
                 console.log(`${c.warn('[WARN]')} User daemon health check was delayed, but port ${daemonPort} is now reachable.`);
-                printUserDaemonActiveNotice(daemonPort, frontendPort);
+                printUserDaemonActiveNotice(daemonPort);
                 return true;
             }
             const installSystemCommand = buildDaemonCliCommand(
                 {
                     subcommand: 'install',
                     mode: 'system',
-                    extraArgs: ['--port', String(daemonPort), '--frontend-port', String(frontendPort)],
+                    extraArgs: ['--port', String(daemonPort), '--single-port'],
                 },
                 DAEMON_COMMAND_CONTEXT
             );
@@ -814,7 +809,7 @@ async function maybeAutoDaemonStart(options = {}) {
                 {
                     subcommand: 'install',
                     mode: 'user',
-                    extraArgs: ['--port', String(daemonPort), '--frontend-port', String(frontendPort)],
+                    extraArgs: ['--port', String(daemonPort), '--single-port'],
                 },
                 DAEMON_COMMAND_CONTEXT
             );

package/server/daemon-manager.js

@@ -187,6 +187,8 @@ function parseDaemonArgs(args) {
             parsed.options.frontendPort = args[++i];
         } else if (arg.startsWith('--frontend-port=')) {
             parsed.options.frontendPort = arg.split('=')[1];
+        } else if (arg === '--no-frontend' || arg === '--single-port') {
+            parsed.options.noFrontend = true;
         } else if (arg === '--mode' || arg === '-m') {
             parsed.options.mode = (args[++i] || '').toLowerCase();
         } else if (arg.startsWith('--mode=')) {
@@ -512,7 +514,7 @@ function showDaemonHelp(c, context = {}) {
         {
             subcommand: 'install',
             mode: 'system',
-            extraArgs: ['--port', '3001', '--frontend-port', '5173'],
+            extraArgs: ['--port', '3001', '--single-port'],
         },
         context
     );
@@ -540,7 +542,9 @@ Subcommands:
 
 Options:
   -p, --port <port>           Set service server port (default: 3001)
-  --frontend-port <port>      Set frontend Vite port (default: 5173)
+  --frontend-port <port>      Start a separate frontend Vite service on this port (legacy/dev)
+  --single-port, --no-frontend
+                              Serve the built UI from the backend port only (default)
   -m, --mode <mode>           Service mode: user | system | auto (default: system)
   --database-path <path>      Set service database path
 
@@ -592,6 +596,8 @@ export async function handleDaemonCommand(args, context = {}) {
     const defaultFrontendPort = context.defaultFrontendPort || process.env.VITE_PORT || String(DEFAULT_FRONTEND_PORT);
     const configuredPort = parsed.options.serverPort || defaultPort;
     const configuredFrontendPort = parsed.options.frontendPort || defaultFrontendPort;
+    const frontendEnabled = parsed.options.noFrontend !== true &&
+        (Boolean(parsed.options.frontendPort) || process.env.PIXCODE_SEPARATE_FRONTEND === '1');
     const databasePath = parsed.options.databasePath || process.env.DATABASE_PATH || '';
 
     const portNum = Number(configuredPort);
@@ -599,7 +605,7 @@ export async function handleDaemonCommand(args, context = {}) {
         throw new Error(`Invalid port "${configuredPort}". Expected an integer between 1 and 65535.`);
     }
     const frontendPortNum = Number(configuredFrontendPort);
-    if (!Number.isInteger(frontendPortNum) || frontendPortNum < 1 || frontendPortNum > 65535) {
+    if (frontendEnabled && (!Number.isInteger(frontendPortNum) || frontendPortNum < 1 || frontendPortNum > 65535)) {
         throw new Error(`Invalid frontend port "${configuredFrontendPort}". Expected an integer between 1 and 65535.`);
     }
 
@@ -632,9 +638,13 @@ export async function handleDaemonCommand(args, context = {}) {
         const systemUnitInstalled = fs.existsSync(getDaemonServicePath('system'));
         const systemFrontendUnitInstalled = fs.existsSync(getFrontendServicePath('system'));
         const selectedModePort = getPortFromServiceUnit(servicePath) || portNum;
-        const selectedModeFrontendPort = getPortFromServiceUnit(frontendServicePath) || frontendPortNum;
+        const selectedModeFrontendPort = frontendEnabled
+            ? getPortFromServiceUnit(frontendServicePath) || frontendPortNum
+            : undefined;
         const portReachable = await isPortReachable(selectedModePort);
-        const frontendPortReachable = await isPortReachable(selectedModeFrontendPort);
+        const frontendPortReachable = selectedModeFrontendPort
+            ? await isPortReachable(selectedModeFrontendPort)
+            : false;
         const userState = userBus.ok
             ? {
                 backend: getServiceState('user', DAEMON_SERVICE_NAME),
@@ -667,7 +677,10 @@ export async function handleDaemonCommand(args, context = {}) {
         console.log(`${c.info('[INFO]')} user state:     backend active=${c.bright(userState.backend.active)} enabled=${c.bright(userState.backend.enabled)} | frontend active=${c.bright(userState.frontend.active)} enabled=${c.bright(userState.frontend.enabled)}`);
         console.log(`${c.info('[INFO]')} system state:   backend active=${c.bright(systemState.backend.active)} enabled=${c.bright(systemState.backend.enabled)} | frontend active=${c.bright(systemState.frontend.active)} enabled=${c.bright(systemState.frontend.enabled)}`);
         console.log(`${c.info('[INFO]')} backend port:   ${c.bright(String(selectedModePort))} (${portReachable ? c.ok('reachable') : c.warn('not reachable')})`);
-        console.log(`${c.info('[INFO]')} frontend port:  ${c.bright(String(selectedModeFrontendPort))} (${frontendPortReachable ? c.ok('reachable') : c.warn('not reachable')})`);
+        console.log(`${c.info('[INFO]')} frontend mode:  ${frontendEnabled ? c.bright('separate Vite service') : c.bright('single backend port')}`);
+        if (frontendEnabled) {
+            console.log(`${c.info('[INFO]')} frontend port:  ${c.bright(String(selectedModeFrontendPort))} (${frontendPortReachable ? c.ok('reachable') : c.warn('not reachable')})`);
+        }
         if (lastErrorLine) {
             console.log(`${c.warn('[WARN]')} Latest error:   ${lastErrorLine}`);
         }
@@ -691,20 +704,17 @@ export async function handleDaemonCommand(args, context = {}) {
         console.log(`SYSTEM_FRONTEND_ENABLED=${systemState.frontend.enabled}`);
         console.log(`BACKEND_PORT=${selectedModePort}`);
         console.log(`BACKEND_PORT_REACHABLE=${portReachable}`);
-        console.log(`FRONTEND_PORT=${selectedModeFrontendPort}`);
+        console.log(`FRONTEND_ENABLED=${frontendEnabled}`);
+        console.log(`FRONTEND_PORT=${selectedModeFrontendPort ?? ''}`);
         console.log(`FRONTEND_PORT_REACHABLE=${frontendPortReachable}`);
         console.log(`LAST_ERROR_LINE=${JSON.stringify(lastErrorLine || '')}\n`);
         return;
     }
 
-    const serviceDefs = [
-        {
-            servicePath,
-        },
-        {
-            servicePath: frontendServicePath,
-        },
-    ];
+    const serviceDefs = [{ servicePath }];
+    if (frontendEnabled) {
+        serviceDefs.push({ servicePath: frontendServicePath });
+    }
 
     switch (parsed.subcommand) {
         case 'install': {
@@ -714,7 +724,9 @@ export async function handleDaemonCommand(args, context = {}) {
 
             try {
                 fs.mkdirSync(path.dirname(servicePath), { recursive: true });
-                fs.mkdirSync(path.dirname(frontendServicePath), { recursive: true });
+                if (frontendEnabled) {
+                    fs.mkdirSync(path.dirname(frontendServicePath), { recursive: true });
+                }
 
                 const backendUnitContent = buildDaemonServiceUnit({
                     appRoot,
@@ -725,20 +737,24 @@ export async function handleDaemonCommand(args, context = {}) {
                 });
                 fs.writeFileSync(servicePath, backendUnitContent, 'utf8');
 
-                const frontendUnitContent = buildFrontendDaemonServiceUnit({
-                    appRoot,
-                    frontendPort: frontendPortNum,
-                    nodeExecPath: context.nodeExecPath,
-                    cliEntry: context.cliEntry,
-                });
-                fs.writeFileSync(frontendServicePath, frontendUnitContent, 'utf8');
+                if (frontendEnabled) {
+                    const frontendUnitContent = buildFrontendDaemonServiceUnit({
+                        appRoot,
+                        frontendPort: frontendPortNum,
+                        nodeExecPath: context.nodeExecPath,
+                        cliEntry: context.cliEntry,
+                    });
+                    fs.writeFileSync(frontendServicePath, frontendUnitContent, 'utf8');
+                }
             } catch (fileError) {
                 if (mode === 'system' && (fileError.code === 'EACCES' || fileError.code === 'EPERM')) {
                     const installHint = buildDaemonCliCommand(
                         {
                             subcommand: 'install',
                             mode: 'system',
-                            extraArgs: ['--port', String(portNum), '--frontend-port', String(frontendPortNum)],
+                            extraArgs: frontendEnabled
+                                ? ['--port', String(portNum), '--frontend-port', String(frontendPortNum)]
+                                : ['--port', String(portNum), '--single-port'],
                         },
                         daemonCommandContext
                     );
@@ -752,7 +768,12 @@ export async function handleDaemonCommand(args, context = {}) {
 
             runSystemctl(mode, ['daemon-reload']);
             runSystemctl(mode, ['enable', '--now', DAEMON_SERVICE_NAME]);
-            runSystemctl(mode, ['enable', '--now', FRONTEND_DAEMON_SERVICE_NAME]);
+            if (frontendEnabled) {
+                runSystemctl(mode, ['enable', '--now', FRONTEND_DAEMON_SERVICE_NAME]);
+            } else {
+                runSystemctl(mode, ['stop', FRONTEND_DAEMON_SERVICE_NAME], { allowFailure: true });
+                runSystemctl(mode, ['disable', FRONTEND_DAEMON_SERVICE_NAME], { allowFailure: true });
+            }
 
             if (mode === 'user') {
                 const lingerResult = runCommand('loginctl', ['enable-linger', os.userInfo().username]);
@@ -764,22 +785,32 @@ export async function handleDaemonCommand(args, context = {}) {
             }
 
             const installedPort = getPortFromServiceUnit(servicePath) || portNum;
-            const installedFrontendPort = getPortFromServiceUnit(frontendServicePath) || frontendPortNum;
             await healthCheckOrThrow(mode, DAEMON_SERVICE_NAME, installedPort, c);
-            await healthCheckOrThrow(mode, FRONTEND_DAEMON_SERVICE_NAME, installedFrontendPort, c);
+            const installedFrontendPort = frontendEnabled
+                ? getPortFromServiceUnit(frontendServicePath) || frontendPortNum
+                : undefined;
+            if (frontendEnabled && installedFrontendPort) {
+                await healthCheckOrThrow(mode, FRONTEND_DAEMON_SERVICE_NAME, installedFrontendPort, c);
+            }
 
             const backendState = getServiceState(mode, DAEMON_SERVICE_NAME);
-            const frontendState = getServiceState(mode, FRONTEND_DAEMON_SERVICE_NAME);
+            const frontendState = frontendEnabled
+                ? getServiceState(mode, FRONTEND_DAEMON_SERVICE_NAME)
+                : { active: 'disabled', enabled: 'disabled' };
             console.log(`\n${c.ok('✔')} Daemon installed and started.`);
             console.log(`   Mode:    ${c.bright(mode)}`);
             console.log(`   Backend Unit:   ${c.dim(servicePath)}`);
-            console.log(`   Frontend Unit:  ${c.dim(frontendServicePath)}`);
+            console.log(`   Frontend Mode:  ${c.bright(frontendEnabled ? 'separate service' : 'single backend port')}`);
             console.log(`   Backend Active: ${c.bright(backendState.active)}`);
             console.log(`   Backend Enabled:${c.bright(backendState.enabled)}`);
-            console.log(`   Frontend Active:${c.bright(frontendState.active)}`);
-            console.log(`   Frontend Enabled:${c.bright(frontendState.enabled)}`);
             console.log(`   Backend URL:    ${c.bright(`http://localhost:${installedPort}`)}`);
-            console.log(`   Frontend URL:   ${c.bright(`http://localhost:${installedFrontendPort}`)}\n`);
+            if (frontendEnabled) {
+                console.log(`   Frontend Unit:  ${c.dim(frontendServicePath)}`);
+                console.log(`   Frontend Active:${c.bright(frontendState.active)}`);
+                console.log(`   Frontend Enabled:${c.bright(frontendState.enabled)}`);
+                console.log(`   Frontend URL:   ${c.bright(`http://localhost:${installedFrontendPort}`)}`);
+            }
+            console.log('');
             if (mode === 'system') {
                 const statusCommand = buildDaemonCliCommand(
                     { subcommand: 'status', mode: 'system' },
@@ -793,9 +824,9 @@ export async function handleDaemonCommand(args, context = {}) {
                     { subcommand: 'logs', mode: 'system' },
                     daemonCommandContext
                 );
-                console.log(`${c.ok('[OK]')} System daemon is active for backend and frontend.`);
+                console.log(`${c.ok('[OK]')} System daemon is active.`);
                 console.log(`${c.info('[INFO]')} Backend health: ${c.bright(`http://localhost:${installedPort}/health`)}`);
-                console.log(`${c.info('[INFO]')} Frontend: ${c.bright(`http://localhost:${installedFrontendPort}/`)}`);
+                console.log(`${c.info('[INFO]')} UI: ${c.bright(`http://localhost:${installedPort}/`)}`);
                 console.log(`${c.info('[INFO]')} Status: ${c.bright(statusCommand)}`);
                 console.log(`${c.info('[INFO]')} Stop: ${c.bright(stopCommand)}`);
                 console.log(`${c.info('[INFO]')} Logs: ${c.bright(logsCommand)}\n`);
@@ -813,9 +844,9 @@ export async function handleDaemonCommand(args, context = {}) {
                     { subcommand: 'logs', mode: 'user' },
                     daemonCommandContext
                 );
-                console.log(`${c.ok('[OK]')} User daemon is active for backend and frontend.`);
+                console.log(`${c.ok('[OK]')} User daemon is active.`);
                 console.log(`${c.info('[INFO]')} Backend health: ${c.bright(`http://localhost:${installedPort}/health`)}`);
-                console.log(`${c.info('[INFO]')} Frontend: ${c.bright(`http://localhost:${installedFrontendPort}/`)}`);
+                console.log(`${c.info('[INFO]')} UI: ${c.bright(`http://localhost:${installedPort}/`)}`);
                 console.log(`${c.info('[INFO]')} Status: ${c.bright(statusCommand)}`);
                 console.log(`${c.info('[INFO]')} Stop: ${c.bright(stopCommand)}`);
                 console.log(`${c.info('[INFO]')} Logs: ${c.bright(logsCommand)}`);
@@ -830,36 +861,36 @@ export async function handleDaemonCommand(args, context = {}) {
 
         case 'start':
             runSystemctl(mode, ['start', DAEMON_SERVICE_NAME]);
-            runSystemctl(mode, ['start', FRONTEND_DAEMON_SERVICE_NAME]);
+            if (frontendEnabled) runSystemctl(mode, ['start', FRONTEND_DAEMON_SERVICE_NAME]);
             await healthCheckOrThrow(mode, DAEMON_SERVICE_NAME, effectivePort, c);
-            await healthCheckOrThrow(mode, FRONTEND_DAEMON_SERVICE_NAME, effectiveFrontendPort, c);
-            console.log(`${c.ok('[OK]')} Backend and frontend services started.`);
+            if (frontendEnabled) await healthCheckOrThrow(mode, FRONTEND_DAEMON_SERVICE_NAME, effectiveFrontendPort, c);
+            console.log(`${c.ok('[OK]')} Pixcode service started.`);
             break;
 
         case 'stop':
             runSystemctl(mode, ['stop', FRONTEND_DAEMON_SERVICE_NAME], { allowFailure: true });
             runSystemctl(mode, ['stop', DAEMON_SERVICE_NAME]);
-            console.log(`${c.ok('[OK]')} Backend and frontend services stopped (auto-start remains enabled).`);
+            console.log(`${c.ok('[OK]')} Pixcode service stopped (auto-start remains enabled).`);
             break;
 
         case 'restart':
             runSystemctl(mode, ['restart', DAEMON_SERVICE_NAME]);
-            runSystemctl(mode, ['restart', FRONTEND_DAEMON_SERVICE_NAME]);
+            if (frontendEnabled) runSystemctl(mode, ['restart', FRONTEND_DAEMON_SERVICE_NAME]);
             await healthCheckOrThrow(mode, DAEMON_SERVICE_NAME, effectivePort, c);
-            await healthCheckOrThrow(mode, FRONTEND_DAEMON_SERVICE_NAME, effectiveFrontendPort, c);
-            console.log(`${c.ok('[OK]')} Backend and frontend services restarted.`);
+            if (frontendEnabled) await healthCheckOrThrow(mode, FRONTEND_DAEMON_SERVICE_NAME, effectiveFrontendPort, c);
+            console.log(`${c.ok('[OK]')} Pixcode service restarted.`);
             break;
 
         case 'enable':
             runSystemctl(mode, ['enable', DAEMON_SERVICE_NAME]);
-            runSystemctl(mode, ['enable', FRONTEND_DAEMON_SERVICE_NAME]);
-            console.log(`${c.ok('[OK]')} Backend and frontend services enabled for auto-start.`);
+            if (frontendEnabled) runSystemctl(mode, ['enable', FRONTEND_DAEMON_SERVICE_NAME]);
+            console.log(`${c.ok('[OK]')} Pixcode service enabled for auto-start.`);
             break;
 
         case 'disable':
             runSystemctl(mode, ['disable', DAEMON_SERVICE_NAME]);
             runSystemctl(mode, ['disable', FRONTEND_DAEMON_SERVICE_NAME]);
-            console.log(`${c.ok('[OK]')} Backend and frontend services disabled for auto-start.`);
+            console.log(`${c.ok('[OK]')} Pixcode service disabled for auto-start.`);
             break;
 
         case 'logs': {
@@ -903,17 +934,25 @@ export async function handleDaemonCommand(args, context = {}) {
             const backendUnitExists = fs.existsSync(servicePath);
             const frontendUnitExists = fs.existsSync(frontendServicePath);
             const selectedPort = getPortFromServiceUnit(servicePath) || portNum;
-            const selectedFrontendPort = getPortFromServiceUnit(frontendServicePath) || frontendPortNum;
+            const selectedFrontendPort = frontendEnabled
+                ? getPortFromServiceUnit(frontendServicePath) || frontendPortNum
+                : undefined;
             console.log(`\n${c.bright('Pixcode Daemon Status')}\n`);
             console.log(`${c.info('[INFO]')} Mode:      ${c.bright(mode)} ${parsed.options.mode === 'auto' ? c.dim('(resolved from auto)') : ''}`);
             console.log(`${c.info('[INFO]')} Backend Unit:   ${c.dim(servicePath)} ${backendUnitExists ? c.ok('[OK]') : c.warn('[MISSING]')}`);
             console.log(`${c.info('[INFO]')} Backend Active: ${c.bright(backendState.active)}`);
             console.log(`${c.info('[INFO]')} Backend Enabled:${c.bright(backendState.enabled)}`);
             console.log(`${c.info('[INFO]')} Backend Port:   ${c.bright(String(selectedPort))}`);
-            console.log(`${c.info('[INFO]')} Frontend Unit:  ${c.dim(frontendServicePath)} ${frontendUnitExists ? c.ok('[OK]') : c.warn('[MISSING]')}`);
-            console.log(`${c.info('[INFO]')} Frontend Active:${c.bright(frontendState.active)}`);
-            console.log(`${c.info('[INFO]')} Frontend Enabled:${c.bright(frontendState.enabled)}`);
-            console.log(`${c.info('[INFO]')} Frontend Port:  ${c.bright(String(selectedFrontendPort))}`);
+            console.log(`${c.info('[INFO]')} UI URL:         ${c.bright(`http://localhost:${selectedPort}/`)}`);
+            console.log(`${c.info('[INFO]')} Frontend Mode:  ${frontendEnabled ? c.bright('separate Vite service') : c.bright('single backend port')}`);
+            if (frontendEnabled) {
+                console.log(`${c.info('[INFO]')} Frontend Unit:  ${c.dim(frontendServicePath)} ${frontendUnitExists ? c.ok('[OK]') : c.warn('[MISSING]')}`);
+                console.log(`${c.info('[INFO]')} Frontend Active:${c.bright(frontendState.active)}`);
+                console.log(`${c.info('[INFO]')} Frontend Enabled:${c.bright(frontendState.enabled)}`);
+                console.log(`${c.info('[INFO]')} Frontend Port:  ${c.bright(String(selectedFrontendPort))}`);
+            } else if (frontendUnitExists) {
+                console.log(`${c.info('[INFO]')} Legacy Frontend:${c.dim(frontendServicePath)} active=${c.bright(frontendState.active)} enabled=${c.bright(frontendState.enabled)}`);
+            }
             console.log('');
         }
     }