wind-agent-cli 1.37.2

package/server/modules/browser-use/index.ts

@@ -0,0 +1,11 @@
+/**
+ * Lazily starts the Browser Use MCP stdio entrypoint. Keeping this import lazy
+ * ensures the entrypoint loads environment configuration before its runtime is
+ * evaluated.
+ */
+export async function startBrowserUseMcp(): Promise<void> {
+  await import('./browser-use-mcp.js');
+}
+
+// getBrowserUseRuntime: used by Browser Use services and environment-mode regression coverage.
+export { getBrowserUseRuntime } from './browser-use-runtime.js';

package/server/modules/browser-use/tests/browser-use.service.test.ts

@@ -0,0 +1,10 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+
+import { browserUseService } from '@/modules/browser-use/browser-use.service.js';
+
+test('browser monitor list starts empty without agent sessions', async () => {
+  const sessions = await browserUseService.listSessions();
+
+  assert.deepEqual(sessions, []);
+});

package/server/modules/cli/cli.module.ts

@@ -0,0 +1,95 @@
+import { execFileSync, execSync } from 'node:child_process';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+import spawn from 'cross-spawn';
+
+import type { CliApplication, CliPackageMetadata } from '@/shared/types.js';
+import { findApplicationRoot, getModuleDirectory } from '@/shared/utils.js';
+
+import { createCliService } from './cli.service.js';
+import { createSandboxCommandService } from './sandbox.service.js';
+
+/**
+ * Creates the production CLI application for the executable entrypoint. This is
+ * the CLI module's single composition root: it reads package metadata and wires
+ * all concrete Node filesystem, subprocess, environment, clock, and module-start
+ * adapters before passing them into otherwise isolated services.
+ */
+export function createCliApplication(): CliApplication {
+  const applicationRoot = findApplicationRoot(getModuleDirectory(import.meta.url));
+  const packageMetadataJson = JSON.parse(
+    fs.readFileSync(path.join(applicationRoot, 'package.json'), 'utf8'),
+  ) as { version: string; homepage?: string; bugs?: { url?: string } };
+  const packageMetadata: CliPackageMetadata = {
+    version: packageMetadataJson.version,
+    homepage: packageMetadataJson.homepage,
+    bugsUrl: packageMetadataJson.bugs?.url,
+  };
+  const fileSystem = {
+    pathExists: (filePath: string) => fs.existsSync(filePath),
+    getFileStats: (filePath: string) => {
+      const stats = fs.statSync(filePath);
+      return { size: stats.size, modifiedAt: stats.mtime };
+    },
+  };
+  const output = {
+    log: (message?: string) => console.log(message),
+    error: (message?: string) => console.error(message),
+  };
+  const homeDirectory = os.homedir();
+  const sandboxService = createSandboxCommandService({
+    homeDirectory,
+    fileSystem,
+    output,
+    runSandboxCommand: (argumentsList, inheritOutput = false) => {
+      const result = execFileSync('sbx', argumentsList, {
+        encoding: 'utf8',
+        stdio: inheritOutput ? 'inherit' : 'pipe',
+      });
+      return result || '';
+    },
+    spawnDetachedSandbox: (argumentsList) => {
+      const childProcess = spawn('sbx', argumentsList, {
+        detached: true,
+        stdio: ['ignore', 'ignore', 'ignore'],
+      });
+      childProcess.unref();
+    },
+    wait: (milliseconds) => new Promise((resolve) => setTimeout(resolve, milliseconds)),
+  });
+
+  return createCliService({
+    applicationRoot,
+    defaultDatabasePath: path.join(homeDirectory, '.cloudcli', 'auth.db'),
+    homeDirectory,
+    packageMetadata,
+    environment: process.env,
+    fileSystem,
+    output,
+    sandboxService,
+    getLatestPackageVersion: async () => {
+      // Yield first so the default `start` command can begin loading the server
+      // before this best-effort npm registry check runs.
+      await new Promise<void>((resolve) => setImmediate(resolve));
+      return execSync(
+        'npm show wind-agent-cli version',
+        { encoding: 'utf8' },
+      ).trim();
+    },
+    updateGlobalPackage: () => {
+      execSync('npm update -g wind-agent-cli', { stdio: 'inherit' });
+    },
+    startServer: async () => {
+      // The server executable is an entrypoint rather than a feature module,
+      // so it has no barrel contract to import through.
+      // eslint-disable-next-line boundaries/no-unknown
+      await import('../../index.js');
+    },
+    startBrowserUseMcp: async () => {
+      const { startBrowserUseMcp } = await import('../browser-use/index.js');
+      await startBrowserUseMcp();
+    },
+  });
+}

