Add server targets and accessories foundation

Author: devalade

src/cli/commands/deploy.ts

@@ -2,33 +2,36 @@ import chalk from 'chalk';
 import { loadConfig } from '../../config/loader.js';
 import { DeployService } from '../../services/deploy.service.js';
 import { LoggingExecutor } from '../../infrastructure/ssh/logging-executor.js';
-import { runRemoteCommand } from '../runner.js';
+import { runRemoteCommandForTargets } from '../runner.js';
 import { ui } from '../ui.js';
 import type { ShipnodeConfig, ShipnodeApp } from '../../shared/types.js';
 import { getActiveApp } from '../../domain/workspace.js';
 import { getPm2Name } from '../../domain/pm2/apps.js';
+import { configForServer, getServerTargets, resolveServerName } from '../../domain/servers.js';
 
 export async function cmdDeploy(cwd: string, options: { dryRun?: boolean; skipBuild?: boolean; app?: string; config?: string }): Promise<void> {
   const config = await loadConfig(cwd, options.config);
-  const targetConfig = options.app
-    ? { ...config, apps: [getActiveApp(config, options.app)] }
-    : config;
+  const selectedApp = options.app ? getActiveApp(config, options.app) : undefined;
+  const targetConfig = selectedApp ? { ...config, apps: [selectedApp] } : config;
 
   if (options.dryRun) {
     printDryRun(targetConfig, options.skipBuild ?? false);
     return;
   }
 
-  await runRemoteCommand(
+  await runRemoteCommandForTargets(
     cwd,
-    async ({ config, executor }) => {
+    async ({ config, executor, serverName }) => {
+      const app = options.app ? config.apps.find((candidate) => candidate.name === options.app) : undefined;
       const deployConfig = options.app
-        ? { ...config, apps: [getActiveApp(config, options.app!)] }
+        ? { ...config, apps: app ? [app] : [] }
         : config;
+      if (deployConfig.apps.length === 0 && Object.keys(deployConfig.accessories ?? {}).length === 0) return;
 
       ui.banner();
       const names = deployConfig.apps.map((a) => a.name).join(', ');
-      ui.step(`Deploying ${chalk.bold(names)} → ${config.ssh.user}@${config.ssh.host}`);
+      const label = names || Object.keys(deployConfig.accessories ?? {}).join(', ');
+      ui.step(`Deploying ${chalk.bold(label)} → ${serverName} (${config.ssh.user}@${config.ssh.host})`);
 
       const deployer = new DeployService(new LoggingExecutor(executor), deployConfig);
       await deployer.execute(cwd, options.skipBuild ?? false);
@@ -45,12 +48,13 @@ export async function cmdDeploy(cwd: string, options: { dryRun?: boolean; skipBu
   );
 }
 
-function renderAppPlan(app: ShipnodeApp, skipBuild: boolean): string {
+function renderAppPlan(config: ShipnodeConfig, app: ShipnodeApp, skipBuild: boolean): string {
   const namespace = app.pm2?.apps[0]?.name;
   const web = app.pm2?.apps.find((a) => a.port !== undefined);
 
   const serverRows: [string, string][] = [
     ['App type', app.appType],
+    ['Server', resolveServerName(config, app.on)],
     ['App root', app.appRoot ?? '(repo root)'],
     ['Keep releases', String(app.keepReleases)],
   ];
@@ -114,18 +118,22 @@ function renderAppPlan(app: ShipnodeApp, skipBuild: boolean): string {
   ].join('\n');
 }
 
-function printDryRun(config: ShipnodeConfig, skipBuild: boolean): void {
+export function printDryRun(config: ShipnodeConfig, skipBuild: boolean): void {
   ui.banner();
 
+  const servers = getServerTargets(config).map((target) => `${target.name}=${target.ssh.user}@${target.ssh.host}:${target.ssh.port}`).join(', ');
   const header = [
     chalk.bold('Workspace'),
-    `  ${chalk.dim('Host'.padEnd(14))} ${config.ssh.user}@${config.ssh.host}:${config.ssh.port}`,
+    `  ${chalk.dim('Servers'.padEnd(14))} ${servers}`,
     `  ${chalk.dim('Remote path'.padEnd(14))} ${config.remotePath}`,
     `  ${chalk.dim('Node'.padEnd(14))} ${config.nodeVersion}`,
     `  ${chalk.dim('Apps'.padEnd(14))} ${config.apps.map((a) => a.name).join(', ')}`,
   ].join('\n');
 
-  const perApp = config.apps.map((app) => renderAppPlan(app, skipBuild)).join('\n\n');
+  const perApp = getServerTargets(config)
+    .map((target) => configForServer(config, target.name))
+    .flatMap((targetConfig) => targetConfig.apps.map((app) => renderAppPlan(config, app, skipBuild)))
+    .join('\n\n');
 
   ui.note([header, '', perApp].join('\n'), 'Dry run — no changes will be made');
 }

src/cli/commands/doctor.ts

@@ -1,13 +1,13 @@
-import { runRemoteCommand } from '../runner.js';
+import { runRemoteCommandForTargets } from '../runner.js';
 import { ui } from '../ui.js';
-import { getActiveApp } from '../../domain/workspace.js';
 import type { ShipnodeConfig } from '../../shared/types.js';
 
 export async function cmdDoctor(cwd: string, options: { config?: string; security?: boolean }): Promise<void> {
-  await runRemoteCommand(
+  await runRemoteCommandForTargets(
     cwd,
-    async ({ config, executor }) => {
+    async ({ config, executor, serverName }) => {
       ui.heading('ShipNode Doctor');
+      ui.heading(`Server: ${serverName} (${config.ssh.user}@${config.ssh.host})`);
 
       await checkLocal(config);
 
@@ -17,12 +17,11 @@ export async function cmdDoctor(cwd: string, options: { config?: string; securit
         await checkSecurity(config, executor);
       }
     },
-    { configPath: options.config },
+    { configPath: options.config, includeEmpty: true },
   );
 }
 
 function checkLocal(config: ShipnodeConfig): void {
-  const app = getActiveApp(config);
   ui.info('Checking local configuration...');
 
   const issues: string[] = [];
@@ -39,7 +38,7 @@ function checkLocal(config: ShipnodeConfig): void {
     issues.push('Remote path is not configured');
   }
 
-  if (app.appType === 'backend' && !app.pm2?.apps.length) {
+  if (config.apps.some((app) => app.appType === 'backend' && !app.pm2?.apps.length)) {
     issues.push('PM2 apps are not configured for backend app');
   }
 
@@ -53,15 +52,21 @@ function checkLocal(config: ShipnodeConfig): void {
 }
 
 async function checkRemote(
-  config: { ssh: { host: string; user: string }; remotePath: string },
+  config: ShipnodeConfig,
   executor: { exec: (cmd: string, opts?: { timeout?: number }) => Promise<{ stdout: string; exitCode: number }> },
 ): Promise<void> {
   ui.info('Checking remote server...');
 
+  const needsNode = config.apps.length > 0;
+  const needsPm2 = config.apps.some((app) => app.appType === 'backend' && app.pm2);
+  const needsCaddy = config.apps.some((app) => app.domain);
+  const needsDocker = Object.keys(config.accessories ?? {}).length > 0;
+
   const checks = [
-    { name: 'Node', cmd: 'node --version' },
-    { name: 'PM2', cmd: 'pm2 --version' },
-    { name: 'Caddy', cmd: 'caddy version' },
+    ...(needsNode ? [{ name: 'Node', cmd: 'node --version' }] : []),
+    ...(needsPm2 ? [{ name: 'PM2', cmd: 'pm2 --version' }] : []),
+    ...(needsCaddy ? [{ name: 'Caddy', cmd: 'caddy version' }] : []),
+    ...(needsDocker ? [{ name: 'Docker', cmd: 'docker --version' }] : []),
     { name: 'rsync', cmd: 'rsync --version' },
     { name: 'jq', cmd: 'jq --version' },
   ];
@@ -79,12 +84,14 @@ async function checkRemote(
     }
   }
 
-  ui.info('Checking deployment directory...');
-  const dirResult = await executor.exec(`test -d "${config.remotePath}" && echo "exists" || echo "missing"`);
-  if (dirResult.stdout === 'exists') {
-    ui.success(`Deployment directory exists: ${config.remotePath}`);
-  } else {
-    ui.warn(`Deployment directory does not exist. Run 'shipnode setup' first.`);
+  if (config.apps.length > 0) {
+    ui.info('Checking deployment directory...');
+    const dirResult = await executor.exec(`test -d "${config.remotePath}" && echo "exists" || echo "missing"`);
+    if (dirResult.stdout === 'exists') {
+      ui.success(`Deployment directory exists: ${config.remotePath}`);
+    } else {
+      ui.warn(`Deployment directory does not exist. Run 'shipnode setup' first.`);
+    }
   }
 }
 

src/cli/commands/setup.ts

@@ -1,6 +1,6 @@
 import { existsSync, readFileSync } from 'fs';
 import { Listr } from 'listr2';
-import { runRemoteCommand } from '../runner.js';
+import { runRemoteCommandForTargets } from '../runner.js';
 import { ui } from '../ui.js';
 import type { RemoteExecutor } from '../../domain/remote/executor.js';
 import type { ShipnodeConfig, NetworkDatabaseConfig } from '../../shared/types.js';
@@ -22,11 +22,11 @@ interface SetupOptions {
 }
 
 export async function cmdSetup(cwd: string, options: SetupOptions): Promise<void> {
-  await runRemoteCommand(
+  await runRemoteCommandForTargets(
     cwd,
-    async ({ config, executor }) => {
+    async ({ config, executor, serverName }) => {
       ui.banner();
-      ui.step(`Setting up ${config.ssh.user}@${config.ssh.host}`);
+      ui.step(`Setting up ${serverName} (${config.ssh.user}@${config.ssh.host})`);
       const created = !options.noDeployUser && (await bootstrapDeployUser(cwd, config, executor));
       await buildTasks(executor, config, created ? DEPLOY_USER : null).run();
       if (created) {
@@ -43,7 +43,7 @@ export async function cmdSetup(cwd: string, options: SetupOptions): Promise<void
         ui.outro('Server ready — run: shipnode deploy');
       }
     },
-    { configPath: options.config },
+    { configPath: options.config, includeEmpty: true },
   );
 }
 
@@ -99,6 +99,8 @@ function buildTasks(executor: RemoteExecutor, config: ShipnodeConfig, ownerUser:
   // so PM2 processes run as that user and `pm2-<user>.service` matches. Without
   // this, everything lands in root's home and deploy has no pm2 on their PATH.
   const targetHome = ownerUser ? `/home/${ownerUser}` : '$HOME';
+  const hasApps = config.apps.length > 0;
+  const hasAccessories = Object.keys(config.accessories ?? {}).length > 0;
 
   return new Listr(
     [
@@ -120,7 +122,7 @@ function buildTasks(executor: RemoteExecutor, config: ShipnodeConfig, ownerUser:
           },
         ], { concurrent: false }),
       },
-      {
+      ...(hasApps ? [{
         title: `Mise (version manager)${ownerUser ? ` for ${ownerUser}` : ''}`,
         task: () =>
           executor.execOrThrow(
@@ -129,8 +131,8 @@ function buildTasks(executor: RemoteExecutor, config: ShipnodeConfig, ownerUser:
               `if ! command -v mise &>/dev/null && [ ! -x "$HOME/.local/bin/mise" ]; then curl -fsSL https://mise.run | sh; fi`,
             ),
           ),
-      },
-      {
+      }] : []),
+      ...(hasApps ? [{
         title: `Node.js ${config.nodeVersion}`,
         task: (_ctx: object, task: any) => task.newListr([
           {
@@ -142,8 +144,8 @@ function buildTasks(executor: RemoteExecutor, config: ShipnodeConfig, ownerUser:
             task: () => executor.execOrThrow(asUser(ownerUser, `${mise}; mise use -g -y "node@${nodeVersion}"`)),
           },
         ], { concurrent: false }),
-      },
-      {
+      }] : []),
+      ...(hasApps && config.apps.some((app) => app.appType === 'backend' && app.pm2) ? [{
         title: 'PM2',
         task: (_ctx: object, task: any) => task.newListr([
           {
@@ -180,8 +182,8 @@ function buildTasks(executor: RemoteExecutor, config: ShipnodeConfig, ownerUser:
             ),
           },
         ], { concurrent: false }),
-      },
-      {
+      }] : []),
+      ...(hasApps && config.apps.some((app) => app.domain) ? [{
         title: 'Caddy',
         task: () =>
           executor.execOrThrow(
@@ -193,7 +195,23 @@ function buildTasks(executor: RemoteExecutor, config: ShipnodeConfig, ownerUser:
             '  $SUDO apt-get update && $SUDO apt-get install -y caddy; ' +
             'fi',
           ),
-      },
+      }] : []),
+      ...(hasAccessories ? [{
+        title: 'Docker',
+        task: () =>
+          executor.execOrThrow(
+            'SUDO=""; [ "$EUID" -ne 0 ] && SUDO="sudo"; ' +
+            'if ! command -v docker &>/dev/null; then ' +
+            '  $SUDO apt-get install -y ca-certificates curl gnupg; ' +
+            '  $SUDO install -m 0755 -d /etc/apt/keyrings; ' +
+            '  curl -fsSL https://download.docker.com/linux/ubuntu/gpg | $SUDO gpg --dearmor -o /etc/apt/keyrings/docker.gpg; ' +
+            '  $SUDO chmod a+r /etc/apt/keyrings/docker.gpg; ' +
+            '  echo "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu $(. /etc/os-release && echo $VERSION_CODENAME) stable" | $SUDO tee /etc/apt/sources.list.d/docker.list > /dev/null; ' +
+            '  $SUDO apt-get update && $SUDO apt-get install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin; ' +
+            'fi; ' +
+            '$SUDO systemctl enable docker && $SUDO systemctl start docker',
+          ),
+      }] : []),
       ...(config.database && config.database.type !== 'sqlite' && config.database.host === 'localhost'
         ? [{
             title: `Database (${config.database.type})`,
@@ -234,7 +252,7 @@ function buildTasks(executor: RemoteExecutor, config: ShipnodeConfig, ownerUser:
             },
           }]
         : []),
-      {
+      ...(hasApps ? [{
         title: 'Deployment directories',
         task: (_ctx: object, task: any) => task.newListr([
           {
@@ -248,7 +266,7 @@ function buildTasks(executor: RemoteExecutor, config: ShipnodeConfig, ownerUser:
                 : `mkdir -p "${config.remotePath}/releases" "${config.remotePath}/shared" "${config.remotePath}/.shipnode"`),
             ),
           },
-          {
+          ...(config.apps.some((app) => app.domain) ? [{
             title: 'Configure Caddy include',
             task: () => executor.execOrThrow(
               'SUDO=""; [ "$EUID" -ne 0 ] && SUDO="sudo"; ' +
@@ -257,9 +275,9 @@ function buildTasks(executor: RemoteExecutor, config: ShipnodeConfig, ownerUser:
               'echo "import /etc/caddy/conf.d/*.caddy" | $SUDO tee -a /etc/caddy/Caddyfile > /dev/null && ' +
               '$SUDO systemctl reload caddy 2>/dev/null || true',
             ),
-          },
+          }] : []),
         ], { concurrent: false }),
-      },
+      }] : []),
     ],
     { rendererOptions: { collapseErrors: false } },
   );

src/cli/commands/status.ts

@@ -1,16 +1,18 @@
-import { runRemoteCommand } from '../runner.js';
+import { runRemoteCommandForTargets } from '../runner.js';
 import { ui } from '../ui.js';
-import { getActiveApp } from '../../domain/workspace.js';
 import { getDeploymentName, getPm2Name } from '../../domain/pm2/apps.js';
 
 export async function cmdStatus(cwd: string, options: { config?: string; app?: string }): Promise<void> {
-  await runRemoteCommand(
+  await runRemoteCommandForTargets(
     cwd,
-    async ({ config, executor }) => {
+    async ({ config, executor, serverName }) => {
       const apps = options.app
-        ? [getActiveApp(config, options.app)]
+        ? config.apps.filter((app) => app.name === options.app)
         : config.apps;
 
+      if (apps.length === 0) return;
+      ui.heading(`Server: ${serverName} (${config.ssh.user}@${config.ssh.host})`);
+
       for (const app of apps) {
         ui.heading(`Status: ${app.name} (${app.appType})`);
 

src/cli/runner.ts

@@ -3,6 +3,7 @@ import { SshConnection } from '../infrastructure/ssh/connection.js';
 import type { RemoteExecutor } from '../domain/remote/executor.js';
 import { loadConfig } from '../config/loader.js';
 import { ui } from './ui.js';
+import { configForServer, getServerTargets } from '../domain/servers.js';
 
 /**
  * A command that operates against a remote host through an executor.
@@ -41,6 +42,35 @@ export async function runRemoteCommand(
   }
 }
 
+export async function runRemoteCommandForTargets(
+  cwd: string,
+  command: (ctx: { config: ShipnodeConfig; executor: RemoteExecutor; serverName: string }) => Promise<void>,
+  options: { configPath?: string; includeEmpty?: boolean } = {},
+): Promise<void> {
+  const config = await loadConfig(cwd, options.configPath);
+
+  try {
+    for (const target of getServerTargets(config)) {
+      const targetConfig = configForServer(config, target.name);
+      if (!options.includeEmpty && targetConfig.apps.length === 0 && Object.keys(targetConfig.accessories ?? {}).length === 0) {
+        continue;
+      }
+
+      const ssh = new SshConnection();
+      try {
+        await ssh.connect(target.ssh);
+        await command({ config: targetConfig, executor: ssh, serverName: target.name });
+      } finally {
+        ssh.disconnect();
+      }
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    ui.error(message);
+    process.exit(1);
+  }
+}
+
 /**
  * Run a local command that does not need a remote connection.
  *