@agent-webui/ai-desk-daemon 1.0.49-beta1 → 1.0.49-beta2

package/bin/cli.js

@@ -12,6 +12,67 @@ const { start, stop, restart, status } = require('../lib/daemon-manager');
 const { getLogPath } = require('../lib/platform');
 const { VERSION } = require('../lib/platform');
 
+function wait(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function startUnixLogFollow(logPath, lines) {
+  const { spawn } = require('child_process');
+  const tailArgs = [];
+
+  if (typeof lines === 'number' && Number.isFinite(lines) && lines > 0) {
+    tailArgs.push('-n', String(lines));
+  }
+
+  tailArgs.push('-F', logPath);
+
+  const tail = spawn('tail', tailArgs);
+
+  tail.stdout.on('data', (data) => {
+    process.stdout.write(data);
+  });
+
+  tail.stderr.on('data', (data) => {
+    process.stderr.write(data);
+  });
+
+  tail.on('error', (error) => {
+    console.error(chalk.red('Failed to follow logs:'), error.message);
+    process.exit(1);
+  });
+
+  return tail;
+}
+
+function startWindowsLogFollow(initialLogPath) {
+  let currentLogPath = initialLogPath;
+  let lastSize = 0;
+
+  return setInterval(() => {
+    const nextLogPath = getLogPath();
+    if (nextLogPath !== currentLogPath) {
+      currentLogPath = nextLogPath;
+      lastSize = 0;
+    }
+
+    try {
+      const stats = fs.statSync(currentLogPath);
+      if (stats.size > lastSize) {
+        const stream = fs.createReadStream(currentLogPath, {
+          start: lastSize,
+          end: stats.size
+        });
+        stream.on('data', (chunk) => {
+          process.stdout.write(chunk);
+        });
+        lastSize = stats.size;
+      }
+    } catch (error) {
+      // Ignore missing files while the daemon is still starting or rolling logs.
+    }
+  }, 500);
+}
+
 function resolveRequestedMode(options) {
   const hasExplicitMode = typeof options.mode === 'string' && options.mode.trim() !== '';
 
@@ -96,31 +157,17 @@ program
         console.log(chalk.cyan('\n📋 Following daemon logs (Ctrl+C to stop daemon)...\n'));
 
         // Wait a moment for daemon to start writing logs
-        await new Promise(resolve => setTimeout(resolve, 1000));
+        await wait(1000);
 
         const logPath = getLogPath();
         if (!fs.existsSync(logPath)) {
           console.log(chalk.yellow('Waiting for logs...'));
-          await new Promise(resolve => setTimeout(resolve, 2000));
+          await wait(2000);
         }
 
-        // Follow logs (tail -f) - works on Unix-like systems
+        // Follow logs - works on Unix-like systems even before the file exists.
         if (process.platform !== 'win32') {
-          const { spawn } = require('child_process');
-          const tail = spawn('tail', ['-f', logPath]);
-
-          tail.stdout.on('data', (data) => {
-            process.stdout.write(data);
-          });
-
-          tail.stderr.on('data', (data) => {
-            process.stderr.write(data);
-          });
-
-          tail.on('error', (error) => {
-            console.error(chalk.red('Failed to follow logs:'), error.message);
-            process.exit(1);
-          });
+          const tail = startUnixLogFollow(logPath);
 
           // Handle Ctrl+C - stop the daemon
           process.on('SIGINT', () => {
@@ -142,24 +189,7 @@ program
           // Windows: use polling to read log file
           console.log(chalk.yellow('Log following on Windows - press Ctrl+C to stop daemon\n'));
 
-          let lastSize = 0;
-          const pollInterval = setInterval(() => {
-            try {
-              const stats = fs.statSync(logPath);
-              if (stats.size > lastSize) {
-                const stream = fs.createReadStream(logPath, {
-                  start: lastSize,
-                  end: stats.size
-                });
-                stream.on('data', (chunk) => {
-                  process.stdout.write(chunk);
-                });
-                lastSize = stats.size;
-              }
-            } catch (error) {
-              // Ignore errors
-            }
-          }, 500);
+          const pollInterval = startWindowsLogFollow(logPath);
 
           process.on('SIGINT', () => {
             clearInterval(pollInterval);
@@ -266,23 +296,21 @@ program
     const logPath = getLogPath();
     
     if (!fs.existsSync(logPath)) {
-      console.log(chalk.yellow('No logs found'));
+      console.log(chalk.yellow(`No logs found at ${logPath}`));
       return;
     }
     
     if (options.follow) {
-      // Follow logs (tail -f)
-      const { spawn } = require('child_process');
-      const tail = spawn('tail', ['-f', logPath]);
-      
-      tail.stdout.on('data', (data) => {
-        process.stdout.write(data);
-      });
-      
-      tail.on('error', (error) => {
-        console.error(chalk.red('Failed to follow logs:'), error.message);
-        process.exit(1);
-      });
+      if (process.platform !== 'win32') {
+        startUnixLogFollow(logPath, Number.parseInt(options.lines, 10));
+      } else {
+        console.log(chalk.yellow('Following logs on Windows - press Ctrl+C to stop\n'));
+        const pollInterval = startWindowsLogFollow(logPath);
+        process.on('SIGINT', () => {
+          clearInterval(pollInterval);
+          process.exit(0);
+        });
+      }
     } else {
       // Show last N lines
       const { execSync } = require('child_process');

package/lib/daemon-manager.js

@@ -5,7 +5,7 @@
 const fs = require('fs');
 const { spawn, execSync } = require('child_process');
 const http = require('http');
-const { getDaemonBinaryPath, getPidPath, getLogPath } = require('./platform');
+const { getDaemonBinaryPath, getPidPath, getConfiguredLogPath, getLogPath } = require('./platform');
 const { getPort, getConfigPath } = require('./config');
 
 /**
@@ -95,7 +95,7 @@ function start() {
 
   const port = getPort();
   const configPath = getConfigPath();
-  const logPath = getLogPath();
+  const configuredLogPath = getConfiguredLogPath();
 
   // Ensure port is a number
   const portNumber = typeof port === 'number' ? port : parseInt(port, 10);
@@ -104,7 +104,7 @@ function start() {
   }
 
   // Ensure log directory exists
-  const logDir = require('path').dirname(logPath);
+  const logDir = require('path').dirname(configuredLogPath);
   if (!fs.existsSync(logDir)) {
     fs.mkdirSync(logDir, { recursive: true });
   }
@@ -124,7 +124,7 @@ function start() {
 
   console.log(`Daemon started (PID: ${child.pid})`);
   console.log(`Port: ${portNumber}`);
-  console.log(`Logs: ${logPath}`);
+  console.log(`Logs: ${getLogPath()}`);
 
   return child.pid;
 }

package/lib/platform.js

@@ -122,12 +122,140 @@ function getConfigPath() {
 }
 
 /**
- * Get log file path
+ * Expand leading "~/" against the current user's home directory.
  */
-function getLogPath() {
+function expandHomePath(value) {
+  if (typeof value !== 'string') {
+    return '';
+  }
+
+  if (value === '~') {
+    return os.homedir();
+  }
+
+  if (value.startsWith(`~${path.sep}`) || value.startsWith('~/')) {
+    return path.join(os.homedir(), value.slice(2));
+  }
+
+  return value;
+}
+
+function getDefaultLogPath() {
   return path.join(getConfigDir(), 'logs', 'daemon.log');
 }
 
+function getConfiguredLogPath() {
+  const defaultLogPath = getDefaultLogPath();
+  const configPath = getConfigPath();
+
+  if (!fs.existsSync(configPath)) {
+    return defaultLogPath;
+  }
+
+  try {
+    const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+    const configuredLogPath = typeof config?.log_path === 'string' ? config.log_path.trim() : '';
+    if (!configuredLogPath) {
+      return defaultLogPath;
+    }
+    return path.resolve(expandHomePath(configuredLogPath));
+  } catch {
+    return defaultLogPath;
+  }
+}
+
+function resolveBaseLogPath(baseLogPath = getConfiguredLogPath()) {
+  if (typeof baseLogPath !== 'string') {
+    return getConfiguredLogPath();
+  }
+
+  const trimmedPath = baseLogPath.trim();
+  if (!trimmedPath) {
+    return getConfiguredLogPath();
+  }
+
+  return path.resolve(expandHomePath(trimmedPath));
+}
+
+function parseRollingLogFilename(prefix, filename) {
+  const pattern = new RegExp(`^${prefix.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}-([0-9]{8})(?:-([0-9]+))?\\.log$`);
+  const match = filename.match(pattern);
+  if (!match) {
+    return null;
+  }
+
+  return {
+    date: match[1],
+    seq: match[2] ? Number.parseInt(match[2], 10) : 1,
+  };
+}
+
+function compareRollingLogEntries(left, right) {
+  if (left.date !== right.date) {
+    return left.date.localeCompare(right.date);
+  }
+  if (left.seq !== right.seq) {
+    return left.seq - right.seq;
+  }
+  return left.filename.localeCompare(right.filename);
+}
+
+function findLatestRollingLogPath(baseLogPath = getConfiguredLogPath()) {
+  const resolvedBaseLogPath = resolveBaseLogPath(baseLogPath);
+  const logDir = path.dirname(resolvedBaseLogPath);
+  const prefix = path.basename(resolvedBaseLogPath, path.extname(resolvedBaseLogPath));
+
+  if (!fs.existsSync(logDir)) {
+    return '';
+  }
+
+  const entries = [];
+  for (const filename of fs.readdirSync(logDir)) {
+    const parsed = parseRollingLogFilename(prefix, filename);
+    if (!parsed) {
+      continue;
+    }
+    entries.push({
+      filename,
+      date: parsed.date,
+      seq: parsed.seq,
+    });
+  }
+
+  if (entries.length === 0) {
+    return '';
+  }
+
+  entries.sort(compareRollingLogEntries);
+  return path.join(logDir, entries[entries.length - 1].filename);
+}
+
+function getExpectedRollingLogPath(baseLogPath = getConfiguredLogPath(), now = new Date()) {
+  const resolvedBaseLogPath = resolveBaseLogPath(baseLogPath);
+  const logDir = path.dirname(resolvedBaseLogPath);
+  const prefix = path.basename(resolvedBaseLogPath, path.extname(resolvedBaseLogPath));
+  const year = now.getFullYear().toString().padStart(4, '0');
+  const month = `${now.getMonth() + 1}`.padStart(2, '0');
+  const day = `${now.getDate()}`.padStart(2, '0');
+  return path.join(logDir, `${prefix}-${year}${month}${day}.log`);
+}
+
+/**
+ * Get the most useful daemon log path for display and tailing.
+ * Prefers the latest rolling log file when present.
+ */
+function getLogPath() {
+  const configuredLogPath = getConfiguredLogPath();
+  const latestRollingLogPath = findLatestRollingLogPath(configuredLogPath);
+  if (latestRollingLogPath) {
+    return latestRollingLogPath;
+  }
+  if (fs.existsSync(configuredLogPath)) {
+    return configuredLogPath;
+  }
+  return getExpectedRollingLogPath(configuredLogPath);
+}
+
 /**
  * Get PID file path
  */
@@ -149,6 +277,11 @@ module.exports = {
   getRuntimePythonPath,
   getHarnessRegistryPath,
   getConfigPath,
+  getConfiguredLogPath,
+  getDefaultLogPath,
+  resolveBaseLogPath,
+  findLatestRollingLogPath,
+  getExpectedRollingLogPath,
   getLogPath,
   getPidPath,
   VERSION

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-webui/ai-desk-daemon",
-  "version": "1.0.49-beta1",
+  "version": "1.0.49-beta2",
   "description": "AI Desk Daemon - CLI tool for managing the AI Desk daemon service",
   "workspaces": [
     "packages/*"
@@ -39,16 +39,16 @@
     "chalk": "^4.1.2"
   },
   "optionalDependencies": {
-    "@agent-webui/ai-desk-daemon-darwin-arm64": "1.0.49-beta1",
-    "@agent-webui/ai-desk-daemon-darwin-x64": "1.0.49-beta1",
-    "@agent-webui/ai-desk-daemon-linux-arm64": "1.0.49-beta1",
-    "@agent-webui/ai-desk-daemon-linux-x64": "1.0.49-beta1",
-    "@agent-webui/ai-desk-daemon-win32-x64": "1.0.49-beta1",
-    "@agent-webui/ai-desk-python-darwin-arm64": "1.0.49-beta1",
-    "@agent-webui/ai-desk-python-darwin-x64": "1.0.49-beta1",
-    "@agent-webui/ai-desk-python-linux-arm64": "1.0.49-beta1",
-    "@agent-webui/ai-desk-python-linux-x64": "1.0.49-beta1",
-    "@agent-webui/ai-desk-python-win32-x64": "1.0.49-beta1"
+    "@agent-webui/ai-desk-daemon-darwin-arm64": "1.0.49",
+    "@agent-webui/ai-desk-daemon-darwin-x64": "1.0.49",
+    "@agent-webui/ai-desk-daemon-linux-arm64": "1.0.49",
+    "@agent-webui/ai-desk-daemon-linux-x64": "1.0.49",
+    "@agent-webui/ai-desk-daemon-win32-x64": "1.0.49",
+    "@agent-webui/ai-desk-python-darwin-arm64": "1.0.49",
+    "@agent-webui/ai-desk-python-darwin-x64": "1.0.49",
+    "@agent-webui/ai-desk-python-linux-arm64": "1.0.49",
+    "@agent-webui/ai-desk-python-linux-x64": "1.0.49",
+    "@agent-webui/ai-desk-python-win32-x64": "1.0.49"
   },
   "repository": {
     "type": "git",