@ours.network/install 1.2.1-nightly.4 → 1.2.1-nightly.41

package/lib/setup-options.mjs

@@ -1,13 +1,16 @@
+import { hostname } from 'node:os';
+import { serverBase } from './gateway.mjs';
 import { join, resolve, isAbsolute, dirname } from 'node:path';
 
 const scopes = ['all', 'server', 'client'];
 const integrations = ['codex', 'claude-code', 'fleet'];
 const valueFlags = new Map(Object.entries({
-  '--scope': 'scope', '--action': 'operation', '--mode': 'mode', '--state-dir': 'stateDir',
-  '--identity-name': 'identityName', '--integrations': 'integrations', '--fleet-settings': 'fleetSettingsPath',
+  '--container-engine': 'containerEngine', '--server-url': 'serverUrl', '--scope': 'scope', '--action': 'operation', '--mode': 'mode', '--state-dir': 'stateDir',
+  '--username': 'localUsername', '--name': 'name', '--surname': 'surname', '--hostname': 'hostname',
+  '--identity-name': 'identityName', '--integrations': 'integrations', '--fleet-settings': 'fleetSettingsPath', '--fleet-task-workflow': 'fleetTaskWorkflowAgents',
   '--config': 'config', '--sources': 'sources', '--migrate-from': 'migrateFrom', '--port': 'port', '--cowork-port': 'coworkPort', '--messenger-port': 'messengerPort',
 }));
-const boolFlags = new Map([['--compatible', 'compatible'], ['--dry-run', 'dryRun'], ['--migrate', 'migrate']]);
+const boolFlags = new Map([['--compatible', 'compatible'], ['--dry-run', 'dryRun'], ['--migrate', 'migrate'], ['--disable-fleet-agents-setup', 'disableFleetAgentsSetup']]);
 const allowed = new Set([...valueFlags.values(), ...boolFlags.values(), 'interactive', 'explicitPorts']);
 const defaults = { port: 3050, coworkPort: 3052, messengerPort: 8420 };
 const paths = ['stateDir', 'config', 'sources', 'fleetSettingsPath', 'migrateFrom'];
