@ours.network/install 0.17.0-nightly.10 → 0.17.0-nightly.12

package/lib/effects.mjs

@@ -18,6 +18,7 @@ import { dirname, join, resolve } from 'node:path';
 import { atomicWriteConfig, snapshotConfig, restoreConfig } from './config.mjs';
 import { askYesNo, askLine as askLineOnTty } from './prompt.mjs';
 import { classifyHarnessProbe } from './logic.mjs';
+import { classifyStateDir } from './detect.mjs';
 
 /** GET http://127.0.0.1:<port>/state-dir — the unauthenticated identity probe. */
 async function probePort(port, { timeoutMs = 1500 } = {}) {
@@ -156,24 +157,41 @@ function copyToClipboard(text) {
 }
 
 /**
- * Every state directory on this machine that still has a daemon config.
+ * Every DAEMON state directory on this machine.
  *
- * `ours-uninstall` asks this exactly once, to answer one question: are the
- * GLOBAL packages still needed by somebody else? Getting it wrong the optimistic
- * way (reporting none) uninstalls the CLI out from under a second daemon that is
- * still running, so the search is deliberately conservative — it looks only where
- * a state directory can actually be, and an unreadable home means "there might be
- * others", not "there are none".
+ * ONE DEFINITION OF WHAT A DAEMON IS, and this function is why that matters.
  *
- * Where they can be: the default `~/.ours`, plus any `~/.ours*` sibling, which is
- * the shape every other part of this installer uses for a second daemon. A state
- * directory somewhere else entirely will not be found, and that is a KNOWN limit
- * rather than a claim — the failure is keeping a global package that could have
- * been removed, which is the harmless direction.
+ * It used to count any `~/.ours*` directory containing a config.json. Two of those
+ * are not daemons on a perfectly normal machine: `~/.ours-telegram/config.json` is
+ * the Telegram connector's and `~/.ours-cowork/config.json` is cowork's. So the
+ * uninstaller reported "@ours.network/cli kept — still used by the daemon at
+ * ~/.ours-telegram", and two things followed silently:
+ *
+ *   · planGlobalPackages kept cli, mcp and the plugin packages FOREVER on any
+ *     machine with the connector installed, naming a connector's config directory
+ *     as a daemon;
+ *   · worse, planPluginRemoval's `lastDaemon` went false, so the whole harness
+ *     plugin phase was skipped — with a reason that was not true. A plain
+ *     interactive `ours-uninstall` on a machine with the connector removed no
+ *     plugins at all.
+ *
+ * The selection screen had already closed exactly this: config.json is the one
+ * piece of evidence that is AMBIGUOUS, so it cannot be the test. That predicate
+ * lives in lib/detect.mjs and this now calls it rather than keeping a second,
+ * naive copy that drifted. A daemon is identified by an artefact only a daemon
+ * writes, or by a config whose SHAPE is a daemon's.
+ *
+ * Still deliberately conservative about WHERE it looks: only `~/.ours` and its
+ * `~/.ours*` siblings. A state directory somewhere else is not found, and an
+ * unreadable home means "there might be others", not "there are none" — because
+ * the caller uses this to decide whether a GLOBAL package is still needed, and
+ * being wrong the optimistic way uninstalls the CLI out from under a running
+ * daemon.
  */
 function knownStateDirsIn(home) {
   const found = [];
-  const consider = (dir) => { if (existsSync(join(dir, 'config.json'))) found.push(dir); };
+  const io = { exists: existsSync, readJson: readJsonFile };
+  const consider = (dir) => { if (classifyStateDir(dir, io).isDaemon) found.push(dir); };
   consider(join(home, '.ours'));
   try {
     for (const entry of readdirSync(home, { withFileTypes: true })) {
@@ -278,7 +296,7 @@ export function realEffects({ write, ttyFd, env = process.env, home = homedir(),
   };
 }
 
-export const __testables = { probePort, portTakenSync, readJsonFile, readTextFile, installedVersionOf };
+export const __testables = { probePort, portTakenSync, readJsonFile, readTextFile, installedVersionOf, knownStateDirsIn };
 
 // -----------------------------------------------------------------------------
 // THE PAIR

package/lib/orchestrate-uninstall.mjs

@@ -141,6 +141,7 @@ export async function runUninstall(argv, effects) {
     exists: effects.exists,
     cliStartedIt: effects.readJson(join(dir, 'ours-cli-daemon.json')) !== null,
     otherStateDirsWithConfig: effects.knownStateDirs(),
+    platform: effects.platform?.platform,
     typedConfirmation: null,
     explicitHarnessSelection: contract.engaged,
   });
@@ -159,6 +160,7 @@ export async function runUninstall(argv, effects) {
   // removal makes that true. If step 3 or 4 fails, the operator is left with a
   // stopped, detached connector NEXT TO A DAEMON THAT IS STILL THERE — a world the
   // bytes no longer describe.
+  let unsupportedService = null;
   const journal = configJournal(effects, { dryRun: args.dryRun });
   const detached = [];
   for (const component of plan.detach) {
@@ -178,6 +180,13 @@ export async function runUninstall(argv, effects) {
   // 3-4. The boot service, then the daemon. Both delegate their refusals.
   try {
     for (const step of plan.daemon) {
+      if (step.id === 'service-unsupported') {
+        // Said, not skipped silently: the operator is entitled to know that the
+        // thing they may have expected to be removed was never installed.
+        effects.out(warn(`ours: ${step.note}`));
+        unsupportedService = step;
+        continue;
+      }
       if (step.command === null) {
         effects.out(info(`${step.note} — nothing signalled`));
         continue;
@@ -204,6 +213,7 @@ export async function runUninstall(argv, effects) {
   const packages = planGlobalPackages({
     stateDir: dir,
     otherStateDirsWithConfig: effects.knownStateDirs(),
+    platform: effects.platform?.platform,
     pluginPackages: pluginOutcome.packages,
     // The plugin packages are recomputed; the CONNECTOR packages are not. They
     // are decided by what the operator confirmed detaching, which the plugin
@@ -219,6 +229,15 @@ export async function runUninstall(argv, effects) {
       await perform(effects, args.dryRun, `npm rm -g ${pkg}`, () => effects.run('npm', ['rm', '-g', pkg]));
     }
   }
+  // SAID AT THE END, where a closing screen is actually read, and not only in the
+  // line it scrolled past during the run. The same rule as the install side: an
+  // uninstall that quietly did less than the operator believes is the thing to
+  // avoid, and "nothing of ours was there to remove" is only reassuring if it is
+  // stated.
+  if (unsupportedService) {
+    effects.out(warn(`Boot service: NOT removed — ${unsupportedService.note}.`));
+    effects.out(info('If you start the daemon yourself at login, remove that arrangement by hand.'));
+  }
   return EXIT_OK;
 }
 

package/lib/orchestrate.mjs

@@ -239,6 +239,7 @@ export async function runDaemonPhase(args, effects) {
   // lookup exists to prevent; this is what stops the installer from setting up the
   // conditions for it.
   const journal = configJournal(effects, { dryRun: args.dryRun });
+  let serviceUnsupported = null;
   if (merged.changed) {
     journal.snapshot(configPath);
     await perform(effects, args.dryRun, `write ${configPath} (port ${target.port})`, () => effects.writeJson(configPath, merged.text));
@@ -254,6 +255,7 @@ export async function runDaemonPhase(args, effects) {
     }
 
     const service = await runServicePhase(args, effects, dir);
+    if (service.unsupported) serviceUnsupported = service.unsupported;
     if (service.refused) {
       // A REFUSAL IS A FAILURE TO REACH THE STATE, not a special case. An unknown
       // unit file stops the run just as a failed start does, and it stops it with
@@ -287,7 +289,7 @@ export async function runDaemonPhase(args, effects) {
     throw error;
   }
 
-  return { target, steps };
+  return { target, steps, serviceUnsupported };
 }
 
 /**
@@ -349,7 +351,19 @@ function rollBack(effects, journal, args, why, { packagesInstalled = true, repla
  * positively identified as ours-mcp's, and never for one we cannot identify.
  */
 export async function runServicePhase(args, effects, dir) {
-  const plan = planServiceInstall({ stateDir: dir, home: effects.home, readText: effects.readText });
+  const plan = planServiceInstall({
+    stateDir: dir, home: effects.home, readText: effects.readText, platform: effects.platform?.platform,
+  });
+  // NOT a refusal and NOT a failure: the daemon is running and correct, and only
+  // the boot service could not be installed. So the run CONTINUES — but it says
+  // so, and the summary marks it, because the person this hurts is the one who
+  // reboots in a fortnight and finds nothing listening.
+  if (plan.action === 'unsupported') {
+    effects.out(warn(`ours: ${plan.message}`));
+    effects.out(info(`Your daemon is installed and running now. To start it after a reboot, run:  ${plan.manual.join(' ')} ${join(dir, 'config.json')}`));
+    effects.out(info('Nothing else in this run depends on the boot service.'));
+    return { step: { id: 'service', changed: false, reason: 'not available on this platform' }, plan, unsupported: plan };
+  }
   if (plan.action === 'refuse') {
     effects.out(warn(`ours: refusing to continue — ${plan.message}`));
     return { refused: plan };
@@ -594,6 +608,12 @@ export function runPreflight(effects) {
     return { ok: false, platform: plat };
   }
   effects.out(ok(`Platform: ${plat.label} (supported)`));
+  // Supported is still true — the daemon runs here. What is NOT available is the
+  // boot service, and saying "supported" without that qualification is what let a
+  // Mac user walk into a run that could not finish.
+  if (effects.platform?.platform && effects.platform.platform !== 'linux') {
+    effects.out(info(`On ${plat.label} the daemon runs, but installing a BOOT SERVICE is not available yet — you will start it yourself after a reboot.`));
+  }
   const version = String(effects.nodeVersion ?? '0');
   if (Number.parseInt(version.split('.')[0], 10) < 20) {
     effects.out(warn(`Node.js ${version} — ours needs v20 or newer. Update Node and re-run.`));
@@ -1003,6 +1023,18 @@ export async function runInstall(argv, effects) {
     state: target.action === 'create' ? 'installed' : 'current',
     note: `port ${target.port}`,
   }];
+  // THE SKIP MUST NOT READ AS SUCCESS. A line that scrolls past is not a warning
+  // — the summary is where someone looks, so an uninstallable boot service gets
+  // the same "needs attention" mark a failed component gets. If this screen read
+  // clean on macOS we would have replaced a failed install with a quieter lie.
+  if (daemon.serviceUnsupported) {
+    summary.push({
+      key: 'service',
+      label: 'Boot service',
+      state: 'failed',
+      note: `not available on ${daemon.serviceUnsupported.platform === 'darwin' ? 'macOS' : daemon.serviceUnsupported.platform} yet — start the daemon yourself after a reboot`,
+    });
+  }
 
   const components = await runComponentPhase(args, effects, target);
   for (const component of COMPONENTS) {

package/lib/plan.mjs

@@ -110,7 +110,39 @@ export function classifyUnit(text) {
  * without a question in front of it — it is what keeps --force from becoming a
  * default that spreads to the other cases.
  */
-export function planServiceInstall({ stateDir, home, readText }) {
+export function planServiceInstall({ stateDir, home, readText, platform = 'linux' }) {
+  // THE BOOT SERVICE IS LINUX-ONLY, AND NOT BECAUSE THIS FILE SAYS SO.
+  //
+  // `ours daemon install-service` in @ours.network/cli builds its adapter with
+  // `createLinuxUserSystemdAdapter()` and no platform branch at all, and that
+  // factory's FIRST line is
+  //   if (deps.platform !== 'linux') throw new Error('service management is not
+  //   supported on <platform>; use an external launcher for `ours daemon serve`')
+  // — verified by reading the published 0.4.1 tarball, which contains zero
+  // occurrences of launchd, LaunchAgents or plist.
+  //
+  // So calling it on macOS does not degrade, it THROWS. Before this, a Mac user
+  // was told their platform was supported, watched the CLI install, the config
+  // write and the daemon start, and then got an exception and a rolled-back
+  // config. Skipping the step leaves them a working daemon and one true sentence
+  // instead — which is the whole of this change.
+  //
+  // A real launchd adapter belongs in the SDK CLI, not here. Nothing in this
+  // package can install a launchd agent, and pretending otherwise by writing a
+  // plist ourselves would put a second service implementation in a second repo.
+  if (platform && platform !== 'linux') {
+    return {
+      action: 'unsupported',
+      platform,
+      reason: 'no-service-manager',
+      message: platform === 'darwin'
+        ? 'installing a boot service is not available on macOS yet — the ours CLI can only manage a Linux user systemd service'
+        : `installing a boot service is not available on ${platform} — the ours CLI can only manage a Linux user systemd service`,
+      // What the operator can do INSTEAD, which is the difference between a gap
+      // and a dead end.
+      manual: ['ours', 'daemon', 'serve', '--config'],
+    };
+  }
   const derived = unitPathForStateDir(stateDir, home);
   if (!derived.ok) {
     return { action: 'refuse', exitCode: 2, reason: 'unusable-state-dir', message: derived.reason };

package/lib/uninstall.mjs

@@ -168,16 +168,35 @@ export function planComponentDetach(key, existing) {
  * case the screen names the external launcher and the run CONTINUES — a daemon
  * someone else supervises is not a failure of this uninstall.
  */
-export function planDaemonRemoval({ stateDir, cliStartedIt }) {
+export function planDaemonRemoval({ stateDir, cliStartedIt, platform = 'linux' }) {
   const dir = resolve(stateDir);
   const unit = unitNameForStateDir(dir);
-  return [
-    {
+  // THE MIRROR OF THE INSTALL SIDE, and half a fix here would be worse than none:
+  // a Mac user who installed successfully and then cannot UNINSTALL is stuck with
+  // something they were told worked.
+  //
+  // `ours daemon uninstall-service` goes through the same
+  // createLinuxUserSystemdAdapter() that throws on the first line for any
+  // non-linux platform, so calling it on darwin fails the run rather than
+  // degrading it. There is also nothing there to remove: this package could never
+  // have installed a launchd agent in the first place.
+  const service = platform && platform !== 'linux'
+    ? {
+      id: 'service-unsupported',
+      unit: null,
+      command: null,
+      platform,
+      continues: true,
+      note: `no boot service was installed on ${platform === 'darwin' ? 'macOS' : platform} — the ours CLI can only manage a Linux user systemd service, so there is nothing of ours to remove here`,
+    }
+    : {
       id: 'service',
       unit: unit.ok ? unit.unit : null,
       command: ['ours', 'daemon', 'uninstall-service', '--yes', '--state-dir', dir],
       note: 'refuses a unit not marked as CLI-managed',
-    },
+    };
+  return [
+    service,
     cliStartedIt
       ? { id: 'stop', command: ['ours', 'daemon', 'stop', '--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' },
@@ -474,7 +493,7 @@ export function selectHarnesses(plugins, chosen) {
  * The whole §8 order, refusing at step 1 rather than starting and stopping
  * half-way.
  */
-export function planUninstall({ home, env = {}, endpoint, stateDir, purge = false, assumeYes = false, confirmedComponents = [], readJson, readText, exists = () => true, cliStartedIt = true, otherStateDirsWithConfig = [], typedConfirmation = null, explicitHarnessSelection = false }) {
+export function planUninstall({ home, env = {}, endpoint, stateDir, purge = false, assumeYes = false, confirmedComponents = [], readJson, readText, exists = () => true, cliStartedIt = true, otherStateDirsWithConfig = [], typedConfirmation = null, explicitHarnessSelection = false, platform = 'linux' }) {
   const dir = resolve(stateDir);
   const lastDaemon = otherStateDirsWithConfig.map((d) => resolve(d)).filter((d) => d !== dir).length === 0;
   const plugins = planPluginRemoval({ home, env, exists, lastDaemon, explicitSelection: explicitHarnessSelection });
@@ -512,7 +531,7 @@ export function planUninstall({ home, env = {}, endpoint, stateDir, purge = fals
     action: 'uninstall',
     stateDir: dir,
     detach: pointing.map((p) => ({ key: p.key, service: [`ours-${p.key === 'tg' ? 'tg-connector' : 'cowork'}`, 'uninstall-service'] })),
-    daemon: planDaemonRemoval({ stateDir: dir, cliStartedIt }),
+    daemon: planDaemonRemoval({ stateDir: dir, cliStartedIt, platform }),
     state: planStatePurge({ stateDir: dir, purge, assumeYes, exists, typedConfirmation }),
     plugins,
     packages: planGlobalPackages({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ours.network/install",
-  "version": "0.17.0-nightly.10",
+  "version": "0.17.0-nightly.12",
   "private": false,
   "description": "The unified ours.network stack installer (ours-install): one guided ~3-minute flow for ours core (the daemon) + the harness plugins (Claude Code / Codex) + ours-fleet + the Telegram connector, then a single copy-paste hand-off prompt. Self-contained (Node built-ins only); run as `ours-install` or via curl|bash (install.sh).",
   "type": "module",