@ours.network/install 1.1.1 → 1.2.0-nightly.1

package/assets/scripts/maintenance/state-operation.mjs

@@ -0,0 +1,249 @@
+#!/usr/bin/env node
+/** One-shot maintenance for a selected domain; the installer excludes administrative writers. */
+import * as fs from 'node:fs';
+import { resolve, dirname, basename, join } from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { randomBytes } from 'node:crypto';
+import { execFileSync } from 'node:child_process';
+import { createArchive, extractArchive, validateArchive, scanSource, copyPrivateTree } from './state-archive.mjs';
+import { exchange, tryLock, setMtimeNs } from './state-native.mjs';
+import { recordNames, readBuildRecords, equalBuildRecords, initializeBuildMarker } from './build-context.mjs';
+
+const PROVENANCE = '.ours-provenance';
+const APPLICATIONS = ['daemon', 'telegram', 'cowork', 'messenger'];
+const exists = path => { try { fs.lstatSync(path); return true; } catch (e) { if (e.code === 'ENOENT') return false; throw e; } };
+const canonical = path => exists(path) ? fs.realpathSync(path) : join(canonical(dirname(path)), basename(path));
+const sameRecords = (a, b) => recordNames(a).length === recordNames(b).length && recordNames(a).every(name => a[name].equals(b[name]));
+const semanticSameRecords = equalBuildRecords;
+const sameInode = (a, b) => a.dev === b.dev && a.ino === b.ino;
+const fail = message => { throw new Error(message); };
+
+export async function runStateOperation(argv, env = process.env, checkpoints = {}) {
+  const selected = name => {
+    const value = env[name];
+    if (!value || resolve(value) !== value || canonical(value) !== value) fail(`${name} must select an absolute canonical path`);
+    return value;
+  };
+  const state = selected('OURS_STATE_ROOT'), live = selected('OURS_LIVE_ROOT'), build = selected('OURS_BUILD_ROOT');
+  if ([state, build].some(path => path === live || path.startsWith(live + '/'))) fail('maintenance and build records must be outside live application state');
+  const backups = join(state, 'backups'), maintenance = join(state, '.maintenance');
+  const domain = argv[1];
+  if (![...APPLICATIONS, 'server'].includes(domain)) fail('select server, daemon, telegram, cowork or messenger');
+  if (Object.hasOwn(env, 'OURS_STATE_DOMAIN') && env.OURS_STATE_DOMAIN !== domain) fail('selected volume domain does not match operation');
+  const compatible = argv.at(-1) === '--compatible';
+  if (compatible) argv = argv.slice(0, -1);
+  const operation = argv[0];
+  const paired = domain === 'daemon' && ['backup', 'restore', 'reset'].includes(operation);
+  const commonTree = domain === 'server' || paired;
+  if (compatible && !['restore', 'update'].includes(operation)) fail('compatibility attestation applies only to update or restore');
+  if (domain === 'server' && !['backup', 'restore', 'update', 'rebuild'].includes(operation)) fail('full-server scope supports only backup, restore, update and rebuild');
+  if (operation === 'rebuild' && domain !== 'server') fail('rebuild selects the complete server');
+  const adopt = operation === 'init' && argv[2] === '--adopt-existing';
+  const valid = (['init', 'update', 'rebuild'].includes(operation) && argv.length === 2) || (adopt && argv.length === 3) || (['backup', 'restore'].includes(operation) && argv.length === 3) || (operation === 'reset' && argv.length === 3 && argv[2] === '--confirm');
+  if (!valid) fail('usage: init DOMAIN | backup DOMAIN LABEL | restore DOMAIN LABEL | reset DOMAIN --confirm | update DOMAIN');
+  const uid = process.getuid(), gid = process.getgid();
+  if (!uid || !gid) fail('state maintenance requires a non-root UID and GID');
+  const options = records => ({ domain, uid, gid, provenance: records });
+  const labelPath = label => {
+    if (!/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}(?![\s\S])/.test(label)) fail('backup label must be a plain basename');
+    return join(backups, label);
+  };
+  if (['backup', 'restore'].includes(operation)) labelPath(argv[2]);
+  function privateStat(path, directory, exact) {
+    const st = fs.lstatSync(path), mode = st.mode & 0o7777;
+    if (!(directory ? st.isDirectory() : st.isFile()) || st.uid !== uid || st.gid !== gid || (mode & ~0o700) || (exact !== undefined && mode !== exact)) fail(`unsafe ownership, type or permissions: ${path}`);
+    return st;
+  }
+  function mkdir(path) {
+    if (exists(path)) privateStat(path, true, 0o700);
+    else { fs.mkdirSync(path, { mode: 0o700 }); fs.chmodSync(path, 0o700); }
+  }
+  function layout() { privateStat(state, true, 0o700); mkdir(backups); mkdir(maintenance); }
+  function readRecords(path, marker = true) {
+    privateStat(path, true, 0o700);
+    return readBuildRecords(path, { privateFiles: true, marker });
+  }
+  function writeRecord(path, bytes) {
+    fs.writeFileSync(path, bytes, { flag: fs.constants.O_WRONLY | fs.constants.O_CREAT | fs.constants.O_EXCL | fs.constants.O_NOFOLLOW, mode: 0o600 });
+    fs.chmodSync(path, 0o600);
+  }
+  function owner(command, extraEnv = {}) {
+    try { execFileSync(command[0], command.slice(1), { env: { ...env, ...extraEnv }, stdio: ['ignore', 'pipe', 'pipe', ...(env.OURS_INSTALLER_LOCK_FD === '3' ? [3] : [])] }); }
+    catch { fail(`owning package ${command[1]} operation failed`); }
+  }
+  function prepare() {
+    if (!['server', 'cowork'].includes(domain) && !paired) return;
+    if (!env.OURS_COWORK_CLI_PATH || !env.OURS_COWORK_CONFIG) fail('Cowork maintenance requires its selected executable and configuration');
+    owner([env.OURS_COWORK_CLI_PATH, '--json', 'prepare-backup'], { OURS_COWORK_CONFIG: env.OURS_COWORK_CONFIG });
+  }
+  function liveDescriptor() {
+    privateStat(live, true, 0o700);
+    const fd = fs.openSync(live, fs.constants.O_RDONLY | fs.constants.O_DIRECTORY | fs.constants.O_NOFOLLOW);
+    try {
+      if (fs.realpathSync(live) !== live || !sameInode(fs.fstatSync(fd), fs.statSync(live))) fail('domain state path changed or is not canonical');
+      return fd;
+    } catch (e) { fs.closeSync(fd); throw e; }
+  }
+  function validateTree(tree, records) {
+    const roots = domain === 'server' ? APPLICATIONS.map(name => join(tree, name)) : [tree];
+    for (const root of roots) if (!sameRecords(readRecords(join(root, PROVENANCE)), records)) fail('restored component provenance does not match the archive build');
+    if (domain === 'server') for (const name of ['mcp', 'credentials']) privateStat(join(tree, name), true, 0o700);
+    if (paired) privateStat(join(tree, '.mcp'), true, 0o700);
+    return roots;
+  }
+  function retarget(tree, source, target) {
+    // Call only on private staging. Publish the entire generation at exchange.
+    for (const root of validateTree(tree, source)) {
+      const marker = join(root, PROVENANCE);
+      fs.rmSync(marker, { recursive: true }); mkdir(marker);
+      for (const name of recordNames(target)) writeRecord(join(marker, name), target[name]);
+    }
+  }
+  function copyTree(source, destination) {
+    copyPrivateTree(source, destination, { uid, gid });
+  }
+  async function backupTo(path, records) {
+    if (!paired) return createArchive(live, path, options(records));
+    const payload = join(maintenance, `daemon-payload-${randomBytes(12).toString('hex')}`);
+    try {
+      if (exists(join(live, 'daemon/.mcp'))) fail('daemon state collides with the separate MCP source');
+      privateStat(join(live, 'mcp'), true, 0o700);
+      copyTree(join(live, 'daemon'), payload);
+      copyTree(join(live, 'mcp'), join(payload, '.mcp'));
+      await createArchive(payload, path, options(records));
+    } finally { if (exists(payload)) fs.rmSync(payload, { recursive: true }); }
+  }
+  async function automaticBackup(prefix, records) {
+    const path = labelPath(`${prefix}-${new Date().toISOString().replace(/[-:.]/g, '')}-${randomBytes(4).toString('hex')}`);
+    checkpoints.beforeBackup?.();
+    await backupTo(path, records);
+    checkpoints.afterBackup?.();
+    return path;
+  }
+  function bindConfig(path, source, keys) {
+    privateStat(source, false, 0o600);
+    const current = JSON.parse(fs.readFileSync(source));
+    const restored = exists(path) ? JSON.parse(fs.readFileSync(path)) : {};
+    for (const value of [current, restored]) if (!value || Array.isArray(value) || typeof value !== 'object') fail('component configuration must be an object');
+    for (const key of keys) {
+      if (Object.hasOwn(current, key)) restored[key] = current[key]; else delete restored[key];
+    }
+    fs.writeFileSync(path, JSON.stringify(restored, null, 2) + '\n', { mode: 0o600 });
+    fs.chmodSync(path, 0o600);
+    return current;
+  }
+  function bindDeployment(tree) {
+    if (commonTree) {
+      const current = bindConfig(join(tree, 'daemon/config.json'), env.OURS_DAEMON_CONFIG, ['stateDir', 'port', 'apiVisibility', 'networkMcp']);
+      if (current.networkMcp?.profile) {
+        const path = join(tree, 'mcp/profile.json');
+        fs.writeFileSync(path, JSON.stringify(current.networkMcp.profile, null, 2) + '\n', { mode: 0o600 });
+        fs.chmodSync(path, 0o600);
+      }
+    }
+    if (['server', 'cowork'].includes(domain)) bindConfig(join(tree, domain === 'server' ? 'cowork/config.json' : 'config.json'), env.OURS_COWORK_CONFIG, ['version', 'stateDir', 'rest']);
+  }
+  function retainAuthority(staging) {
+    if (!['daemon', 'server'].includes(domain)) return;
+    if (!env.OURS_CLI_PATH || !env.OURS_DAEMON_CONFIG) fail('daemon maintenance requires its selected executable and configuration');
+    const daemon = commonTree ? join(staging, 'daemon') : staging;
+    owner([env.OURS_CLI_PATH, 'config', 'access-retain', '--config', env.OURS_DAEMON_CONFIG, '--target-state-dir', daemon, '--json']);
+    if (!commonTree) return;
+    const credentials = join(live, 'credentials'), destination = join(staging, 'credentials');
+    for (const name of ['telegram', 'cowork', 'messenger']) if (!privateStat(join(credentials, name, 'daemon-token'), false, 0o600).size) fail('current managed credential is empty');
+    fs.rmSync(destination, { recursive: true }); copyTree(credentials, destination);
+  }
+  function replace(staging) {
+    const fd = fs.openSync(staging, fs.constants.O_RDONLY | fs.constants.O_DIRECTORY | fs.constants.O_NOFOLLOW);
+    try {
+      if (!tryLock(fd)) fail('replacement staging is in use');
+      if (!sameInode(fs.fstatSync(fd), fs.statSync(staging))) fail('replacement staging changed before exchange');
+      checkpoints.beforeExchange?.();
+      exchange(live, staging);
+      checkpoints.afterExchange?.();
+      fs.rmSync(staging, { recursive: true });
+    } finally { fs.closeSync(fd); }
+  }
+  privateStat(state, true, 0o700);
+  if (!exists(live)) { if (operation !== 'init') fail('domain state does not exist; run init for this domain first'); layout(); mkdir(live); }
+  const target = readBuildRecords(build);
+  const fd = liveDescriptor();
+  try {
+    if (!tryLock(fd)) fail('domain state is already in use');
+    const check = liveDescriptor();
+    try { if (!sameInode(fs.fstatSync(fd), fs.fstatSync(check))) fail('domain state changed while acquiring its lock'); }
+    finally { fs.closeSync(check); }
+    let records;
+    if (domain === 'server') { records = readRecords(join(live, 'daemon', PROVENANCE)); validateTree(live, records); }
+    else if (paired) { records = readRecords(join(live, 'daemon', PROVENANCE)); privateStat(join(live, 'mcp'), true, 0o700); }
+    else if (operation !== 'init') records = readRecords(join(live, PROVENANCE));
+    else {
+      const marker = join(live, PROVENANCE), application = fs.readdirSync(live).filter(name => name !== PROVENANCE);
+      records = target;
+      if (exists(marker)) {
+        privateStat(marker, true, 0o700);
+        if (fs.readdirSync(marker).length) {
+          records = readRecords(marker); // Partial generations are never repaired implicitly.
+          if (!sameRecords(records, target)) fail('existing provenance differs; use reviewed update --compatible to establish the new build context');
+        } else if (application.length && !adopt) fail('existing unmarked domain state requires evidence-backed adoption');
+      } else if (application.length && !adopt) fail('existing unmarked domain state requires evidence-backed adoption');
+      prepare(); if (application.length && adopt) scanSource(live, { uid, gid });
+      checkpoints.beforeInitialMarker?.();
+      initializeBuildMarker(marker, records);
+      checkpoints.afterInitialMarker?.();
+      layout(); return;
+    }
+    if (operation === 'update' || operation === 'rebuild') {
+      // The installer admits rebuild only after verifying unchanged sources.
+      // This is not a recorded user compatibility attestation.
+      if (!semanticSameRecords(records, target) && !(compatible && operation !== 'rebuild')) fail('different-build restore/update requires reviewed storage compatibility (--compatible)');
+      prepare(); layout(); const archive = await automaticBackup('pre-update', records);
+      console.log(`Validated pre-update backup: ${basename(archive)}`);
+      // Stage the complete set for every domain; no in-place partial retarget.
+      const staging = join(maintenance, `update-${randomBytes(12).toString('hex')}`);
+      try {
+        copyTree(live, staging);
+        retarget(staging, records, target);
+        validateTree(staging, target);
+        replace(staging);
+      } finally { if (exists(staging)) fs.rmSync(staging, { recursive: true }); }
+      return;
+    }
+    if (operation === 'backup') { prepare(); layout(); await backupTo(labelPath(argv[2]), records); return; }
+    const staging = join(maintenance, `${operation}-${randomBytes(12).toString('hex')}`);
+    try {
+      if (operation === 'restore') {
+        const archive = labelPath(argv[2]); if (fs.realpathSync(archive) !== archive) fail('backup path is not canonical');
+        const archived = readRecords(archive, false);
+        if (!semanticSameRecords(archived, target) && !compatible) fail('different-build restore/update requires reviewed storage compatibility (--compatible)');
+        await validateArchive(archive, options(archived)); prepare(); layout(); await automaticBackup('pre-restore', records);
+        if (paired) {
+          const payload = `${staging}-payload`;
+          try {
+            await extractArchive(archive, payload, options(archived)); retarget(payload, archived, target);
+            copyTree(live, staging);
+            fs.rmSync(join(staging, 'daemon'), { recursive: true });
+            fs.rmSync(join(staging, 'mcp'), { recursive: true });
+            fs.renameSync(join(payload, '.mcp'), join(staging, 'mcp'));
+            fs.renameSync(payload, join(staging, 'daemon'));
+          } finally { if (exists(payload)) fs.rmSync(payload, { recursive: true }); }
+        } else { await extractArchive(archive, staging, options(archived)); retarget(staging, archived, target); }
+      } else {
+        prepare(); layout(); await automaticBackup('pre-reset', records);
+        if (paired) {
+          copyTree(live, staging);
+          for (const name of ['daemon', 'mcp']) { fs.rmSync(join(staging, name), { recursive: true }); mkdir(join(staging, name)); }
+        } else mkdir(staging);
+        const marker = join(paired ? join(staging, 'daemon') : staging, PROVENANCE);
+        mkdir(marker);
+        for (const name of recordNames(records)) writeRecord(join(marker, name), records[name]);
+        bindDeployment(staging);
+      }
+      retainAuthority(staging); bindDeployment(staging); replace(staging);
+    } finally { if (exists(staging)) fs.rmSync(staging, { recursive: true }); }
+  } finally { fs.closeSync(fd); }
+}
+if (process.argv[1] && import.meta.url === pathToFileURL(resolve(process.argv[1])).href) {
+  try { await runStateOperation(process.argv.slice(2)); }
+  catch (error) { console.error(`OURS state operation refused: ${error.message}`); process.exitCode = 1; }
+}