@@ -15,7 +18,7 @@ const nonempty = value => typeof value === 'string' && value.trim().length > 0 &
 
 export function recommendedMode({ platform, arch, release = '' } = {}) {
   if (platform === 'linux' && /microsoft|wsl/i.test(release)) return { mode: 'docker', reason: 'Docker is recommended on Windows and WSL.' };
-  if (platform === 'linux' && arch === 'x64') return { mode: 'packages', reason: 'Native packages are recommended on Linux x64 with a systemd user manager.' };
+  if (platform === 'linux' && arch === 'x64') return { mode: 'docker', reason: 'Docker provides the integrated gateway for full-stack setup; native mode is server-only.' };
   if (platform === 'darwin') return { mode: 'docker', reason: 'Docker is recommended on macOS.' };
   if (platform === 'win32') return { mode: 'docker', reason: 'Docker is recommended on Windows; run the installer inside WSL with Docker Desktop.' };
   return { mode: 'docker', reason: 'Docker is recommended for this platform.' };
@@ -31,17 +34,51 @@ export function validateSetupOptions(input, { interactive = input?.interactive =
   const client = options.scope !== 'server';
   if (options.migrateFrom !== undefined && (!server || options.operation !== 'install')) throw new Error('--migrate-from requires server or all scope and operation install');
   if (options.migrateFrom !== undefined && (!nonempty(options.migrateFrom) || !isAbsolute(options.migrateFrom))) throw new Error('--migrate-from requires an absolute daemon config path');
+  const suppliedHuman = ['localUsername', 'name', 'surname'].some(key => options[key] !== undefined);
+  if (suppliedHuman) {
+    for (const key of ['localUsername', 'name', 'surname']) if (!nonempty(options[key])) throw new Error(`Missing human profile option: ${key}`);
+    if (!/^[a-z0-9][a-z0-9-]{0,29}$/.test(options.localUsername)) throw new Error('Local username must contain 1–30 lowercase letters, digits or hyphens');
+    for (const key of ['name', 'surname']) {
+      if (options[key].trim().length > 100) throw new Error(`${key} must contain at most 100 characters`);
+      options[key] = options[key].trim();
+    }
+    // Name and Surname together name the person's own identity, which Messenger runs as.
+    const person = `${options.name} ${options.surname}`;
+    if ([...person].length > 64 || person !== person.normalize('NFC') || /[\\/\p{Cc}\p{Cf}\p{Cs}\p{Zl}\p{Zp}]/u.test(person))
+      throw new Error('Name and Surname together must contain at most 64 NFC characters, including the space between them, without slashes or control characters');
+    options.hostname = options.hostname?.trim() || defaultHostname();
+    if (!/^[a-z0-9][a-z0-9-]{0,29}$/.test(options.hostname)) throw new Error('Hostname must contain 1–30 lowercase letters, digits or hyphens');
+    const identity = `${options.localUsername}@${options.hostname}`;
+    if (options.migrateFrom === undefined && options.identityName !== undefined && options.identityName !== identity) throw new Error('--identity-name conflicts with username and hostname');
+    if (options.migrateFrom === undefined) options.identityName = identity;
+  } else if (options.hostname !== undefined) throw new Error('--hostname requires username, name and surname');
+  if (options.disableFleetAgentsSetup !== undefined && typeof options.disableFleetAgentsSetup !== 'boolean') throw new Error('disableFleetAgentsSetup must be a boolean');
+  if (options.disableFleetAgentsSetup && options.fleetSettingsPath) throw new Error('--disable-fleet-agents-setup conflicts with --fleet-settings');
+  if (options.fleetTaskWorkflowAgents !== undefined) {
+    // Fleet owns what the workflow is; the installer only carries which agents the operator named.
+    const agents = options.fleetTaskWorkflowAgents;
+    if (!Array.isArray(agents) || !agents.length || agents.some(name => typeof name !== 'string' || !/^[A-Za-z0-9][A-Za-z0-9_-]{0,63}$/.test(name)) || new Set(agents).size !== agents.length)
+      throw new Error('--fleet-task-workflow requires unique Fleet agent names separated by commas');
+    if (!options.integrations?.includes?.('fleet')) throw new Error('--fleet-task-workflow requires the fleet integration');
+    if (options.disableFleetAgentsSetup) throw new Error('--fleet-task-workflow conflicts with --disable-fleet-agents-setup: no agents are configured by this run');
+    options.fleetTaskWorkflowAgents = [...agents];
+  }
   const missing = [];
   if (server) for (const [key, flag] of [['mode', '--mode'], ['stateDir', '--state-dir'], ...(options.migrateFrom === undefined ? [['identityName', '--identity-name']] : [])]) if (!nonempty(options[key])) missing.push(flag);
   if (client && options.integrations === undefined) missing.push('--integrations (use none to skip)');
   if (!server && !nonempty(options.config)) missing.push('--config');
   if (server && (options.operation === 'update' || options.migrateFrom !== undefined) && options.compatible !== true) missing.push('--compatible');
-  if (Array.isArray(options.integrations) && options.integrations.includes('fleet') && !interactive && !nonempty(options.fleetSettingsPath)) missing.push('--fleet-settings');
+  if (Array.isArray(options.integrations) && options.integrations.includes('fleet') && !interactive && !options.disableFleetAgentsSetup && !nonempty(options.fleetSettingsPath)) missing.push('--fleet-settings');
   if (missing.length) throw new Error(`Missing required setup options: ${missing.join(', ')}`);
   if (options.mode === 'native') options.mode = 'packages';
   if (server && !['packages', 'docker'].includes(options.mode)) throw new Error('Mode must be packages (or native) or docker');
+  if (options.containerEngine !== undefined && (!server || options.mode !== 'docker' || !['docker', 'podman'].includes(options.containerEngine))) throw new Error('--container-engine docker|podman requires server container mode');
+  if (options.serverUrl !== undefined) {
+    if (!server || options.mode !== 'docker' || options.operation !== 'install') throw new Error('--server-url requires Docker server installation');
+    options.serverUrl = serverBase(options.serverUrl);
+  }
   if (server && options.config !== undefined) throw new Error('--config is only valid for client scope');
-  if (!server) for (const key of ['mode', 'stateDir', 'identityName', ...Object.keys(defaults), 'compatible', 'migrate']) {
+  if (!server) for (const key of ['mode', 'stateDir', 'identityName', 'localUsername', 'name', 'surname', 'hostname', ...Object.keys(defaults), 'compatible', 'migrate']) {
     if (options[key] !== undefined) throw new Error(`${key} is only valid for server or all scope`);
   }
   if (!client && (options.integrations !== undefined || options.fleetSettingsPath !== undefined)) throw new Error('--integrations and --fleet-settings require all or client scope');
@@ -84,7 +121,7 @@ function expandPaths(options, home) {
   return output;
 }
 
-export function parseSetupArgs(argv, { home } = {}) {
+export function parseSetupArgs(argv, { home, validate = true } = {}) {
   if (!Array.isArray(argv) || !argv.every(arg => typeof arg === 'string')) throw new Error('Arguments must be strings');
   const options = { interactive: false, explicitPorts: [] };
   const seen = new Set();
@@ -107,6 +144,7 @@ export function parseSetupArgs(argv, { home } = {}) {
     if (!nonempty(value) || value.startsWith('--')) throw new Error(`${flag} requires a value`);
     const key = valueFlags.get(flag);
     if (key === 'integrations') put(key, value === 'none' ? [] : value.split(',').map(item => item.trim()));
+    else if (key === 'fleetTaskWorkflowAgents') put(key, value.split(',').map(item => item.trim()));
     else if (Object.hasOwn(defaults, key)) {
       if (!/^[1-9]\d*$/.test(value)) throw new Error(`${flag} requires an integer port`);
       put(key, Number(value)); options.explicitPorts.push(key);
@@ -115,30 +153,34 @@ export function parseSetupArgs(argv, { home } = {}) {
   if (positional.length && scopes.includes(positional[0])) put('scope', positional.shift());
   if (positional.length && ['install', 'update'].includes(positional[0])) put('operation', positional.shift());
   if (positional.length) throw new Error(`Unexpected setup argument: ${positional.join(' ')}`);
-  return validateSetupOptions(expandPaths(options, home), { interactive: false });
+  return validate ? validateSetupOptions(expandPaths(options, home), { interactive: false }) : expandPaths(options, home);
 }
 
-export async function collectSetupOptions(effects) {
+export function defaultHostname() {
+  return hostname().toLowerCase().replace(/[^a-z0-9-]/g, '-').replace(/^[^a-z0-9]+/, '').slice(0, 30) || 'workspace';
+}
+
+export async function collectSetupOptions(effects, presets = {}) {
   if (effects.interactive !== true) throw new Error('Interactive setup requires a TTY; provide the complete CLI options instead');
-  const options = { interactive: true, explicitPorts: [] };
+  const options = { ...presets, interactive: true, explicitPorts: presets.explicitPorts ?? [] };
   const scopeChoices = [
     { value: 'all', label: 'Everything on this computer' },
     { value: 'server', label: 'Server only' },
     { value: 'client', label: 'Connect this computer to an existing server' },
   ];
   effects.out('Choose what this computer should do. Everything runs the server here and connects your selected apps; client-only uses a server you already have.');
-  options.scope = await effects.select('What would you like to set up?', scopeChoices, 'all');
+  options.scope ??= await effects.select('What would you like to set up?', scopeChoices, 'all');
   if (!scopes.includes(options.scope)) throw new Error('Scope must be all, server, or client');
   let existing;
   let pendingMigration;
   if (options.scope !== 'client') {
     const recommendedRoot = join(effects.home, '.ours-install');
     effects.out(`Stores the server programs and data, including identities and messages. The recommended folder is ${recommendedRoot}; choose another only if you want to manage its location yourself.`);
-    const location = await effects.select('Where should server programs and data be stored?', [
+    const location = options.stateDir ? 'preset' : await effects.select('Where should server programs and data be stored?', [
       { value: 'recommended', label: `Use the recommended folder (${recommendedRoot})` },
       { value: 'custom', label: 'Choose another folder' },
     ], 'recommended');
-    options.stateDir = location === 'recommended' ? recommendedRoot : await effects.askLine('Folder for server programs and data: ', recommendedRoot);
+    options.stateDir ??= location === 'recommended' ? recommendedRoot : await effects.askLine('Folder for server programs and data: ', recommendedRoot);
     options.stateDir = expandPaths({ stateDir: options.stateDir }, effects.home).stateDir;
     existing = effects.readJson(join(options.stateDir, 'installation.json'));
     const migrationJournal = existing?.legacyMigrationSource ? effects.readJson(join(options.stateDir, 'legacy-migration.json')) : null;
@@ -150,7 +192,7 @@ export async function collectSetupOptions(effects) {
     ? 'This folder already contains an installation. Update selects this installer’s release while retaining state; repair reinstalls the retained package selection.'
     : options.scope === 'client' ? 'Install connects your selected apps. Update refreshes their packages while keeping the server connection.'
       : 'Install creates a managed installation in the selected folder. Update requires an installation already recorded there.');
-  options.operation = !existing && options.scope !== 'client' ? 'install' : await effects.select('What should happen?', [
+  options.operation ??= !existing && options.scope !== 'client' ? 'install' : await effects.select('What should happen?', [
     { value: 'install', label: pendingMigration ? 'Resume the unfinished migration' : existing ? 'Repair this installation' : 'Install and configure' },
     { value: 'update', label: 'Update an existing installation' },
   ], existing && !pendingMigration ? 'update' : 'install');
@@ -160,7 +202,8 @@ export async function collectSetupOptions(effects) {
     const legacyState = nonempty(legacy?.stateDir) ? legacy.stateDir
       : legacy && legacy.stateDir === undefined && nonempty(effects.readJson(join(effects.home, '.ours', 'root.json'))?.name)
         ? join(effects.home, '.ours') : null;
-    if (pendingMigration) options.migrateFrom = pendingMigration;
+    if (options.migrateFrom) { /* Explicit selection is validated below. */ }
+    else if (pendingMigration) options.migrateFrom = pendingMigration;
     else if (legacyState) {
       effects.out(`Found an existing ours installation at ${legacyState}. Upgrade it to keep its identities, messages and settings. The old server will stop; its original state is kept as a recovery copy.`);
       if (await effects.ask('Upgrade this existing ours installation and keep its data?', true)) options.migrateFrom = defaultConfig;
@@ -184,41 +227,69 @@ export async function collectSetupOptions(effects) {
       if (!nonempty(root?.name)) throw new Error('Cannot read the existing Human identity name; choose the configuration file for a complete existing installation');
       options.identityName = root.name;
       effects.out(`Your existing Human identity, ${root.name}, will be retained; no replacement identity will be created. Migration keeps the original state, but compatibility with an older release cannot be guaranteed automatically.`);
-      options.compatible = await effects.ask('Proceed with this release and keep the original state as a recovery copy?', false);
+      options.compatible ??= await effects.ask('Proceed with this release and keep the original state as a recovery copy?', false);
       if (!options.compatible) throw new Error('Migration requires explicit compatibility confirmation (--compatible)');
     }
   }
   if (options.scope !== 'client') {
     const recommendation = recommendedMode({ ...effects.platform, arch: effects.platform?.arch ?? process.arch });
-    effects.out(`${recommendation.reason} Native runs directly on this computer; Docker runs in containers and needs Docker installed and running. An existing installation must keep its current mode.`);
-    options.mode = await effects.select('How should the server run?', [
-      { value: 'packages', label: 'Native packages' }, { value: 'docker', label: 'Docker' },
-    ], existing?.mode ?? recommendation.mode);
+    // Native runs the server only: local clients need the container gateway. A retained
+    // native installation keeps its mode, so a full setup of it cannot finish.
+    // (An unfinished migration is resumed in its recorded mode and is validated with the plan.)
+    if (options.scope === 'all' && existing?.mode === 'packages' && !options.migrateFrom)
+      throw new Error('This installation runs natively, which supports the server only. Choose the server-only setup to maintain it (ours-install server); local clients need an installation that runs in Docker or Podman. Nothing was changed.');
+    const nativeOffered = options.scope === 'server' || existing?.mode === 'packages';
+    effects.out(nativeOffered
+      ? `${recommendation.reason} Native runs directly on this computer; Docker runs in containers and needs Docker installed and running. An existing installation must keep its current mode.`
+      : 'The server runs in containers. Docker and Podman both work; the one you choose must be installed and running. An existing installation must keep its current mode.');
+    const runtime = options.mode ?? await effects.select('How should the server run?', [
+      ...(nativeOffered ? [{ value: 'packages', label: 'Native packages' }] : []), { value: 'docker', label: 'Docker' }, { value: 'podman', label: 'Podman' },
+    ], existing?.mode === 'docker' && existing?.containerEngine === 'podman' ? 'podman' : existing?.mode ?? recommendation.mode);
+    options.mode = runtime === 'podman' ? 'docker' : runtime;
+    if (runtime === 'podman') options.containerEngine = 'podman';
     if (!options.migrateFrom) {
-      effects.out(existing ? 'Existing identities and names are retained. This name is used only if a Human identity needs to be created.' : 'Choose the name other people and agents should see for your Human identity.');
-      options.identityName = await effects.askLine('What name should others see? ', existing?.messengerIdentity ?? effects.username?.() ?? 'me');
+      if (existing?.messengerIdentity) {
+        effects.out(`Existing Human identity ${existing.messengerIdentity} and Messenger profile will be retained.`);
+        // Supplied profile inputs never rename a retained root.
+        if (!['localUsername', 'name', 'surname'].some(key => options[key] !== undefined)) options.identityName ??= existing.messengerIdentity;
+      } else if (options.identityName === undefined || options.localUsername !== undefined) {
+        effects.out('Choose a local username (no global uniqueness check). Name and Surname appear in Messenger; the optional host name identifies this workspace.');
+        options.localUsername ??= await effects.askLine('Local username: ', (effects.username?.() ?? 'me').toLowerCase().replace(/[^a-z0-9-]/g, '-').slice(0, 30));
+        options.name ??= await effects.askLine('Name: ', '');
+        options.surname ??= await effects.askLine('Surname: ', '');
+        options.hostname ??= await effects.askLine('Host / machine name (optional): ', '');
+      }
+    }
+    if (['localUsername', 'name', 'surname'].some(key => options[key] !== undefined)) {
+      // Partial profile presets still collect missing fields on retained and
+      // migration paths; these inputs never replace their authoritative root.
+      effects.out('Name and Surname initialize a missing Messenger profile; an existing profile is retained.');
+      options.localUsername ??= await effects.askLine('Local username: ', (effects.username?.() ?? 'me').toLowerCase().replace(/[^a-z0-9-]/g, '-').slice(0, 30));
+      options.name ??= await effects.askLine('Name: ', '');
+      options.surname ??= await effects.askLine('Surname: ', '');
+      options.hostname ??= await effects.askLine('Host / machine name (optional): ', '');
     }
-    for (const [key, fallback] of Object.entries(defaults)) options[key] = existing?.[key] ?? fallback;
+    for (const [key, fallback] of Object.entries(defaults)) options[key] ??= existing?.[key] ?? fallback;
     if (options.operation === 'update') {
       effects.out('The update retains identities and messages and creates a recovery backup before changing stored state. Proceed only if you accept this release for your existing data; compatibility is not automatically guaranteed.');
-      options.compatible = await effects.ask('Proceed with this update and keep a recovery backup?', false);
+      options.compatible ??= await effects.ask('Proceed with this update and keep a recovery backup?', false);
     }
   } else {
     const savedProfile = join(effects.home, '.ours-client', 'profile.json');
     effects.out('A connection profile identifies the server and its private access credential. Reuse your saved connection or select a profile supplied by the server owner.');
-    const connection = await effects.select('Which server connection should this computer use?', [
+    const connection = options.config ? 'preset' : await effects.select('Which server connection should this computer use?', [
       { value: 'saved', label: 'Use the saved server connection' }, { value: 'file', label: 'Choose a connection profile file' },
     ], effects.readJson(savedProfile) ? 'saved' : 'file');
-    options.config = connection === 'saved' ? savedProfile : await effects.askLine('Connection profile file: ', savedProfile);
+    options.config ??= connection === 'saved' ? savedProfile : await effects.askLine('Connection profile file: ', savedProfile);
   }
   if (options.scope !== 'server') {
     const detected = typeof effects.detectHarnesses === 'function' ? await effects.detectHarnesses() : [];
     const selected = integrations.filter(name => name === 'fleet' || detected.some(item => item.name === name && item.status === 'ok'));
     effects.out('Choose the apps to connect. Detected agent apps are selected by default; Fleet configures persistent agents but leaves them stopped. Use Space to toggle choices, then Enter to continue. You can select none.');
-    options.integrations = await effects.multiselect('Which integrations should be configured?', [
+    options.integrations ??= await effects.multiselect('Which integrations should be configured?', [
       { value: 'codex', label: 'Codex' }, { value: 'claude-code', label: 'Claude Code' }, { value: 'fleet', label: 'Fleet — persistent agents' },
     ], selected);
-    if (options.integrations.includes('fleet')) {
+    if (options.integrations.includes('fleet') && !options.disableFleetAgentsSetup && !options.fleetSettingsPath) {
       effects.out('Fleet needs model and agent settings. Its guided setup asks for these later; a prepared settings file applies your existing choices. Fleet roles will not start automatically.');
       const fleetMode = await effects.select('How should Fleet be configured?', [
         { value: 'wizard', label: 'Configure interactively with Fleet' }, { value: 'file', label: 'Use a prepared settings file' },

package/lib/setup.mjs

@@ -1,17 +1,19 @@
+import { validateGatewayClientProfile } from './target.mjs';
+import { gatewayAddress } from './gateway.mjs';
 import { inspectLegacyMigration } from './legacy-migration.mjs';
 import { join } from 'node:path';
 import { parseSetupArgs, collectSetupOptions, validateSetupOptions } from './setup-options.mjs';
 import { parseNetworkArgs, validateHostProfile, InstallUsageError } from './target.mjs';
-import { validateInstallation } from './plan.mjs';
+import { clientPackageNames, validateInstallation } from './plan.mjs';
 import { runServerCommand, runClientCommand } from './orchestrate.mjs';
 import { banner, heading, info, ok, warn, progress } from './ui.mjs';
 import { isCancel } from './prompt.mjs';
 import { USAGE } from './usage.mjs';
 import { validateIdentityName } from './server-onboarding.mjs';
 import { validateFleetSettings } from './fleet-settings.mjs';
+import { installerFailure } from './diagnostics.mjs';
 
-const maintenance = new Set(['status', 'start', 'stop', 'restart', 'rebuild', 'access-issue', 'access-replace', 'backup', 'restore', 'reset']);
-const clientPackages = integrations => [...new Set(['sdk', ...(integrations.includes('fleet') ? ['cli'] : []), ...integrations])];
+const maintenance = new Set(['status', 'start', 'stop', 'restart', 'uninstall', 'rebuild', 'gateway-enable', 'access-issue', 'access-replace', 'backup', 'restore', 'reset']);
 
 export function completeReleasePolicy(retained, supplied) {
   if (retained?.release) {
@@ -32,7 +34,9 @@ export async function prepareSetupPlan(options, effects) {
   options = validateSetupOptions(options, { interactive: options.interactive });
   if (effects.platform?.platform === 'win32') throw new InstallUsageError('Run ours-install inside WSL with Docker Desktop integration on Windows. Direct Windows Node installations are not supported.');
   const plan = { ...options };
-  if (options.scope !== 'server' && options.integrations.length) {
+  if (options.scope === 'all' && options.mode === 'packages' && options.integrations?.length)
+    throw new InstallUsageError('Gateway-only clients require a gateway. Use Docker full-stack setup, or install the native server separately and provision an HTTP gateway before client setup; nothing was changed.');
+  if (options.scope !== 'server') {
     for (const name of ['OURS_API_TOKEN', 'OURS_PORT', 'OURS_STATE_DIR', 'OURS_DAEMON_ID']) {
       if (effects.env?.[name]?.trim()) throw new InstallUsageError(`${name} conflicts with the selected client profile. Clear this override before full-stack/client setup; nothing was changed.`);
     }
@@ -54,6 +58,7 @@ export async function prepareSetupPlan(options, effects) {
     const value = effects.readJson(join(options.stateDir, 'installation.json'));
     if (value) {
       plan.existing = validateInstallation(value, options.stateDir);
+      if (options.containerEngine && options.containerEngine !== (plan.existing.containerEngine ?? 'docker')) throw new InstallUsageError('Container engine conflicts with retained installation');
       if (options.mode !== plan.existing.mode) throw new InstallUsageError('The selected mode conflicts with the retained installation; choose its existing mode or a separate empty directory');
       for (const key of ['port', 'coworkPort', 'messengerPort']) {
         if (options.explicitPorts?.includes(key) && options[key] !== plan.existing[key]) throw new InstallUsageError(`${key} conflicts with the retained installation`);
@@ -61,33 +66,33 @@ export async function prepareSetupPlan(options, effects) {
       }
       if (options.operation === 'install' && !options.migrateFrom) {
         const retained = readObject(effects, plan.existing.sourcesPath, 'Retained source policy');
-        plan.sourcePolicy = options.scope === 'server' || !options.integrations?.length ? retained : completeReleasePolicy(retained, options.sources ? policy : null);
+        plan.sourcePolicy = options.scope === 'server' ? retained : completeReleasePolicy(retained, options.sources ? policy : null);
       }
     } else if (options.operation === 'update') {
       throw new InstallUsageError('Update requires an existing installation.json; choose install for a new installation');
     }
     // Reject a local client already attached to another server before changing the server.
-    const saved = options.scope === 'all' && options.integrations.length ? effects.readManagedClientProfile() : null;
-    if (saved && (!plan.existing || saved.expectedInstanceId !== plan.existing.instanceId || saved.endpoint !== `http://127.0.0.1:${plan.port}`)) {
+    const saved = options.scope === 'all' ? effects.readManagedClientProfile() : null;
+    if (saved && (!plan.existing || saved.expectedInstanceId !== plan.existing.instanceId || saved.endpoint !== (plan.existing?.gateway ? gatewayAddress(plan.existing).base + '/daemon' : `http://127.0.0.1:${plan.port}`))) {
       throw new InstallUsageError('This user already has clients attached to a different server; their saved connection was not changed');
     }
   } else {
-    const profile = validateHostProfile(readObject(effects, options.config, 'Client profile'));
+    const profile = validateGatewayClientProfile(readObject(effects, options.config, 'Client profile'));
     if (!profile) throw new InstallUsageError('Client profile must contain endpoint, expectedInstanceId and credentialPath');
     if (!effects.readText(profile.credentialPath)?.trim()) throw new InstallUsageError('Client credential file is missing or empty');
     plan.profile = profile;
     const saved = effects.readManagedClientProfile();
-    if (saved && (saved.endpoint !== profile.endpoint || saved.expectedInstanceId !== profile.expectedInstanceId)) throw new InstallUsageError('Managed clients already select another server; existing connection was not changed');
+    if (saved && saved.expectedInstanceId !== profile.expectedInstanceId) throw new InstallUsageError('Managed clients already select another server; existing connection was not changed');
     if (saved && options.operation === 'install' && !options.sources) plan.sourcePolicy = readObject(effects, saved.installer.sourcesPath, 'Retained client source policy');
   }
   // Dry-run never spawns a resolver or acquires an installation lock.
   if (!options.dryRun) {
-    if (options.scope === 'all' && options.operation === 'update' && options.integrations.length) {
+    if (options.scope === 'all' && options.operation === 'update') {
       const running = await effects.serverLifecycle(plan.existing, 'status', ['daemon']);
       if (!running.includes('daemon')) throw new InstallUsageError('Full-stack update requires the selected daemon to be running for client verification. Start it first, or use server update to preserve its stopped state.');
     }
     if (options.scope !== 'client') await effects.resolveSourcePolicy(plan.sourcePolicy, 'server');
-    if (options.scope !== 'server' && options.integrations.length) await effects.resolveSourcePolicy(plan.sourcePolicy, 'client', clientPackages(options.integrations));
+    if (options.scope !== 'server') await effects.resolveSourcePolicy(plan.sourcePolicy, 'client', clientPackageNames(options.integrations));
   }
   return plan;
 }
@@ -100,7 +105,7 @@ export async function executeSetupPlan(plan, effects, { server = runServerComman
   if (plan.dryRun) {
     effects.out(info('Preview only. No packages, identities, credentials or services will be changed.'));
     if (plan.scope !== 'client') effects.out(info('Server: prerequisites → runtime preparation/update → retained identity/state restoration → readiness.'));
-    if (plan.scope !== 'server' && plan.integrations.length) effects.out(info('Clients: private connection → exact packages → selected integrations → Fleet settings when selected.'));
+    if (plan.scope !== 'server') effects.out(info('Clients: private connection → exact packages → selected integrations → Fleet settings when selected.'));
     return 0;
   }
   let clientConfig = plan.config;
@@ -110,6 +115,9 @@ export async function executeSetupPlan(plan, effects, { server = runServerComman
     const result = await server({ ...plan, role: 'server', operation: plan.operation, sourcePolicy: plan.sourcePolicy }, effects);
     if (result !== 0) return result;
     const record = validateInstallation(effects.readJson(join(plan.stateDir, 'installation.json')), plan.stateDir);
+    if (plan.name && plan.surname && plan.operation === 'install') {
+      await effects.serverEnsureHumanProfile(record, { name: plan.name, surname: plan.surname });
+    }
     if (plan.operation === 'update') {
       effects.out(progress(0, 1, 'Retained identities', 'Verify the Human identity after state restoration; existing names and keys are retained.'));
       const running = await effects.serverLifecycle(record, 'status', ['daemon']);
@@ -118,21 +126,23 @@ export async function executeSetupPlan(plan, effects, { server = runServerComman
         effects.out(ok('Retained identities verified.'));
       } else effects.out(info('Daemon remains stopped; stored identities are retained and will restore on the next start.'));
     }
-    if (plan.scope === 'all' && plan.integrations.length) {
+    if (plan.scope === 'all') {
       clientPolicy = completeReleasePolicy(readObject(effects, record.sourcesPath, 'Server source policy'), plan.sourcePolicy);
       effects.out(heading('Connect local clients'));
       const handoff = await effects.prepareLocalClient(record, plan.integrations, plan.fleetSettingsPath);
       clientConfig = handoff.configPath;
     }
   }
-  if (plan.scope !== 'server' && plan.integrations.length) {
+  if (plan.scope !== 'server') {
     const result = await client({ role: 'client', operation: 'install', config: clientConfig,
       integrations: plan.integrations, fleetSettingsPath: plan.fleetSettingsPath, sourcePolicy: clientPolicy,
+      disableFleetAgentsSetup: plan.disableFleetAgentsSetup, fleetTaskWorkflowAgents: plan.fleetTaskWorkflowAgents,
       preset: true, nonInteractive: !plan.interactive }, effects);
     if (result !== 0) return result;
   }
+  if (plan.disableFleetAgentsSetup && plan.integrations?.includes('fleet')) effects.out(info('Fleet is installed. Run ours-fleet setup-tunnel with the expiring one-use payload from the App command; a compatible Fleet prints the QR and connection code automatically. Configure agents and models in the App after linking.'));
   effects.out(ok(`Requested ${plan.operation} completed. Existing identities were retained.`));
-  if (plan.integrations?.includes('fleet')) effects.out(info('Fleet is configured but stopped. Review its settings, then run ours-fleet doctor, ours-fleet config and ours-fleet up.'));
+  if (plan.integrations?.includes('fleet') && !plan.disableFleetAgentsSetup) effects.out(info('Fleet is configured but stopped. Review its settings, then run ours-fleet doctor, ours-fleet config and ours-fleet up.'));
   return 0;
 }
 
@@ -144,12 +154,20 @@ export async function runSetup(argv, effects) {
     if (argv[0] === 'server' && maintenance.has(argv[1])) return await runServerCommand(parseNetworkArgs(argv), effects);
     if (!argv.length && effects.env?.OURS_ASSUME_YES) throw new InstallUsageError('OURS_ASSUME_YES cannot fill an interactive setup plan. Supply complete CLI presets for unattended installation.');
     if (!argv.length) { effects.out(banner()); effects.out(heading('Interactive setup')); }
-    const options = argv.length ? parseSetupArgs(argv, { home: effects.home }) : await collectSetupOptions(effects);
+    let options;
+    if (argv.length) {
+      const presets = parseSetupArgs(argv, { home: effects.home, validate: false });
+      try { options = validateSetupOptions(presets, { interactive: false }); }
+      catch (error) {
+        if (!effects.interactive || effects.env?.OURS_ASSUME_YES || !/^Missing (required setup options|human profile option):/.test(error.message)) throw error;
+        options = await collectSetupOptions(effects, presets);
+      }
+    } else options = await collectSetupOptions(effects);
     const plan = await prepareSetupPlan(options, effects);
     return await executeSetupPlan(plan, effects);
   } catch (error) {
     if (isCancel(error)) { effects.out(warn('Installation cancelled.')); return 130; }
-    effects.out(warn(`ours-install: ${error.message}`));
+    effects.out(warn(`ours-install: ${installerFailure(error, effects.env)}`));
     return 2;
   }
 }

package/lib/target.mjs

@@ -1,3 +1,4 @@
+import { serverBase } from './gateway.mjs';
 // ours-install v3 — argument handling and daemon detection.
 //
 // Pure argument handling and daemon-target selection. The orchestrator
@@ -85,17 +86,30 @@ export function validateHostProfile(value) {
   const mixed = LEGACY_PROFILE_KEYS.filter((key) => Object.hasOwn(value, key));
   if (mixed.length) throw profileError(`legacy selection keys cannot be mixed with a host profile (${mixed.join(', ')}).`);
   const { endpoint, expectedInstanceId, credentialPath } = value;
-  if (typeof endpoint !== 'string' || endpoint.trim() !== endpoint || endpoint === '') throw profileError('endpoint must be a non-empty HTTP origin.');
+  if (typeof endpoint !== 'string' || endpoint.trim() !== endpoint || endpoint === '') throw profileError('endpoint must be a non-empty HTTP or HTTPS base URL.');
   if (typeof expectedInstanceId !== 'string' || !PROFILE_UUID.test(expectedInstanceId)) throw profileError('expectedInstanceId must be a lowercase UUID.');
   if (typeof credentialPath !== 'string' || credentialPath === '' || !credentialPath.startsWith('/') || resolve(credentialPath) !== credentialPath) {
     throw profileError('credentialPath must be a normalized absolute path.');
   }
   let url;
-  try { url = new URL(endpoint); } catch { throw profileError('endpoint must be an HTTP origin.'); }
-  if (url.protocol !== 'http:' || url.username || url.password || url.pathname !== '/' || url.search || url.hash) {
-    throw profileError('endpoint must be an HTTP origin without credentials, path, query, or fragment.');
+  try { url = new URL(endpoint); } catch { throw profileError('endpoint must be an HTTP or HTTPS base URL.'); }
+  if ((url.protocol !== 'http:' && url.protocol !== 'https:') || url.username || url.password || url.search || url.hash) {
+    throw profileError('endpoint must be an HTTP or HTTPS base URL without credentials, query, or fragment.');
   }
-  return { endpoint: url.origin, expectedInstanceId, credentialPath };
+  const endpointBase = serverBase(endpoint);
+  if (value.serverUrl !== undefined) {
+    const serverUrl = serverBase(value.serverUrl);
+    if (endpointBase !== serverUrl + '/daemon') throw profileError('endpoint must select serverUrl/daemon.');
+    return { serverUrl, endpoint: endpointBase, expectedInstanceId, credentialPath };
+  }
+  return { endpoint: endpointBase, expectedInstanceId, credentialPath };
+}
+
+/** Client installs require the single gateway even when a legacy server profile exists. */
+export function validateGatewayClientProfile(value) {
+  if (!value || typeof value.serverUrl !== 'string') throw profileError('serverUrl is required; enable the server gateway and import its client profile. Direct daemon endpoints are not client routes.');
+  const serverUrl = serverBase(value.serverUrl);
+  return validateHostProfile({ ...value, endpoint: value.endpoint ?? serverUrl + '/daemon' });
 }
 
 export function resolveProfileSelection({ args, env = {}, home = homedir(), exists, readProfile }) {
@@ -454,10 +468,11 @@ export function searchFreePort(isTaken, { floor = FREE_PORT_FLOOR, reserved = IN
 export function parseNetworkArgs(argv) {
   if (!['server', 'client'].includes(argv[0])) return null;
   const [role, operation] = argv;
-  const operations = role === 'client' ? ['install'] : ['install', 'status', 'start', 'stop', 'restart', 'access-issue', 'access-replace', 'backup', 'restore', 'reset', 'update', 'rebuild'];
+  const operations = role === 'client' ? ['install'] : ['install', 'status', 'start', 'stop', 'restart', 'uninstall', 'access-issue', 'access-replace', 'backup', 'restore', 'reset', 'update', 'rebuild', 'gateway-enable'];
   if (!operations.includes(operation)) throw new InstallUsageError(`Unsupported ${role} operation: ${operation ?? '(missing)'}`);
   const allowed = role === 'client' ? ['config'] : ['state-dir'];
-  if (role === 'server' && operation === 'install') allowed.push('mode', 'sources', 'migrate');
+  if (role === 'server' && operation === 'install') allowed.push('mode', 'sources', 'migrate', 'container-engine');
+  if (role === 'server' && ['install', 'gateway-enable'].includes(operation)) allowed.push('server-url');
   if (operation === 'access-issue') allowed.push('output');
   if (['access-replace', 'reset'].includes(operation)) allowed.push('confirm');
   if (['restore', 'update'].includes(operation)) allowed.push('compatible');
@@ -486,13 +501,14 @@ export function parseNetworkArgs(argv) {
     } else {
       const value = inline ?? argv[++i];
       if (!value || value.startsWith('--')) throw new InstallUsageError(`--${name} requires a value`);
-      result[key] = name === 'mode' ? value : resolve(value);
+      result[key] = ['mode', 'container-engine'].includes(name) ? value : name === 'server-url' ? serverBase(value) : resolve(value);
     }
   }
   const required = role === 'client' ? [] : ['stateDir'];
   if (operation === 'access-issue') required.push('output');
   if (['access-replace', 'reset'].includes(operation)) required.push('confirm');
   for (const key of required) if (!result[key]) throw new InstallUsageError(`${operation} requires --${key.replace(/[A-Z]/g, c => '-' + c.toLowerCase())}`);
+  if (result.containerEngine !== undefined && (result.mode !== 'docker' || !['docker', 'podman'].includes(result.containerEngine))) throw new InstallUsageError('--container-engine docker|podman requires --mode docker');
   if (result.mode && !['packages', 'docker'].includes(result.mode)) throw new InstallUsageError('--mode must be packages or docker');
   return result;
 }

package/lib/uninstall.mjs

@@ -174,13 +174,13 @@ export function planDaemonRemoval({ stateDir, cliStartedIt }) {
   const service = {
     id: 'service',
     unit: unit.ok ? unit.unit : null,
-    command: ['ours', 'daemon', 'uninstall-service', '--yes', '--state-dir', dir, '--config', join(dir, 'config.json')],
+    command: ['ours-daemon', 'uninstall-service', '--yes', '--state-dir', dir, '--config', join(dir, 'config.json')],
     note: 'removes the unit managed by the ours CLI',
   };
   return [
     service,
     cliStartedIt
-      ? { id: 'stop', command: ['ours', 'daemon', 'stop', '--state-dir', dir, '--config', join(dir, 'config.json')] }
+      ? { id: 'stop', command: ['ours-daemon', 'stop', '--state-dir', dir, '--config', join(dir, 'config.json')] }
       : { id: 'stop-external', command: null, continues: true, note: 'this daemon was not started by the CLI; naming its launcher and continuing' },
   ];
 }

package/lib/usage.mjs

@@ -1,10 +1,15 @@
 // Public setup and maintenance commands.
-export const USAGE = `ours-install — interactive setup or complete CLI presets.
+export const USAGE = `ours-install — interactive setup with optional CLI presets.
 
   ours-install
     Opens the console form. Choose all (server + clients), server, or client;
     runtime, installation directory, identity, integrations and Fleet settings.
-    Linux x64 recommends native; macOS/Windows recommend Docker. Windows uses WSL.
+    Full setup runs the server in Docker or Podman, which provide the gateway local clients need.
+    Native mode is offered for server-only setup. Windows uses WSL.
+
+  Install now, configure Fleet agents in the App after linking:
+    ours-install --username alex --name Alex --surname Taylor --disable-fleet-agents-setup
+    Remaining installation choices are prompted on a terminal. No enrollment credentials or expiry.
 
   Full stack, with every required answer preset (no prompts):
     ours-install --mode docker --state-dir /private/ours --identity-name "Your Name" --integrations codex,fleet --fleet-settings /private/fleet.json
@@ -22,13 +27,21 @@ export const USAGE = `ours-install — interactive setup or complete CLI presets
   --scope all|server|client   preset which parts to configure (default all)
   --action install|update    equivalent to the positional operation
   --mode docker|native      packages is also accepted for native mode
+  --container-engine docker|podman  server container backend (default Docker); retained for maintenance
   --state-dir PATH          installation root; required for all/server
+  --username USERNAME       local username; no global uniqueness check
+  --name NAME               Messenger given name
+  --surname SURNAME         Messenger family name
+  --hostname NAME           optional host/workspace name; defaults to this machine
+  --disable-fleet-agents-setup  install Fleet CLI without its roles/model wizard
   --identity-name NAME      desired Human name for a fresh server; existing root is retained
   --integrations LIST       codex,claude-code,fleet; use none to skip clients explicitly
-  --fleet-settings PATH     JSON settings for Fleet; mandatory for CLI presets selecting Fleet
+  --fleet-settings PATH     JSON settings for Fleet; required unless Fleet agents setup is disabled
+  --fleet-task-workflow A[,B]  let these Fleet agents run Fleet task commands outside their command sandbox
   --config PATH             complete connection profile for client-only setup
   --sources PATH            explicit full development source policy override
-  --port N                  daemon port (default 3050 on a fresh installation)
+  --port N                  public gateway port for Docker (default 3050; e.g. 4050)
+  --server-url URL          external gateway URL (Docker install; configure authenticated entry separately)
   --cowork-port N           cowork port (default 3052)
   --messenger-port N        messenger port (default 8420)
   --compatible              required for server updates and legacy state migration
@@ -39,13 +52,14 @@ export const USAGE = `ours-install — interactive setup or complete CLI presets
   --help, -h                show help
   --version, -V             print installer version
 
-CLI presets must be complete and never open the interactive form or a Fleet wizard.
-Missing answers are reported before installation. Both input modes run the same
+Partial CLI presets on a terminal ask for the remaining choices. Without a terminal,
+or with OURS_ASSUME_YES, supply complete CLI presets; missing answers fail before installation. Both input modes run the same
 installer with preparation, identity restoration, update and readiness progress.
 Fleet is configured but left stopped for operator review.
 
 Scoped maintenance:
-  ours-install server status|start|stop|restart|rebuild --state-dir PATH
+  ours-install server status|start|stop|restart|rebuild|uninstall --state-dir PATH
+  ours-install server gateway-enable --state-dir PATH [--server-url URL]
   ours-install server access-issue --state-dir PATH --output PATH
   ours-install server access-replace --state-dir PATH --confirm
   ours-install server backup|restore server|daemon|telegram|cowork|messenger LABEL --state-dir PATH