package/server/modules/cli/cli.service.ts

@@ -0,0 +1,260 @@
+import path from 'node:path';
+
+import type {
+  CliApplication,
+  CliEnvironment,
+  CliFileSystem,
+  CliOutput,
+  CliPackageMetadata,
+  SandboxCommandService,
+} from '@/shared/types.js';
+import { terminalTextStyles } from '@/shared/utils.js';
+
+type CliServiceDependencies = {
+  applicationRoot: string;
+  defaultDatabasePath: string;
+  homeDirectory: string;
+  packageMetadata: CliPackageMetadata;
+  environment: CliEnvironment;
+  fileSystem: CliFileSystem;
+  output: CliOutput;
+  sandboxService: SandboxCommandService;
+  getLatestPackageVersion(): Promise<string>;
+  updateGlobalPackage(): void;
+  startServer(): Promise<void>;
+  startBrowserUseMcp(): Promise<void>;
+};
+
+type ParsedCliArguments = {
+  command: string;
+  options: {
+    serverPort?: string;
+    databasePath?: string;
+  };
+  remainingArguments: string[];
+};
+
+function parseCliArguments(argumentsList: string[]): ParsedCliArguments {
+  const parsedArguments: ParsedCliArguments = {
+    command: 'start',
+    options: {},
+    remainingArguments: [],
+  };
+
+  for (let argumentIndex = 0; argumentIndex < argumentsList.length; argumentIndex += 1) {
+    const argument = argumentsList[argumentIndex];
+    if (argument === '--port' || argument === '-p') {
+      parsedArguments.options.serverPort = argumentsList[++argumentIndex];
+    } else if (argument.startsWith('--port=')) {
+      parsedArguments.options.serverPort = argument.slice('--port='.length);
+    } else if (argument === '--database-path') {
+      parsedArguments.options.databasePath = argumentsList[++argumentIndex];
+    } else if (argument.startsWith('--database-path=')) {
+      parsedArguments.options.databasePath = argument.slice('--database-path='.length);
+    } else if (argument === '--help' || argument === '-h') {
+      parsedArguments.command = 'help';
+    } else if (argument === '--version' || argument === '-v') {
+      parsedArguments.command = 'version';
+    } else if (!argument.startsWith('-')) {
+      parsedArguments.command = argument;
+      if (argument === 'sandbox') {
+        parsedArguments.remainingArguments = argumentsList.slice(argumentIndex + 1);
+        break;
+      }
+    }
+  }
+
+  return parsedArguments;
+}
+
+function isNewerVersion(candidateVersion: string, currentVersion: string): boolean {
+  const candidateParts = candidateVersion.split('.').map(Number);
+  const currentParts = currentVersion.split('.').map(Number);
+  for (let partIndex = 0; partIndex < 3; partIndex += 1) {
+    if (candidateParts[partIndex] > currentParts[partIndex]) return true;
+    if (candidateParts[partIndex] < currentParts[partIndex]) return false;
+  }
+  return false;
+}
+
+function showStatus(dependencies: CliServiceDependencies): void {
+  const { environment, fileSystem, output } = dependencies;
+  const databasePath = environment.DATABASE_PATH || dependencies.defaultDatabasePath;
+  const databaseExists = fileSystem.pathExists(databasePath);
+  const claudeProjectsPath = path.join(dependencies.homeDirectory, '.claude', 'projects');
+  const environmentFilePath = path.join(dependencies.applicationRoot, '.env');
+
+  output.log(`\n${terminalTextStyles.bright('CloudCLI UI - Status')}\n`);
+  output.log(terminalTextStyles.dim('═'.repeat(60)));
+  output.log(`\n${terminalTextStyles.info('[INFO]')} Version: ${terminalTextStyles.bright(dependencies.packageMetadata.version)}`);
+  output.log(`\n${terminalTextStyles.info('[INFO]')} Installation Directory:`);
+  output.log(`       ${terminalTextStyles.dim(dependencies.applicationRoot)}`);
+  output.log(`\n${terminalTextStyles.info('[INFO]')} Database Location:`);
+  output.log(`       ${terminalTextStyles.dim(databasePath)}`);
+  output.log(`       Status: ${databaseExists
+    ? terminalTextStyles.ok('[OK] Exists')
+    : terminalTextStyles.warn('[WARN] Not created yet (will be created on first run)')}`);
+
+  if (databaseExists) {
+    const databaseStats = fileSystem.getFileStats(databasePath);
+    output.log(`       Size: ${terminalTextStyles.dim(`${(databaseStats.size / 1024).toFixed(2)} KB`)}`);
+    output.log(`       Modified: ${terminalTextStyles.dim(databaseStats.modifiedAt.toLocaleString())}`);
+  }
+
+  output.log(`\n${terminalTextStyles.info('[INFO]')} Configuration:`);
+  output.log(`       SERVER_PORT: ${terminalTextStyles.bright(environment.SERVER_PORT || environment.PORT || '3001')} ${terminalTextStyles.dim(environment.SERVER_PORT || environment.PORT ? '' : '(default)')}`);
+  output.log(`       DATABASE_PATH: ${terminalTextStyles.dim(environment.DATABASE_PATH || '(using default location)')}`);
+  output.log(`       CLAUDE_CLI_PATH: ${terminalTextStyles.dim(environment.CLAUDE_CLI_PATH || 'claude (default)')}`);
+  output.log(`       CONTEXT_WINDOW: ${terminalTextStyles.dim(environment.CONTEXT_WINDOW || '160000 (default)')}`);
+  output.log(`\n${terminalTextStyles.info('[INFO]')} Claude Projects Folder:`);
+  output.log(`       ${terminalTextStyles.dim(claudeProjectsPath)}`);
+  output.log(`       Status: ${fileSystem.pathExists(claudeProjectsPath)
+    ? terminalTextStyles.ok('[OK] Exists')
+    : terminalTextStyles.warn('[WARN] Not found')}`);
+  output.log(`\n${terminalTextStyles.info('[INFO]')} Configuration File:`);
+  output.log(`       ${terminalTextStyles.dim(environmentFilePath)}`);
+  output.log(`       Status: ${fileSystem.pathExists(environmentFilePath)
+    ? terminalTextStyles.ok('[OK] Exists')
+    : terminalTextStyles.warn('[WARN] Not found (using defaults)')}`);
+  output.log(`\n${terminalTextStyles.dim('═'.repeat(60))}`);
+  output.log(`\n${terminalTextStyles.tip('[TIP]')} Hints:`);
+  output.log(`      ${terminalTextStyles.dim('>')} Use ${terminalTextStyles.bright('wacli --port 8080')} to run on a custom port`);
+  output.log(`      ${terminalTextStyles.dim('>')} Use ${terminalTextStyles.bright('wacli --database-path /path/to/db')} for custom database`);
+  output.log(`      ${terminalTextStyles.dim('>')} Run ${terminalTextStyles.bright('wacli help')} for all options`);
+  output.log(`      ${terminalTextStyles.dim('>')} Access the UI at http://localhost:${environment.SERVER_PORT || environment.PORT || '3001'}\n`);
+}
+
+function showHelp(dependencies: CliServiceDependencies): void {
+  dependencies.output.log(`
+╔═══════════════════════════════════════════════════════════════╗
+║              CloudCLI - Command Line Tool               ║
+╚═══════════════════════════════════════════════════════════════╝
+
+Usage:
+  wacli [command] [options]
+
+Commands:
+  start            Start the CloudCLI server (default)
+  sandbox          Manage Docker sandbox environments
+  browser-use-mcp  Run Browser MCP stdio server
+  status           Show configuration and data locations
+  update           Update to the latest version
+  help             Show this help information
+  version          Show version information
+
+Options:
+  -p, --port <port>           Set server port (default: 3001)
+  --database-path <path>      Set custom database location
+  -h, --help                  Show this help information
+  -v, --version               Show version information
+
+Examples:
+  $ wacli                        # Start with defaults
+  $ wacli --port 8080            # Start on port 8080
+  $ wacli sandbox ~/my-project   # Run in a Docker sandbox
+  $ wacli status                 # Show configuration
+
+Environment Variables:
+  SERVER_PORT         Set server port (default: 3001)
+  PORT                Set server port (default: 3001) (LEGACY)
+  DATABASE_PATH       Set custom database location
+  CLAUDE_CLI_PATH     Set custom Claude CLI path
+  CONTEXT_WINDOW      Set context window size (default: 160000)
+
+Documentation:
+  ${dependencies.packageMetadata.homepage || 'https://github.com/siteboon/claudecodeui'}
+
+Report Issues:
+  ${dependencies.packageMetadata.bugsUrl || 'https://github.com/siteboon/claudecodeui/issues'}
+`);
+}
+
+/**
+ * Creates the top-level CLI command service used by the CLI composition root
+ * and unit tests. Every filesystem, subprocess, environment, output, and
+ * cross-module startup dependency is explicit and required.
+ */
+export function createCliService(dependencies: CliServiceDependencies): CliApplication {
+  const checkForUpdates = async (silent = false): Promise<boolean> => {
+    try {
+      const latestVersion = await dependencies.getLatestPackageVersion();
+      const currentVersion = dependencies.packageMetadata.version;
+      if (isNewerVersion(latestVersion, currentVersion)) {
+        dependencies.output.log(`\n${terminalTextStyles.warn('[UPDATE]')} New version available: ${terminalTextStyles.bright(latestVersion)} (current: ${currentVersion})`);
+        dependencies.output.log(`         Run ${terminalTextStyles.bright('wacli update')} to update\n`);
+        return true;
+      }
+      if (!silent) {
+        dependencies.output.log(`${terminalTextStyles.ok('[OK]')} You are on the latest version (${currentVersion})`);
+      }
+      return false;
+    } catch {
+      if (!silent) {
+        dependencies.output.log(`${terminalTextStyles.warn('[WARN]')} Could not check for updates`);
+      }
+      return false;
+    }
+  };
+
+  const updatePackage = async (): Promise<void> => {
+    dependencies.output.log(`${terminalTextStyles.info('[INFO]')} Checking for updates...`);
+    const hasUpdate = await checkForUpdates(true);
+    if (!hasUpdate) {
+      dependencies.output.log(`${terminalTextStyles.ok('[OK]')} Already on the latest version (${dependencies.packageMetadata.version})`);
+      return;
+    }
+
+    try {
+      dependencies.output.log(`${terminalTextStyles.info('[INFO]')} Updating ${dependencies.packageMetadata.version}...`);
+      dependencies.updateGlobalPackage();
+      dependencies.output.log(`${terminalTextStyles.ok('[OK]')} Update complete! Restart wacli to use the new version.`);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      dependencies.output.error(`${terminalTextStyles.error('[ERROR]')} Update failed: ${message}`);
+      dependencies.output.log(`${terminalTextStyles.tip('[TIP]')} Try running manually: npm update -g wind-agent-cli`);
+    }
+  };
+
+  return {
+    async run(argumentsList) {
+      const parsedArguments = parseCliArguments(argumentsList);
+      if (parsedArguments.options.serverPort) {
+        dependencies.environment.SERVER_PORT = parsedArguments.options.serverPort;
+      } else if (!dependencies.environment.SERVER_PORT && dependencies.environment.PORT) {
+        dependencies.environment.SERVER_PORT = dependencies.environment.PORT;
+      }
+      if (parsedArguments.options.databasePath) {
+        dependencies.environment.DATABASE_PATH = parsedArguments.options.databasePath;
+      }
+
+      switch (parsedArguments.command) {
+        case 'start':
+          void checkForUpdates(true);
+          await dependencies.startServer();
+          return 0;
+        case 'sandbox':
+          return dependencies.sandboxService.execute(parsedArguments.remainingArguments);
+        case 'browser-use-mcp':
+          await dependencies.startBrowserUseMcp();
+          return 0;
+        case 'status':
+        case 'info':
+          showStatus(dependencies);
+          return 0;
+        case 'help':
+          showHelp(dependencies);
+          return 0;
+        case 'version':
+          dependencies.output.log(dependencies.packageMetadata.version);
+          return 0;
+        case 'update':
+          await updatePackage();
+          return 0;
+        default:
+          dependencies.output.error(`\n❌ Unknown command: ${parsedArguments.command}`);
+          dependencies.output.log('   Run "wacli help" for usage information.\n');
+          return 1;
+      }
+    },
+  };
+}

package/server/modules/cli/cli.ts

@@ -0,0 +1,19 @@
+#!/usr/bin/env node
+
+// The CLI can reach shared environment constants through its composition root,
+// so finish the root environment bootstrap before loading that import graph.
+// eslint-disable-next-line boundaries/no-unknown
+import '../../load-env.js';
+
+async function runCli(): Promise<number> {
+  const { createCliApplication } = await import('./index.js');
+  return createCliApplication().run(process.argv.slice(2));
+}
+
+runCli().then((exitCode) => {
+  process.exitCode = exitCode;
+}).catch((error: unknown) => {
+  const message = error instanceof Error ? error.message : String(error);
+  console.error('\n❌ Error:', message);
+  process.exitCode = 1;
+});

package/server/modules/cli/index.ts

@@ -0,0 +1,2 @@
+// createCliApplication: used by the CLI executable to obtain the fully wired command application.
+export { createCliApplication } from './cli.module.js';