package/assets/scripts/runtime/README.md

@@ -0,0 +1,24 @@
+# Startup and readiness
+
+Inputs: Compose variables and named volumes, protected credentials and existing
+settings. Outputs: prepared paths/profiles, running processes and readiness exit
+codes. Compose makes normal calls; no separate manual setup scripts are required.
+
+| Files | Caller and purpose |
+|---|---|
+| `client-setup.mjs` | installer preparation: directories, configuration, issued credentials, MCP profile and protected Telegram input; does not create identities |
+| `entrypoint.sh`, `start-*.sh` | Compose services: lock the data directory and start the application; the Telegram package applies optional provisioning before readiness |
+| `check-start.mjs`, `check-client.mjs` | Launchers: check access/credentials and essential settings before startup |
+| `runtime-common.mjs` | Shared check helpers and build-record writing under the state lock |
+| `healthcheck.mjs`, `health-*` | Docker healthchecks for daemon, Telegram, Cowork and Messenger readiness; failure returns a nonzero exit code |
+
+The main MCP runs inside Docker. Fleet and ours-codex/ours-claude remain on the
+host. Files use the existing transport without host bind mounts.
+
+Main MCP attaches to the daemon on the server and exposes its network transport.
+The installer owns preparation and selects the same sibling layout in package
+mode. Docker uses one named `server-storage` volume: `state/daemon`, `state/mcp`,
+`state/telegram`, `state/cowork`, `state/messenger` and `state/credentials`.
+Preparation mounts the storage root; running applications mount only their own
+state children and selected credentials. Backups and maintenance staging are
+outside `state/`. The owner-lock volume contains transient runtime locks.

