agent-window 1.0.1 → 1.0.2

package/src/core/platform/docker-bridge.js

@@ -0,0 +1,372 @@
+/**
+ * Docker Bridge Module
+ *
+ * Cross-platform abstraction for Docker commands.
+ * Supports:
+ * - Native Docker on Linux/macOS
+ * - Docker Desktop on Windows
+ * - WSL2 Docker backend on Windows
+ */
+
+import { spawn, exec } from 'child_process';
+import { promisify } from 'util';
+import { isWindows, isWSLAvailable } from './detector.js';
+
+const execAsync = promisify(exec);
+
+/**
+ * Docker execution options
+ */
+class DockerOptions {
+  constructor(options = {}) {
+    this.timeout = options.timeout || 30000;
+    this.wsl = options.wsl !== false; // Default to WSL on Windows
+    this.silent = options.silent || false;
+  }
+}
+
+/**
+ * Execute Docker command with platform abstraction
+ */
+async function execDockerCommand(args, options = {}) {
+  const opts = new DockerOptions(options);
+  let command = 'docker';
+  let cmdArgs = args;
+  let execOptions = { timeout: opts.timeout };
+
+  // On Windows, try WSL2 if available
+  if (isWindows() && opts.wsl) {
+    const wslAvailable = await isWSLAvailable();
+    if (wslAvailable) {
+      command = 'wsl.exe';
+      cmdArgs = ['docker', ...args];
+      execOptions.windowsHide = true;
+    }
+  }
+
+  return new Promise((resolve, reject) => {
+    const stdoutChunks = [];
+    const stderrChunks = [];
+
+    const child = spawn(command, cmdArgs, {
+      stdio: ['ignore', 'pipe', 'pipe'],
+      ...execOptions
+    });
+
+    child.stdout.on('data', (chunk) => {
+      stdoutChunks.push(chunk);
+      if (!opts.silent) {
+        process.stdout.write(chunk);
+      }
+    });
+
+    child.stderr.on('data', (chunk) => {
+      stderrChunks.push(chunk);
+      if (!opts.silent) {
+        process.stderr.write(chunk);
+      }
+    });
+
+    child.on('close', (code) => {
+      const stdout = Buffer.concat(stdoutChunks).toString('utf8').trim();
+      const stderr = Buffer.concat(stderrChunks).toString('utf8').trim();
+
+      if (code === 0) {
+        resolve({ stdout, stderr, code });
+      } else {
+        reject(new Error(`Docker command failed (exit ${code}): ${stderr || stdout}`));
+      }
+    });
+
+    child.on('error', (err) => {
+      reject(new Error(`Failed to execute docker command: ${err.message}`));
+    });
+  });
+}
+
+/**
+ * Execute command inside a Docker container
+ */
+async function execContainer(containerName, command, options = {}) {
+  const execArgs = ['exec', containerName];
+  if (options.workDir) {
+    execArgs.push('-w', options.workDir);
+  }
+  if (options.env) {
+    for (const [key, value] of Object.entries(options.env)) {
+      execArgs.push('-e', `${key}=${value}`);
+    }
+  }
+  execArgs.push('sh', '-c', command);
+
+  return execDockerCommand(execArgs, options);
+}
+
+/**
+ * Check if a container exists
+ */
+async function containerExists(containerName) {
+  try {
+    const result = await execDockerCommand(
+      ['ps', '-a', '--filter', `name=${containerName}`, '--format', '{{.Names}}'],
+      { silent: true }
+    );
+    return result.stdout.includes(containerName);
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Check if a container is running
+ */
+async function isContainerRunning(containerName) {
+  try {
+    const result = await execDockerCommand(
+      ['ps', '--filter', `name=${containerName}`, '--format', '{{.Names}}'],
+      { silent: true }
+    );
+    return result.stdout.includes(containerName);
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Get container info
+ */
+async function inspect(containerName) {
+  try {
+    const result = await execDockerCommand(
+      ['inspect', containerName],
+      { silent: true }
+    );
+    return JSON.parse(result.stdout);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Get container IP address
+ */
+async function getContainerIP(containerName) {
+  const inspectData = await inspect(containerName);
+  if (!inspectData || inspectData.length === 0) {
+    return null;
+  }
+
+  const networkSettings = inspectData[0].NetworkSettings;
+  return networkSettings.IPAddress || null;
+}
+
+/**
+ * Get container port bindings
+ */
+async function getPortBindings(containerName) {
+  const inspectData = await inspect(containerName);
+  if (!inspectData || inspectData.length === 0) {
+    return {};
+  }
+
+  const networkSettings = inspectData[0].NetworkSettings;
+  return networkSettings.Ports || {};
+}
+
+/**
+ * Start a container
+ */
+async function start(containerName, options = {}) {
+  return execDockerCommand(['start', containerName], options);
+}
+
+/**
+ * Stop a container
+ */
+async function stop(containerName, options = {}) {
+  const timeout = options.timeout || 10;
+  return execDockerCommand(['stop', '-t', String(timeout), containerName], options);
+}
+
+/**
+ * Restart a container
+ */
+async function restart(containerName, options = {}) {
+  return execDockerCommand(['restart', containerName], options);
+}
+
+/**
+ * Remove a container
+ */
+async function rm(containerName, options = {}) {
+  const args = ['rm'];
+  if (options.force) args.push('-f');
+  args.push(containerName);
+  return execDockerCommand(args, options);
+}
+
+/**
+ * Run a new container
+ */
+async function run(image, options = {}) {
+  const args = ['run'];
+
+  if (options.detach) args.push('-d');
+  if (options.name) args.push('--name', options.name);
+  if (options.remove) args.push('--rm');
+
+  // Port mappings
+  if (options.ports) {
+    for (const port of options.ports) {
+      args.push('-p', port);
+    }
+  }
+
+  // Volume mounts
+  if (options.volumes) {
+    for (const vol of options.volumes) {
+      args.push('-v', vol);
+    }
+  }
+
+  // Environment variables
+  if (options.env) {
+    for (const [key, value] of Object.entries(options.env)) {
+      args.push('-e', `${key}=${value}`);
+    }
+  }
+
+  // Work directory
+  if (options.workDir) {
+    args.push('-w', options.workDir);
+  }
+
+  args.push(image);
+
+  if (options.command) {
+    args.push(...(Array.isArray(options.command) ? options.command : [options.command]));
+  }
+
+  return execDockerCommand(args, options);
+}
+
+/**
+ * Build an image
+ */
+async function build(path, options = {}) {
+  const args = ['build'];
+
+  if (options.tag) {
+    args.push('-t', options.tag);
+  }
+
+  if (options.file) {
+    args.push('-f', options.file);
+  }
+
+  args.push(path);
+
+  return execDockerCommand(args, options);
+}
+
+/**
+ * Pull an image
+ */
+async function pull(image, options = {}) {
+  return execDockerCommand(['pull', image], options);
+}
+
+/**
+ * Get Docker version info
+ */
+async function version() {
+  try {
+    const result = await execDockerCommand(['version', '--format', 'json'], { silent: true });
+    return JSON.parse(result.stdout);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Check if Docker is available
+ */
+async function isAvailable() {
+  try {
+    await execDockerCommand(['--version'], { silent: true, timeout: 5000 });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Get list of containers
+ */
+async function ps(options = {}) {
+  const args = ['ps'];
+
+  if (options.all) args.push('-a');
+
+  args.push('--format', 'json');
+
+  try {
+    const result = await execDockerCommand(args, { silent: true });
+    return result.stdout.split('\n')
+      .filter(line => line.trim())
+      .map(line => JSON.parse(line));
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Get container logs
+ */
+async function logs(containerName, options = {}) {
+  const args = ['logs'];
+
+  if (options.follow) args.push('-f');
+  if (options.tail) args.push('--tail', String(options.tail));
+  if (options.timestamps) args.push('-t');
+
+  args.push(containerName);
+
+  return execDockerCommand(args, options);
+}
+
+/**
+ * Copy file to container
+ */
+async function cpTo(localPath, containerName, containerPath, options = {}) {
+  return execDockerCommand(['cp', localPath, `${containerName}:${containerPath}`], options);
+}
+
+/**
+ * Copy file from container
+ */
+async function cpFrom(containerName, containerPath, localPath, options = {}) {
+  return execDockerCommand(['cp', `${containerName}:${containerPath}`, localPath], options);
+}
+
+export default {
+  exec: execContainer,
+  containerExists,
+  isContainerRunning,
+  inspect,
+  getContainerIP,
+  getPortBindings,
+  start,
+  stop,
+  restart,
+  rm,
+  run,
+  build,
+  pull,
+  version,
+  isAvailable,
+  ps,
+  logs,
+  cpTo,
+  cpFrom
+};

package/src/core/platform/index.js

@@ -0,0 +1,27 @@
+/**
+ * Platform Module
+ *
+ * Exports platform detection and abstraction layer for cross-platform support.
+ * Supports Windows (with WSL2), macOS, and Linux.
+ */
+
+// Platform detection
+export {
+  Platform,
+  currentPlatform,
+  isWindows,
+  isWSLAvailable,
+  isDockerDesktopAvailable,
+  isPMAvailable,
+  getShell,
+  executor
+} from './detector.js';
+
+// Docker bridge (cross-platform Docker commands)
+export { default as docker } from './docker-bridge.js';
+
+// PM2 bridge (cross-platform PM2 commands)
+export { default as pm2 } from './pm2-bridge.js';
+
+// Cross-platform path utilities
+export { default as paths } from './paths.js';

package/src/core/platform/paths.js

@@ -0,0 +1,112 @@
+/**
+ * Cross-platform path utilities
+ *
+ * Handles platform-specific path differences between Windows, macOS, and Linux.
+ */
+
+import { homedir } from 'os';
+import { join, normalize } from 'path';
+
+/**
+ * Get home directory in a cross-platform way.
+ * On Unix-like systems, this is equivalent to $HOME.
+ * On Windows, Node.js' os.homedir() handles USERPROFILE.
+ */
+export function getHomeDir() {
+  return homedir();
+}
+
+/**
+ * Get AgentWindow home directory.
+ * Can be overridden via AGENT_WINDOW_HOME environment variable.
+ */
+export function getAgentWindowHome() {
+  return process.env.AGENT_WINDOW_HOME || join(getHomeDir(), '.agent-window');
+}
+
+/**
+ * Get user's bots directory.
+ * Convention: ~/bots directory for storing bot configurations.
+ */
+export function getBotsDir() {
+  return join(getHomeDir(), 'bots');
+}
+
+/**
+ * Get Claude's default config directory.
+ */
+export function getClaudeConfigDir() {
+  return join(getHomeDir(), '.claude');
+}
+
+/**
+ * Expand a path with ~ (tilde) to absolute path.
+ * Handles both ~/path and plain ~.
+ */
+export function expandTilde(path) {
+  if (!path) return path;
+  if (path.startsWith('~/')) {
+    return join(getHomeDir(), path.slice(2));
+  }
+  if (path === '~') {
+    return getHomeDir();
+  }
+  return path;
+}
+
+/**
+ * Normalize a path for the current platform.
+ * On Windows, converts forward slashes to backslashes.
+ * On Unix, ensures forward slashes.
+ */
+export function normalizePath(path) {
+  return normalize(path);
+}
+
+/**
+ * Get platform-specific config directory.
+ * On Windows: %APPDATA%/agent-window or ~/.agent-window
+ * On Unix: ~/.config/agent-window or ~/.agent-window
+ */
+export function getConfigDir(appName = 'agent-window') {
+  if (process.platform === 'win32') {
+    // On Windows, prefer APPDATA, fallback to home
+    return process.env.APPDATA
+      ? join(process.env.APPDATA, appName)
+      : join(getHomeDir(), `.${appName}`);
+  }
+  // On Unix, use XDG_CONFIG_DIR if set, otherwise ~/.config
+  const configBase = process.env.XDG_CONFIG_HOME || join(getHomeDir(), '.config');
+  return join(configBase, appName);
+}
+
+/**
+ * Get platform-specific data directory.
+ * On Windows: %LOCALAPPDATA%/agent-window
+ * On macOS: ~/Library/Application Support/agent-window
+ * On Linux: ~/.local/share/agent-window
+ */
+export function getDataDir(appName = 'agent-window') {
+  if (process.platform === 'win32') {
+    return process.env.LOCALAPPDATA
+      ? join(process.env.LOCALAPPDATA, appName)
+      : join(getHomeDir(), `.${appName}`, 'data');
+  }
+  if (process.platform === 'darwin') {
+    return join(getHomeDir(), 'Library', 'Application Support', appName);
+  }
+  // Linux and others
+  const dataBase = process.env.XDG_DATA_HOME || join(getHomeDir(), '.local', 'share');
+  return join(dataBase, appName);
+}
+
+export default {
+  getHomeDir,
+  getAgentWindowHome,
+  getBotsDir,
+  getClaudeConfigDir,
+  expandTilde,
+  normalizePath,
+  getConfigDir,
+  getDataDir
+};