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

package/lib/plan.mjs

@@ -1,3 +1,5 @@
+import { validateContainerEngine } from './container-engine.mjs';
+import { gatewayAddress } from './gateway.mjs';
 // ours-install v3 — daemon creation and boot-service installation.
 //
 // Pure planning code, like lib/target.mjs: the orchestrator
@@ -97,7 +99,7 @@ export function launchdLabelForStateDir(stateDir) {
 export function classifyUnit(text) {
   if (text === null || text === undefined) return { kind: 'absent' };
   const s = String(text);
-  if (s.startsWith(CLI_UNIT_MARKER)) return { kind: 'cli-managed' };
+  if ((s.startsWith(CLI_UNIT_MARKER) || s.startsWith('# Managed by @ours.network/daemon'))) return { kind: 'cli-managed' };
   const looksLikeOursMcp = /ExecStart=.*\bours-mcp\b/.test(s)
     || /^Description=ours MCP daemon\b/m.test(s)
     || (/^Environment=OURS_STATE_DIR=/m.test(s) && /^Environment=OURS_TRANSPORT=http$/m.test(s));
@@ -138,7 +140,7 @@ export function planServiceInstall({ stateDir, home, readText, platform = 'linux
       platform,
       reason: 'no-service-manager',
       message: `installing a boot service is not available on ${platform} — the ours CLI supports Linux user systemd and macOS launchd`,
-      manual: ['ours', 'daemon', 'serve', '--config'],
+      manual: ['ours-daemon', 'serve', '--config'],
     };
   }
 
@@ -224,7 +226,7 @@ export function serviceInstallCommand({ stateDir, adoptLegacyUnit = false }) {
   // --json so the caller can read back whether the unit actually CHANGED rather
   // than assuming it did. --force is reachable only through the explicit argument
   // above, and the CLI refuses to overwrite a unit it did not write.
-  const cmd = ['ours', 'daemon', 'install-service', '--yes', '--json', '--state-dir', dir, '--config', join(dir, 'config.json')];
+  const cmd = ['ours-daemon', 'install-service', '--yes', '--json', '--state-dir', dir, '--config', join(dir, 'config.json')];
   if (adoptLegacyUnit) cmd.push('--force');
   return cmd;
 }
@@ -265,20 +267,23 @@ export function planDaemonSteps(target, { cliVersionChanged = false, cliStartedI
   const steps = [{ id: 'cli', label: 'install the ours-sdk CLI', command: ['npm', 'i', '-g', '@ours.network/cli'] }];
   steps.push({ id: 'config', label: `write ${join(dir, 'config.json')}`, port: target.port });
   if (target.action === 'create') {
-    steps.push({ id: 'start', label: `start the daemon on port ${target.port}`, command: ['ours', 'daemon', 'start', '--config', join(dir, 'config.json')] });
+    steps.push({ id: 'start', label: `start the daemon on port ${target.port}`, command: ['ours-daemon', 'start', '--config', join(dir, 'config.json')] });
   } else if (cliVersionChanged) {
     // `ours daemon stop` refuses to signal a daemon it did not start, so a
     // daemon under another launcher is left running and the caller says which
     // launcher must be restarted instead.
     steps.push(cliStartedIt
-      ? { id: 'restart', label: 'restart the daemon (package version changed)', command: ['ours', 'daemon', 'restart', '--config', join(dir, 'config.json')] }
+      ? { id: 'restart', label: 'restart the daemon (package version changed)', command: ['ours-daemon', 'restart', '--config', join(dir, 'config.json')] }
       : { id: 'restart-external', label: 'daemon was not started by the CLI — restart it with its own launcher', command: null });
   }
   steps.push({ id: 'service', label: 'install the boot service', command: serviceInstallCommand({ stateDir: dir }) });
   return steps;
 }
 
-export const SERVER_PACKAGES = ['sdk', 'cli', 'mcp', 'tg-connector', 'cowork', 'messenger-server'].map(n => `@ours.network/${n}`);
+export const SERVER_PACKAGES = ['sdk', 'cli', 'daemon', 'tg-connector', 'cowork', 'messenger-server'].map(n => `@ours.network/${n}`);
+/** Selected when the policy names it; retained policies from before it existed stay valid. */
+export const NOTIFICATIONS_PACKAGE = '@ours.network/notifications';
+const serverPackages = manifest => [...SERVER_PACKAGES, ...(manifest?.packages?.[NOTIFICATIONS_PACKAGE] ? [NOTIFICATIONS_PACKAGE] : [])];
 export const SERVER_DEPENDENCIES = {
   daemon: [], telegram: ['daemon'], cowork: ['daemon'], messenger: ['daemon'],
 };
@@ -294,7 +299,7 @@ export function maintenanceServices(record, domain) {
 
 /** Validate exact supplied selections, without rewriting the source authority. */
 export function selectSourcePackages(manifest, role, clients = []) {
-  const names = role === 'server' ? SERVER_PACKAGES : clients.map(n => `@ours.network/${n}`);
+  const names = role === 'server' ? serverPackages(manifest) : clients.map(n => `@ours.network/${n}`);
   const result = {};
   for (const name of names) {
     const selected = manifest?.packages?.[name];
@@ -312,7 +317,7 @@ export function selectSourcePackages(manifest, role, clients = []) {
 /** Resolve a packaged compatibility policy into a role-filtered exact selection. */
 export async function resolveSourcePolicy(manifest, role, clients = [], resolveNpm) {
   const release = releaseBinding(manifest);
-  const names = role === 'server' ? SERVER_PACKAGES : clients.map(name => `@ours.network/${name}`);
+  const names = role === 'server' ? serverPackages(manifest) : clients.map(name => `@ours.network/${name}`);
   const packages = {};
   const sourceNames = new Set();
   for (const name of names) {
@@ -356,15 +361,21 @@ export function installationPaths(record) {
 }
 
 export function validateInstallation(record, root) {
+  if (record) validateContainerEngine(record);
   if (!record || ![1, 2].includes(record.schema) || !['docker', 'packages'].includes(record.mode)
     || record.root !== root || record.configPath !== installationPaths(record).config
     || record.sourcesPath !== join(root, 'sources.json') || record.workDir !== join(root, 'runtime')
     || !/^[0-9a-f]{8}(?:-[0-9a-f]{4}){3}-[0-9a-f]{12}$/.test(record.instanceId ?? '')
     || !/^ours-[a-z0-9]+$/.test(record.project ?? '')
     || (record.sourcePolicyHash !== undefined && !/^[0-9a-f]{64}$/.test(record.sourcePolicyHash))
-    || !Array.isArray(record.services) || record.services[0] !== 'daemon' || new Set(record.services).size !== record.services.length || record.services.some(s => !SERVER_SERVICES.includes(s))) {
+    || !Array.isArray(record.services) || record.services[0] !== 'daemon' || new Set(record.services).size !== record.services.length || record.services.some(s => !SERVER_SERVICES.includes(s) && !(s === 'gateway' && record.gateway?.version === 1))) {
     throw new Error('Invalid or conflicting installation selection');
   }
+  if (record.gateway !== undefined && (record.schema !== 2 || record.mode !== 'docker' || record.gateway?.version !== 1
+    || Object.keys(record.gateway).some(key => !['version', 'serverUrl'].includes(key)) || record.services.at(-1) !== 'gateway')) {
+    throw new Error('Invalid gateway installation selection');
+  }
+  if (record.gateway) gatewayAddress(record);
   if (record.layoutConversion !== undefined) {
     // DEPRECATED (introduced in 2.0): legacy managed-layout conversion only.
     // Removal target: 3.0, after supported installs convert and upgrade inputs
@@ -380,7 +391,8 @@ export function validateInstallation(record, root) {
       throw new Error('Invalid layout conversion record');
     }
     validateInstallation(source, root);
-    if (['mode', 'instanceId', 'project', 'sourcesPath', 'workDir'].some(key => source[key] !== record[key])
+    if (JSON.stringify(source.containerBinding) !== JSON.stringify(record.containerBinding)) throw new Error('Conflicting conversion backend');
+    if (['mode', 'containerEngine', 'instanceId', 'project', 'sourcesPath', 'workDir'].some(key => source[key] !== record[key])
       || JSON.stringify(source.services) !== JSON.stringify(record.services)
       || conversion.runningServices.some(service => !source.services.includes(service))) {
       throw new Error('Conflicting layout conversion source');
@@ -402,7 +414,7 @@ export function validateInstallation(record, root) {
       throw new Error('Invalid server build transition');
     }
     validateInstallation(candidate, candidate.root);
-    for (const key of ['schema', 'mode', 'instanceId', 'services', 'port', 'coworkPort', 'messengerPort', 'messengerIdentity', 'uid', 'gid']) {
+    for (const key of ['schema', 'mode', 'containerEngine', 'containerBinding', 'instanceId', 'services', 'gateway', 'port', 'coworkPort', 'messengerPort', 'messengerIdentity', 'uid', 'gid']) {
       if (JSON.stringify(candidate[key]) !== JSON.stringify(record[key])) throw new Error('Conflicting server build candidate');
     }
   }
@@ -470,3 +482,7 @@ export function consumerServiceState(text, service, platform) {
   }
   return matches === 1 ? selected : undefined;
 }
+
+export function clientPackageNames(integrations) {
+  return [...new Set(['sdk', 'cli', ...(integrations.some(name => ['codex', 'claude-code'].includes(name)) ? ['mcp'] : []), ...integrations])];
+}

package/lib/podman-preflight.mjs

@@ -0,0 +1,40 @@
+import { mkdtempSync, writeFileSync, rmSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { randomUUID } from 'node:crypto';
+import { runContainer } from './container-engine.mjs';
+
+export const PROBE_IMAGE = 'docker.io/library/nginx:1.28-alpine@sha256:a8b39bd9cf0f83869a2162827a0caf6137ddf759d50a171451b335cecc87d236';
+/** Behavioral checks, in disposable resources, before touching installation storage. */
+export async function qualifyPodman(effects, record) {
+  const root = mkdtempSync(join(tmpdir(), 'ours-podman-preflight-'));
+  const project = `ours-probe-${randomUUID()}`;
+  const file = join(root, 'compose.json'), overlay = join(root, 'reset.yaml');
+  const common = { image: PROBE_IMAGE, entrypoint: ['/bin/sh', '-ec'], read_only: true, cap_drop: ['ALL'], security_opt: ['no-new-privileges:true'] };
+  writeFileSync(file, JSON.stringify({ services: {
+    prepare: { ...common, user: '0:0', network_mode: 'none', cap_add: ['CHOWN', 'DAC_OVERRIDE'],
+      command: ['mkdir -p /storage/state/daemon /storage/state/sibling; chmod 700 /storage/state/daemon; chown 1000:1000 /storage/state/daemon'],
+      volumes: [{ type: 'volume', source: 'data', target: '/storage', volume: { nocopy: true } }] },
+    probe: { ...common, user: '1000:1000', command: ['test ! -e /data/sibling; test "$(stat -c %a /data)" = 700; nslookup -type=A probe.; echo ready > /data/probe; sleep 120'],
+      healthcheck: { test: ['CMD-SHELL', 'test -s /data/probe'], interval: '1s', timeout: '2s', retries: 10 },
+      volumes: [{ type: 'volume', source: 'data', target: '/data', volume: { nocopy: true, subpath: 'state/daemon' } }] },
+  }, volumes: { data: {} } }), { mode: 0o600 });
+  writeFileSync(overlay, 'services:\n  probe:\n    ports: !reset []\n', { mode: 0o600 });
+  const compose = args => runContainer(effects, record, ['compose', '-p', project, '-f', file, '-f', overlay, ...args], { timeout: 180000 });
+  try {
+    await compose(['config', '--format', 'json']);
+    await compose(['run', '--rm', '--no-deps', '-T', 'prepare']);
+    await compose(['up', '-d', '--no-build', '--wait', 'probe']);
+    const result = await compose(['ps', '--format', 'json']);
+    const rows = result.stdout.trim().startsWith('[') ? JSON.parse(result.stdout) : result.stdout.trim().split('\n').map(s => JSON.parse(s));
+    if (!rows.some(r => r.Service === 'probe' && r.State === 'running')) throw new Error('Compose JSON status is incompatible');
+    await compose(['exec', '-T', 'probe', '/bin/sh', '-ec', 'test -s /data/probe; test ! -e /data/state']);
+  } catch (cause) {
+    let logs = '';
+    try { logs = (await compose(['logs', '--no-color', '--tail', '30'])).stdout; } catch {}
+    throw new Error(`Podman capability check failed (Compose !reset/wait/status, DNS, rootless UID, volume subpath): ${cause.message}\n${logs}`, { cause });
+  } finally {
+    try { await compose(['down', '--volumes', '--remove-orphans']); }
+    finally { rmSync(root, { recursive: true, force: true }); }
+  }
+}

package/lib/server-onboarding.mjs

@@ -1,9 +1,12 @@
+import { gatewayAddress } from './gateway.mjs';
 /** Human bootstrap and local client handoff through the existing owner interfaces. */
 import { existsSync, lstatSync, mkdirSync, mkdtempSync, readFileSync, realpathSync, renameSync, rmSync, writeFileSync } from 'node:fs';
 import { join, resolve, isAbsolute } from 'node:path';
 import { randomUUID } from 'node:crypto';
 import { installationPaths } from './plan.mjs';
 import { validateHostProfile } from './target.mjs';
+/** Read by Fleet beside the profile credential; bound to one server installation. */
+export const NOTIFICATIONS_PRODUCER_FILE = 'notifications-producer.json';
 
 export function validateIdentityName(name) {
   if (typeof name !== 'string' || [...name].length < 1 || [...name].length > 64 || name !== name.normalize('NFC')
@@ -28,16 +31,67 @@ function validateRecord(record) {
 }
 
 export function createServerOnboarding(effects, { compose, localEnv, bin }) {
-  async function identityCommand(record, args) {
-    const result = record.mode === 'docker'
-      ? await compose(record, ['exec', '-T', 'daemon', 'node', '/opt/ours/node_modules/@ours.network/cli/dist/cli.js', ...args, '--config', '/var/lib/ours/config.json', '--state-dir', '/var/lib/ours', '--json'])
-      : await effects.run(bin(record, 'ours'), [...args, '--config', record.configPath, '--state-dir', installationPaths(record).daemon, '--json'], { env: localEnv(record) });
+  // CLI client commands only accept gateway profiles in current releases. Use
+  // the installed SDK against the selected local daemon and its private file.
+  const identityScript = `
+import { createRequire } from 'node:module';
+import { pathToFileURL } from 'node:url';
+import { randomUUID } from 'node:crypto';
+const selection = JSON.parse(process.argv[1]);
+const require = createRequire(selection.anchor);
+const { attachOursClient } = await import(pathToFileURL(require.resolve('@ours.network/sdk/client')).href);
+const client = await attachOursClient({ endpoint: selection.endpoint,
+  expectedInstanceId: selection.instanceId, credentialPath: selection.credentialPath,
+  sessionMode: 'external', leaseToken: randomUUID(), env: {} });
+// The lease this short-lived client takes is released exactly once. An operation is not reported as done
+// while that release is incomplete, and what failed first is what is reported.
+let output, released = false;
+try {
+  const result = selection.operation === 'list' ? await client.listIdentities()
+    : selection.operation === 'create-role' ? { created: await client.createIdentity({ name: selection.name, bio: '',
+        exposeLocal: true, localAutoAccept: true }), current: await client.currentIdentity() }
+    : selection.operation === 'describe-role' ? (await client.chooseIdentity({ name: selection.name, force: false }),
+        { current: await client.currentIdentity() })
+    : await client.createRootIdentity({ name: selection.name, bio: '',
+        exposeLocal: true, localAutoAccept: true, skipIfRootExists: true });
+  released = true;
+  const release = await client.releaseLease();
+  output = release?.failed > 0 ? { onboardingError: 'LEASE_RELEASE_INCOMPLETE' } : result;
+} catch (error) {
+  output = { onboardingError: error.code || 'OWNER_OPERATION_FAILED' };
+  if (!released) try { await client.releaseLease(); } catch {}
+} finally {
+  try { await client.close(); } catch {}
+}
+process.stdout.write(JSON.stringify(output));
+`;
+  async function identityCommand(record, operation, name) {
+    validateRecord(record);
+    const docker = record.mode === 'docker';
+    const selection = {
+      operation, ...(name === undefined ? {} : { name }),
+      endpoint: `http://127.0.0.1:${docker ? 3050 : record.port}`,
+      instanceId: record.instanceId,
+      credentialPath: docker ? '/var/lib/ours/daemon-token' : join(installationPaths(record).daemon, 'daemon-token'),
+      anchor: docker ? '/opt/ours/package.json' : join(record.workDir, 'package.json'),
+    };
+    const args = ['--input-type=module', '-e', identityScript, JSON.stringify(selection)];
+    const result = docker
+      ? await compose(record, ['exec', '-T', 'daemon', 'node', ...args])
+      : await effects.run(process.execPath, args, { env: localEnv(record), sensitive: true });
     if (result.code !== undefined && result.code !== 0) throw new Error('Owner identity operation failed');
-    try { return JSON.parse(result.stdout); }
+    let value;
+    try { value = JSON.parse(result.stdout); }
     catch { throw new Error('Owner identity operation returned malformed JSON'); }
+    if (value?.onboardingError) {
+      const error = new Error('Owner identity operation failed');
+      error.code = value.onboardingError;
+      throw error;
+    }
+    return value;
   }
   async function identities(record) {
-    const rows = await identityCommand(record, ['identity', 'list']);
+    const rows = await identityCommand(record, 'list');
     if (!Array.isArray(rows) || rows.some(row => !row || typeof row.name !== 'string'
         || (!['root', 'role'].includes(row.kind) && !['reconciling', 'awaiting-root', 'migration-failed', 'refresh-failed'].includes(row.status))
         || (row.kind && (typeof row.cid !== 'string' || !row.cid)))) throw new Error('Owner identity list is malformed');
@@ -59,10 +113,11 @@ export function createServerOnboarding(effects, { compose, localEnv, bin }) {
       if (prior.rows.some(row => row.name === name)) throw new Error('Requested Human identity name already exists; no identity was changed');
       effects.out?.(`Creating Human identity ${name}; retaining ${prior.rows.length} existing identities.`);
       try {
-        await identityCommand(record, ['identity', 'create-root', '--name', name, '--skip-if-root-exists', 'true']);
+        await identityCommand(record, 'create-root', name);
       } catch (error) {
-        // ROOT_EXISTS is currently a CLI error. A concurrent creator is safe only
+        // A concurrent creator is safe only
         // when the authoritative list now contains a root; other errors stay errors.
+        if (error.code !== 'ROOT_EXISTS') throw error;
         const after = await identities(record);
         if (after.root) return retained(after);
         throw error;
@@ -73,16 +128,98 @@ export function createServerOnboarding(effects, { compose, localEnv, bin }) {
       effects.out?.(`Human identity ${after.root.name} is ready.`);
       return { name: after.root.name, cid: after.root.cid, created: true };
     },
+    /**
+     * The person's own identity under the Human root, which Messenger runs as. An identity of that name is
+     * used only when the daemon itself describes it as a permanent role of exactly the retained root;
+     * nothing else is renamed or adopted.
+     */
+    async serverEnsureMessengerIdentity(record, name) {
+      validateRecord(record);
+      validateIdentityName(name);
+      const listed = row => row?.kind === 'role' && row.temp === null && typeof row.cid === 'string';
+      const taken = () => new Error('Requested Messenger identity name is already used by another identity; no identity was changed');
+      const prior = await identities(record);
+      if (!prior.root) throw new Error('Messenger identity requires the Human identity; no identity was changed');
+      // The list has no parent column. What the daemon describes for the identity, bound for a moment, names its root.
+      const under = (current, row) => current?.name === name && current.temporary === false && current.isRoot === false
+        && current.described === true && typeof current.roleId === 'string' && current.roleId !== ''
+        && typeof current.cid === 'string' && current.cid === row.cid
+        && typeof current.rootCid === 'string' && current.rootCid.toLowerCase() === String(prior.root.cid).toLowerCase();
+      const adopt = async rows => {
+        const row = rows.rows.find(candidate => candidate.name === name);
+        if (rows.root?.cid !== prior.root.cid || !listed(row)) throw taken();
+        const { current } = await identityCommand(record, 'describe-role', name);
+        if (!under(current, row)) throw taken();
+        return row;
+      };
+      if (prior.rows.some(row => row.name === name)) {
+        const row = await adopt(prior);
+        effects.out?.(`Retained Messenger identity ${name}.`);
+        return { name, cid: row.cid, created: false };
+      }
+      effects.out?.(`Creating Messenger identity ${name} under ${prior.root.name}; retaining ${prior.rows.length} existing identities.`);
+      let result;
+      try {
+        result = await identityCommand(record, 'create-role', name);
+      } catch (error) {
+        // Only a name collision can mean a concurrent creator; any other failure is reported as it is.
+        if (error.code !== 'NAME_TAKEN') throw error;
+        // That creator is accepted only when the authoritative list now shows the name under the same root.
+        const after = await identities(record);
+        if (!after.rows.some(row => row.name === name)) throw error;
+        const row = await adopt(after);
+        return { name, cid: row.cid, created: false };
+      }
+      const after = await identities(record);
+      const row = after.rows.find(candidate => candidate.name === name);
+      if (result?.created?.hierarchy !== 'role' || result.created.underRoot !== prior.root.name || after.root?.cid !== prior.root.cid
+          || !listed(row) || result.created.info?.cid !== row.cid || !under(result.current, row))
+        throw new Error('Messenger identity creation completed without a usable identity under the Human identity');
+      effects.out?.(`Messenger identity ${name} is ready.`);
+      return { name, cid: row.cid, created: true };
+    },
+    async serverEnsureHumanProfile(record, human) {
+      validateRecord(record);
+      for (const key of ['name', 'surname']) if (typeof human[key] !== 'string' || !human[key].trim() || human[key].length > 100 || /[\x00-\x1f\x7f]/.test(human[key])) throw new Error('Invalid Messenger human profile');
+      // Messenger owns the profile lifecycle. Never rename the daemon root or
+      // overwrite a profile already present on a retained installation.
+      const script = `
+import { readFileSync } from 'node:fs';
+const selection = JSON.parse(process.argv[1]);
+const token = readFileSync(selection.credentialPath, 'utf8').trim();
+const base = selection.base;
+async function request(path, value) {
+ const response = await fetch(base + '/api/' + path, { method: value === undefined ? 'GET' : 'POST', redirect: 'error', signal: AbortSignal.timeout(15000), headers: { 'X-Ours-Api-Token': token, ...(value === undefined ? {} : { 'Content-Type': 'application/json', Origin: selection.origin, 'X-Ours-Messenger-CSRF': '1' }) }, ...(value === undefined ? {} : { body: JSON.stringify(value) }) });
+ if (!response.ok) { await response.body?.cancel(); throw new Error('Messenger human profile operation failed (HTTP ' + response.status + ')'); }
+ return response.json();
+}
+const identity = await request('identity');
+if (identity.humanProfile) process.stdout.write('Retained Messenger Name and Surname.');
+else { await request('identity/profile', selection.human); process.stdout.write('Messenger Name and Surname initialized.'); }
+`;
+      const docker = record.mode === 'docker';
+      const selection = { base: `http://127.0.0.1:${docker ? 8420 : record.messengerPort}`,
+        // Behind the gateway Messenger accepts mutations only from the gateway origin.
+        origin: record.gateway ? gatewayAddress(record).origin : `http://127.0.0.1:${record.messengerPort}`,
+        credentialPath: docker ? '/credentials/messenger/daemon-token' : installationPaths(record).credentials.messenger,
+        human: { name: human.name, surname: human.surname } };
+      const args = ['--input-type=module', '-e', script, JSON.stringify(selection)];
+      const result = docker ? await compose(record, ['exec', '-T', 'messenger', 'node', ...args])
+        : await effects.run(process.execPath, args, { env: localEnv(record), sensitive: true });
+      if (result.code !== undefined && result.code !== 0) throw new Error('Messenger human profile initialization failed');
+      effects.out?.(result.stdout);
+    },
     async prepareLocalClient(record, integrations, fleetSettingsPath) {
       validateRecord(record);
-      if (!Array.isArray(integrations) || !integrations.length || new Set(integrations).size !== integrations.length
+      if (!Array.isArray(integrations) || new Set(integrations).size !== integrations.length
           || integrations.some(name => !['codex', 'claude-code', 'fleet'].includes(name))) throw new Error('Client integrations must select codex, claude-code and/or fleet');
       if (fleetSettingsPath !== undefined) {
         if (typeof fleetSettingsPath !== 'string' || !isAbsolute(fleetSettingsPath) || resolve(fleetSettingsPath) !== fleetSettingsPath) throw new Error('Fleet settings path must be absolute');
         const settings = JSON.parse(readFileSync(fleetSettingsPath, 'utf8'));
         if (!settings || typeof settings !== 'object' || Array.isArray(settings)) throw new Error('Fleet settings must be a JSON object');
       }
-      const endpoint = `http://127.0.0.1:${record.port}`;
+      const serverUrl = record.gateway ? gatewayAddress(record).base : undefined;
+      const endpoint = serverUrl ? `${serverUrl}/daemon` : `http://127.0.0.1:${record.port}`;
       const current = effects.readManagedClientProfile();
       if (current && (current.endpoint !== endpoint || current.expectedInstanceId !== record.instanceId)) throw new Error('Managed client already selects another server; no credential was issued');
       privatePath(record.root, true);
@@ -93,16 +230,27 @@ export function createServerOnboarding(effects, { compose, localEnv, bin }) {
       const published = join(root, 'issued-' + randomUUID());
       const credential = join(stage, 'credential');
       try {
-        effects.out?.('Issuing a separate local client credential with the retained server authority.');
-        try { await effects.serverAccess(record, 'access-issue', { output: credential }); }
-        catch { throw new Error('Client credential issuance failed; existing profiles were retained'); }
-        const stat = privatePath(credential);
-        if (stat.size > 4096 || !readFileSync(credential, 'utf8').trim()) throw new Error('Issued client credential is empty or invalid');
+        if (!current) {
+          effects.out?.('Issuing a separate local client credential with the retained server authority.');
+          try { await effects.serverAccess(record, 'access-issue', { output: credential }); }
+          catch (cause) { throw new Error('Client credential issuance failed; existing profiles were retained', { cause }); }
+        }
+        const retainedCredential = current?.credentialPath ?? credential;
+        const stat = privatePath(retainedCredential);
+        if (stat.size > 4096 || !readFileSync(retainedCredential, 'utf8').trim()) throw new Error('Issued client credential is empty or invalid');
         const profile = {
-          ...validateHostProfile({ endpoint, expectedInstanceId: record.instanceId, credentialPath: join(published, 'credential') }),
+          ...validateHostProfile({ ...(serverUrl ? { serverUrl } : {}), endpoint, expectedInstanceId: record.instanceId, credentialPath: current?.credentialPath ?? join(published, 'credential') }),
           installer: { integrations: [...integrations], ...(fleetSettingsPath !== undefined ? { fleetSettingsPath } : {}) },
         };
         writeFileSync(join(stage, 'profile.json'), JSON.stringify(profile, null, 2) + '\n', { flag: 'wx', mode: 0o600 });
+        // Fleet on this host produces agent notifications through the server gateway.
+        // A runtime without the notification service prepares no producer credential.
+        const issued = record.gateway ? await compose(record, ['run', '--rm', '--no-deps', '-T', '--entrypoint', 'cat', 'messenger', '/var/lib/ours-notifications/fleet-producer'], { sensitive: true, allowCodes: [1] }) : null;
+        if (issued && (issued.code ?? 0) === 0) {
+          const token = String(issued.stdout ?? '');
+          if (!/^[A-Za-z0-9_-]{32,256}$/.test(token)) throw new Error('Notification producer credential is invalid; repeat server install');
+          writeFileSync(join(stage, NOTIFICATIONS_PRODUCER_FILE), JSON.stringify({ schema: 1, serverUrl, expectedInstanceId: record.instanceId, token }) + '\n', { flag: 'wx', mode: 0o600 });
+        }
         // Publish the complete pair in one rename. Managed-default activation and
         // package/source selection remain the normal client installer's job.
         renameSync(stage, published);

package/lib/server-ports.mjs

@@ -0,0 +1,17 @@
+/** Fresh selections only; retained installations keep their recorded addresses. */
+export function selectServerPorts(record, isTaken, explicitPorts = [], out = () => {}) {
+  const reserved = new Set([3051]);
+  for (const key of ['port', 'coworkPort', 'messengerPort']) {
+    const preferred = record[key];
+    let selected = preferred;
+    while (reserved.has(selected) || isTaken(selected)) {
+      if (explicitPorts.includes(key)) throw Error(`Requested ${key} ${preferred} is unavailable; select another explicit port`);
+      selected++;
+      if (selected > 65535) throw Error(`No free loopback port available for ${key}`);
+    }
+    reserved.add(selected);
+    record[key] = selected;
+    if (selected !== preferred) out(`${key}: ${preferred} is unavailable; selected loopback port ${selected}`);
+  }
+  return record;
+}