package/assets/scripts/runtime/check-client.mjs

@@ -0,0 +1,21 @@
+import { checkCredential, checkRuntime, jsonConfig, privatePath, recordBuild } from './runtime-common.mjs';
+
+try {
+  const service = process.argv[2];
+  if (!['telegram', 'cowork', 'messenger'].includes(service)) throw new Error('Unknown client service');
+  const state = `/var/lib/ours-${service}`;
+  checkRuntime(state, process.env[service === 'telegram' ? 'OURS_TG_DAEMON_ID' : 'OURS_DAEMON_ID']);
+  privatePath(`/credentials/${service}`, true);
+  checkCredential(`/credentials/${service}/daemon-token`);
+  const config = jsonConfig(`${state}/config.json`);
+  if (service === 'cowork' && (!config || config.stateDir !== state || config.rest?.enabled !== true)) {
+    throw new Error('Cowork config must enable REST and use its declared state directory');
+  }
+  if (service === 'messenger' && !process.env.OURS_MESSENGER_IDENTITY?.trim()) {
+    throw new Error('Configure a messenger identity');
+  }
+  recordBuild(state);
+} catch (error) {
+  console.error(`OURS client startup refused: ${error.message}`);
+  process.exit(1);
+}

package/assets/scripts/runtime/check-start.mjs

@@ -0,0 +1,15 @@
+import { checkCredential, checkRuntime, jsonConfig, recordBuild } from './runtime-common.mjs';
+
+try {
+  const state = '/var/lib/ours';
+  checkRuntime(state, process.env.OURS_DAEMON_ID);
+  checkCredential(`${state}/daemon-token`);
+  const config = jsonConfig(`${state}/config.json`);
+  if (config && ('apiToken' in config || (config.stateDir && config.stateDir !== state))) {
+    throw new Error('Daemon config must use its declared state directory and current token file');
+  }
+  recordBuild(state);
+} catch (error) {
+  console.error(`OURS startup refused: ${error.message}`);
+  process.exit(1);
+}

package/assets/scripts/runtime/client-setup.mjs

@@ -0,0 +1,197 @@
+import { readBuildRecords, initializeBuildMarker } from '../maintenance/build-context.mjs';
+import { spawnSync } from 'node:child_process';
+import { randomBytes } from 'node:crypto';
+import {
+  closeSync, constants, fstatSync, lstatSync, mkdirSync, openSync, readFileSync,
+  realpathSync, renameSync, unlinkSync, writeFileSync, readdirSync, chmodSync, chownSync,
+} from 'node:fs';
+
+const DELIVERY_FILES = [
+  '/credentials/telegram/daemon-token',
+  '/credentials/cowork/daemon-token',
+  '/credentials/messenger/daemon-token',
+];
+const fail = (message) => { throw new Error(message); };
+const uuid = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
+
+function privatePath(path, directory, exact = directory ? 0o700 : 0o600) {
+  let value;
+  if (directory) {
+    const descriptor = openSync(path, constants.O_RDONLY | constants.O_DIRECTORY | constants.O_NOFOLLOW);
+    try { value = fstatSync(descriptor); } finally { closeSync(descriptor); }
+  } else {
+    value = lstatSync(path);
+  }
+  if ((directory ? !value.isDirectory() : !value.isFile()) || value.isSymbolicLink()
+      || value.uid !== process.getuid() || value.gid !== process.getgid()
+      || (value.mode & 0o7777) !== exact) {
+    fail(`Unsafe ownership or permissions: ${path}`);
+  }
+  return value;
+}
+
+function existingPrivate(path, directory, exact) {
+  try { return privatePath(path, directory, exact); }
+  catch (error) { if (error.code === 'ENOENT') return null; throw error; }
+}
+
+function jsonObject(path) {
+  privatePath(path, false);
+  let value;
+  try { value = JSON.parse(readFileSync(path, 'utf8')); }
+  catch { fail(`Existing config is not valid JSON: ${path}`); }
+  if (!value || Array.isArray(value) || typeof value !== 'object') fail(`Existing config must be an object: ${path}`);
+  return value;
+}
+
+function atomicJson(path, value) {
+  const temp = `${path}.setup-${randomBytes(8).toString('hex')}`;
+  try {
+    writeFileSync(temp, `${JSON.stringify(value, null, 2)}\n`, { encoding: 'utf8', mode: 0o600, flag: 'wx' });
+    renameSync(temp, path);
+  } finally {
+    try { unlinkSync(temp); } catch (error) { if (error.code !== 'ENOENT') throw error; }
+  }
+}
+
+function ensureDirectory(path) {
+  if (existingPrivate(path, true, 0o700)) return;
+  mkdirSync(path, { mode: 0o700 });
+  privatePath(path, true);
+}
+
+function validateCommon(idName = 'OURS_DAEMON_ID') {
+  if (!process.getuid() || !process.getgid()) fail('A non-root UID and GID are required');
+  if (!uuid.test(process.env[idName] ?? '')) fail('Configure the shared lowercase daemon UUID');
+}
+
+function composeConfig(domain) {
+  if (domain === 'daemon') {
+    const value = { stateDir: '/var/lib/ours', port: 3050, apiVisibility: 'owner', networkMcp: { profile: { endpoint: 'http://127.0.0.1:3050', expectedInstanceId: process.env.OURS_DAEMON_ID, credentialPath: '/var/lib/ours/daemon-token' }, applicationConfigPath: '/var/lib/ours-mcp/config.json' } };
+    if (process.env.OURS_BROKER_URL) value.brokerUrl = process.env.OURS_BROKER_URL;
+    return value;
+  }
+  if (domain === 'cowork') {
+    const port = Number(process.env.OURS_COWORK_REST_PORT);
+    if (!Number.isSafeInteger(port) || port < 1 || port > 65535) fail('Configure a valid cowork REST port');
+    return { version: 1, stateDir: '/var/lib/ours-cowork', rest: { enabled: true, host: '0.0.0.0', port } };
+  }
+  return null;
+}
+
+function prepare() {
+  const uid = Number(process.env.OURS_UID), gid = Number(process.env.OURS_GID);
+  if (![uid, gid].every((n) => Number.isSafeInteger(n) && n > 0)) fail('Configure non-root numeric OURS_UID and OURS_GID');
+  const roots = ['/storage', '/owner-locks'];
+  for (const path of roots) {
+    const fd = openSync(path, constants.O_RDONLY | constants.O_DIRECTORY | constants.O_NOFOLLOW);
+    let st; try { st = fstatSync(fd); } finally { closeSync(fd); }
+    if (st.uid === 0 && readdirSync(path).length === 0) {
+      chmodSync(path, 0o700); chownSync(path, uid, gid);
+    } else if (st.uid !== uid || st.gid !== gid || (st.mode & 0o7777) !== 0o700) {
+      fail(`Unsafe existing volume: ${path}`);
+    }
+  }
+  process.setgroups([]); process.setgid(gid); process.setuid(uid);
+  process.umask(0o077);
+  validateCommon();
+  for (const path of ['/storage/state', '/storage/state/mcp', '/storage/state/credentials',
+    ...['telegram', 'cowork', 'messenger'].map(name => `/storage/state/credentials/${name}`),
+    '/storage/backups', '/storage/.maintenance']) ensureDirectory(path);
+  const coworkPort = Number(process.env.OURS_COWORK_REST_PORT);
+  if (!Number.isSafeInteger(coworkPort) || coworkPort < 1 || coworkPort > 65535) fail('Configure a valid cowork REST port');
+  for (const domain of ['daemon', 'telegram', 'cowork', 'messenger']) {
+    const data = `/storage/state/${domain}`;
+    ensureDirectory(data);
+    // access-init owns the fresh-state check; no installer files enter daemon
+    // state until it has initialized or retained the selected authority.
+    if (domain === 'daemon') continue;
+    initializeBuildMarker(`${data}/.ours-provenance`, readBuildRecords('/opt/ours'));
+  }
+  const path = '/storage/state/daemon/config.json';
+  const expected = composeConfig('daemon');
+  if (existingPrivate(path, false)) {
+    const config = jsonObject(path);
+    if ('apiToken' in config || Object.entries(expected).some(([key, value]) => JSON.stringify(config[key]) !== JSON.stringify(value))) {
+      fail('Existing daemon configuration differs; use the supported maintenance workflow');
+    }
+  } else atomicJson(path, expected);
+  const coworkPath = '/storage/state/cowork/config.json';
+  const cowork = composeConfig('cowork');
+  if (!existingPrivate(coworkPath, false)) atomicJson(coworkPath, cowork);
+  else {
+    const config = jsonObject(coworkPath);
+    if (config.version !== 1 || config.stateDir !== cowork.stateDir || config.rest?.enabled !== true || config.rest?.host !== '0.0.0.0') fail('Existing cowork configuration conflicts with Compose');
+  }
+  console.log('OURS persistent volumes are ready');
+}
+
+function finishDaemonSetup() {
+  const state = '/var/lib/ours';
+  initializeBuildMarker(`${state}/.ours-provenance`, readBuildRecords('/opt/ours'));
+  privatePath('/var/lib/ours-mcp', true);
+  const mcpProfile = { endpoint: 'http://127.0.0.1:3050', expectedInstanceId: process.env.OURS_DAEMON_ID, credentialPath: `${state}/daemon-token` };
+  const mcpPath = '/var/lib/ours-mcp/profile.json';
+  if (!existingPrivate(mcpPath, false)) atomicJson(mcpPath, mcpProfile);
+  else if (JSON.stringify(jsonObject(mcpPath)) !== JSON.stringify(mcpProfile)) fail('Existing MCP profile differs from the selected daemon');
+}
+
+async function telegramInput() {
+  let raw = '';
+  for await (const chunk of process.stdin) {
+    raw += chunk;
+    if (Buffer.byteLength(raw) > 1024 * 1024) fail('Telegram input exceeds 1 MiB');
+  }
+  let value; try { value = JSON.parse(raw); } catch { fail('Telegram input must be JSON'); }
+  exactKeys(value, ['config', 'provision'], 'Telegram input');
+  for (const [key, input] of Object.entries(value)) {
+    if (!input || Array.isArray(input) || typeof input !== 'object') fail(`Telegram ${key} must be an object`);
+    const target = `/storage/state/telegram/${key === 'config' ? 'config' : 'provision'}.json`;
+    if (existingPrivate(target, false)) {
+      if (JSON.stringify(jsonObject(target)) !== JSON.stringify(input)) fail(`Existing Telegram ${key} differs; change it through the owning application`);
+    } else atomicJson(target, input);
+  }
+  console.log('OURS protected Telegram input stored');
+}
+
+function cliJson(args) {
+  const result = spawnSync(process.execPath, ['/opt/ours/node_modules/@ours.network/cli/dist/cli.js', ...args], {
+    encoding: 'utf8', timeout: 60_000, maxBuffer: 1024 * 1024,
+  });
+  if (result.status !== 0) fail('Official OURS CLI operation failed');
+  try { return JSON.parse(result.stdout); }
+  catch { fail('Official OURS CLI returned malformed JSON'); }
+}
+
+function access(operation, output) {
+  validateCommon();
+  const config = '/var/lib/ours/config.json';
+  if (operation === 'access-init') {
+    cliJson(['config', operation, '--config', config, ...(process.env.OURS_ACCESS_MIGRATE === '1' ? ['--migrate'] : []), '--json']);
+    finishDaemonSetup();
+  }
+  else if (operation === 'access-replace') cliJson(['config', operation, '--config', config, '--confirm', '--json']);
+  else if (operation === 'access-issue') {
+    for (const path of output ? [output] : ['/var/lib/ours/daemon-token', ...DELIVERY_FILES]) {
+      cliJson(['config', operation, '--config', config, '--output', path, '--replace', '--json']);
+    }
+  } else fail('Unknown access operation');
+  console.log(`OURS ${operation} completed`);
+}
+
+function exactKeys(value, allowed, label) {
+  if (!value || Array.isArray(value) || typeof value !== 'object') fail(`${label} must be an object`);
+  if (Object.keys(value).some((key) => !allowed.includes(key))) fail(`${label} contains an unsupported field`);
+}
+
+
+try {
+  const operation = process.argv[2];
+  if (operation === 'prepare') prepare();
+  else if (operation === 'telegram-input') { prepare(); await telegramInput(); }
+  else if (['access-init', 'access-issue', 'access-replace'].includes(operation)) access(operation, process.argv[3]);
+  else fail('usage: client-setup.mjs prepare | telegram-input | access-init | access-issue [OUTPUT] | access-replace');
+} catch (error) {
+  console.error(`OURS client setup refused: ${error.message}`);
+  process.exit(1);
+}

package/assets/scripts/runtime/entrypoint.sh

@@ -0,0 +1,13 @@
+#!/bin/sh
+set -eu
+umask 077
+exec 3</var/lib/ours
+if flock -n -E 73 3; then
+  :
+else
+  status=$?
+  echo "OURS startup refused: daemon state is already in use" >&2
+  exit "$status"
+fi
+node /opt/ours/docker/check-start.mjs
+exec node /opt/ours/node_modules/@ours.network/cli/dist/cli.js daemon serve

package/assets/scripts/runtime/health-cowork.sh

@@ -0,0 +1,11 @@
+#!/bin/sh
+node /opt/ours/node_modules/@ours.network/cowork/dist/cli.js --json status |
+  node -e '
+    let input = "";
+    process.stdin.on("data", chunk => input += chunk).on("end", () => {
+      try {
+        const status = JSON.parse(input);
+        process.exit(status.ok === true && status.result?.running === true ? 0 : 1);
+      } catch { process.exit(1); }
+    });
+  '

package/assets/scripts/runtime/health-messenger.mjs

@@ -0,0 +1,6 @@
+try {
+  const response = await fetch('http://127.0.0.1:8420/api/healthz', {
+    signal: AbortSignal.timeout(3000), redirect: 'error',
+  });
+  process.exitCode = response.ok ? 0 : 1;
+} catch { process.exitCode = 1; }

package/assets/scripts/runtime/health-telegram.sh

@@ -0,0 +1,8 @@
+#!/bin/sh
+# The connector exposes readiness only after optional provisioning succeeds.
+node -e '
+  fetch("http://127.0.0.1:3051/health", {
+    signal: AbortSignal.timeout(3000), redirect: "error"
+  }).then(response => process.exit(response.ok ? 0 : 1))
+    .catch(() => process.exit(1));
+'

package/assets/scripts/runtime/healthcheck.mjs

@@ -0,0 +1,17 @@
+import { attachOursClient } from '@ours.network/sdk/client';
+let client;
+try {
+  client = await attachOursClient({
+    endpoint: 'http://127.0.0.1:3050',
+    expectedInstanceId: process.env.OURS_DAEMON_ID,
+    credentialPath: '/var/lib/ours/daemon-token',
+    requiredCapabilities: ['external-sessions-v1'],
+    sessionMode: 'external',
+    leaseToken: 'container-readiness',
+    env: {},
+  });
+  await client.listIdentities();
+} catch {
+  console.error('Daemon API is not ready');
+  process.exitCode = 1;
+} finally { await client?.close(); }

package/assets/scripts/runtime/runtime-common.mjs

@@ -0,0 +1,47 @@
+import { readBuildRecords, initializeBuildMarker } from '../maintenance/build-context.mjs';
+import { accessSync, constants, lstatSync, readFileSync } from 'node:fs';
+
+export function privatePath(path, directory = false, writable = false) {
+  const stat = lstatSync(path);
+  if ((directory ? !stat.isDirectory() : !stat.isFile()) || stat.isSymbolicLink()
+      || stat.uid !== process.getuid() || stat.gid !== process.getgid()
+      || (stat.mode & 0o7077) !== 0) {
+    throw new Error(`Unsafe ownership or permissions: ${path}`);
+  }
+  accessSync(path, constants.R_OK | (directory ? constants.X_OK : 0) | (writable ? constants.W_OK : 0));
+}
+
+export function jsonConfig(path) {
+  try {
+    privatePath(path);
+    const value = JSON.parse(readFileSync(path, 'utf8'));
+    if (!value || Array.isArray(value) || typeof value !== 'object') throw new Error(`Invalid config: ${path}`);
+    return value;
+  } catch (error) {
+    if (error.code === 'ENOENT') return null;
+    throw error;
+  }
+}
+
+export function checkRuntime(state, id) {
+  if (!process.getuid() || !process.getgid()) throw new Error('Run as a non-root UID and GID');
+  if (!/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/.test(id ?? '')) {
+    throw new Error('Configure a stable daemon UUID');
+  }
+  privatePath(state, true, true);
+  for (const name of ['OURS_API_TOKEN', 'OURS_DAEMON_TOKEN', 'OURS_TG_BOT_TOKEN', 'OURS_TG_STT_API_KEY', 'TELEGRAM_BOT_TOKEN']) {
+    if (process.env[name] !== undefined) throw new Error(`Use a protected credential file instead of ${name}`);
+  }
+}
+
+export function checkCredential(path) {
+  privatePath(path);
+  // Credential format and authenticity belong to the SDK attachment API.
+  if (!readFileSync(path, 'utf8').trim()) throw new Error(`Empty daemon credential: ${path}`);
+}
+
+// Called with the startup state-directory lock held. These are build records,
+// not a storage schema or a declaration that arbitrary upgrades are compatible.
+export function recordBuild(state) {
+  initializeBuildMarker(`${state}/.ours-provenance`, readBuildRecords('/opt/ours'));
+}

package/assets/scripts/runtime/start-cowork.sh

@@ -0,0 +1,6 @@
+#!/bin/sh
+umask 077
+exec 3</var/lib/ours-cowork
+flock -n 3
+node /opt/ours/docker/check-client.mjs cowork
+exec node /opt/ours/node_modules/@ours.network/cowork/dist/cli.js serve

package/assets/scripts/runtime/start-messenger.sh

@@ -0,0 +1,6 @@
+#!/bin/sh
+umask 077
+exec 3</var/lib/ours-messenger
+flock -n 3
+node /opt/ours/docker/check-client.mjs messenger
+exec node /opt/ours/node_modules/@ours.network/messenger-server/dist/cli.js serve

package/assets/scripts/runtime/start-telegram.sh

@@ -0,0 +1,6 @@
+#!/bin/sh
+umask 077
+exec 3</var/lib/ours-telegram
+flock -n 3
+node /opt/ours/docker/check-client.mjs telegram
+exec node /opt/ours/node_modules/@ours.network/tg-connector/dist/cli.js serve