appostle-installer 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Oh Lord Agency
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,101 @@
+# appostle-installer
+
+One-shot installer for the Appostle daemon and the agent CLIs it talks to (Claude Code, Codex, OpenCode, Copilot, Pi). Sets up the daemon on your machine and pairs it with [appostle.app](https://appostle.app), where you control your agents from the web app, mobile app, or any paired client.
+
+```bash
+npx appostle-installer
+```
+
+## What it does
+
+1. Asks which agent CLIs you want (Claude Code, Codex, Copilot, OpenCode, Pi)
+2. Installs each one (idempotent — skips anything already present)
+3. Walks you through each CLI's native auth flow
+4. Installs the daemon runtime (`@appostle/cli` from public npm)
+5. Configures auto-start so the daemon connects to [pair.appostle.app](https://pair.appostle.app) on every boot
+6. Prints a pairing link + QR — paste into [appostle.app](https://appostle.app)
+
+## Updating an existing install
+
+Already paired and just want a newer daemon? Run the installer with `--update`:
+
+```bash
+npx appostle-installer@latest --update
+```
+
+That skips provider selection, auth, and the pairing step. It only:
+- Reinstalls `@appostle/cli@latest`
+- Re-applies the OS auto-start config (which restarts the running service)
+
+Safe to run from cron / a scheduled task for unattended upgrades.
+
+## Re-show the pairing link
+
+Need to pair another device or browser and don't have the link handy? Run:
+
+```bash
+npx appostle-installer@latest --pair
+```
+
+Prints a fresh QR + link for the local daemon and exits. No installs, no service changes — just the pairing artifact.
+
+## Other flags
+
+| Flag | Effect |
+|---|---|
+| `--yes`, `-y` | Skip every interactive prompt; install daemon only (no providers, no auth, no pairing print). Good for CI / Dockerfile bootstrap. |
+| `--providers=a,b,c` | Pre-pick a comma-separated list of provider IDs (e.g. `claude-code,codex`) and skip the multiselect. |
+| `--no-auth` | Install providers without running their auth flows. Pair with `--providers=…`. |
+| `--update` | Update-only mode (above). Implies non-interactive. |
+| `--pair` | Print a fresh pairing link/QR and exit. Daemon must already be installed. |
+
+## Architecture
+
+The daemon is the Appostle runtime (`@appostle/cli`), wired to Appostle's own relay and branded web UI.
+
+```
+Your machine                    Our infra
+────────────                    ─────────
+appostle daemon ──(E2EE WS)──▶ pair.appostle.app  (Cloudflare Worker relay)
+                                      │
+                                      ▼
+browser ─────────▶ appostle.app  (web UI, served from devportal)
+```
+
+Traffic is E2E-encrypted — the relay only forwards ciphertext.
+
+## Platform support
+
+| OS | Auto-start | Notes |
+|---|---|---|
+| macOS | launchd agent at `~/Library/LaunchAgents/app.appostle.daemon.plist` | tested |
+| Linux | systemd user unit at `~/.config/systemd/user/appostle.service` | run `loginctl enable-linger $USER` to keep it up when logged out |
+| Windows | `.vbs` launcher in Startup folder | ⚠️ **beta — unverified**. Code path is written but hasn't been dry-run on a real Windows machine yet. Please [open an issue](https://gitlab.com/ohlord-suite/appostle-daemon-installer/-/issues) if you hit problems. No restart-on-crash; upgrade to a Windows Service later if needed. |
+
+## Requirements
+
+- Node.js 20+ and npm on PATH. Install from [nodejs.org](https://nodejs.org) if missing.
+- A shell (bash/zsh/PowerShell).
+
+## Development
+
+```bash
+git clone https://gitlab.com/ohlord-suite/appostle-daemon-installer.git
+cd appostle-daemon-installer
+npm install
+npm run dev           # live-run without building
+npm run typecheck
+npm run build         # compile to dist/
+```
+
+## Publishing
+
+```bash
+npm publish --access public
+```
+
+Or push a `v*` tag to trigger the GitLab CI publish job.
+
+## License
+
+MIT — but the daemon it installs ([@appostle/cli](https://www.npmjs.com/package/@appostle/cli)) is AGPL-3.0.

package/bin/appostle-installer.mjs

@@ -0,0 +1,22 @@
+#!/usr/bin/env node
+// Entry point for `npx appostle-installer`.
+
+// Defensive Node version check.
+// We rely on `node:util#styleText` (added in Node 20.12) via @clack/core.
+// `engines` in package.json only warns on most installs; this is the hard gate.
+const [major, minor] = process.versions.node.split(".").map(Number);
+if (major < 20 || (major === 20 && minor < 12)) {
+  console.error(
+    `\n  appostle-installer requires Node.js >= 20.12.0` +
+      `\n  Detected: ${process.versions.node}` +
+      `\n` +
+      `\n  Upgrade via your OS package manager, or install Node 22 LTS:` +
+      `\n    macOS:   brew install node@22` +
+      `\n    Linux:   curl -fsSL https://deb.nodesource.com/setup_22.x | sudo -E bash - && sudo apt install -y nodejs` +
+      `\n    Windows: https://nodejs.org/en/download` +
+      `\n`,
+  );
+  process.exit(1);
+}
+
+import("../dist/appostle-installer.js");

package/bin/appostle.mjs

@@ -0,0 +1,19 @@
+#!/usr/bin/env node
+// Entry point for the `appostle` CLI binary that ships inside
+// appostle-installer. Same node version gate as appostle-installer.
+const [major, minor] = process.versions.node.split(".").map(Number);
+if (major < 20 || (major === 20 && minor < 12)) {
+  console.error(
+    `\n  appostle requires Node.js >= 20.12.0` +
+      `\n  Detected: ${process.versions.node}` +
+      `\n` +
+      `\n  Upgrade via your OS package manager, or install Node 22 LTS:` +
+      `\n    macOS:   brew install node@22` +
+      `\n    Linux:   curl -fsSL https://deb.nodesource.com/setup_22.x | sudo -E bash - && sudo apt install -y nodejs` +
+      `\n    Windows: https://nodejs.org/en/download` +
+      `\n`,
+  );
+  process.exit(1);
+}
+
+import("../dist/appostle.js");

package/dist/appostle-installer.js

@@ -0,0 +1,490 @@
+import { createRequire as __ac_createRequire } from "node:module";
+const require = __ac_createRequire(import.meta.url);
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/config.ts
+var config_exports = {};
+__export(config_exports, {
+  APPOSTLE_RELAY_ENDPOINT: () => APPOSTLE_RELAY_ENDPOINT,
+  APPOSTLE_WEB_URL: () => APPOSTLE_WEB_URL,
+  INSTALLER_PACKAGE: () => INSTALLER_PACKAGE
+});
+var APPOSTLE_RELAY_ENDPOINT, APPOSTLE_WEB_URL, INSTALLER_PACKAGE;
+var init_config = __esm({
+  "src/config.ts"() {
+    "use strict";
+    APPOSTLE_RELAY_ENDPOINT = "pair.appostle.app:443";
+    APPOSTLE_WEB_URL = "https://appostle.app";
+    INSTALLER_PACKAGE = "appostle-installer";
+  }
+});
+
+// src/index.ts
+init_config();
+import {
+  cancel,
+  confirm,
+  intro,
+  isCancel,
+  log,
+  multiselect,
+  note,
+  outro,
+  spinner
+} from "@clack/prompts";
+import chalk from "chalk";
+
+// src/daemon-setup.ts
+init_config();
+
+// src/util.ts
+import { execa } from "execa";
+import { accessSync, constants } from "node:fs";
+import { platform } from "node:os";
+import which from "which";
+function currentPlatform() {
+  const p = platform();
+  if (p === "darwin" || p === "linux" || p === "win32") return p;
+  throw new Error(`Unsupported platform: ${p}`);
+}
+async function has(binary) {
+  try {
+    await which(binary);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function resolveBinary(binary) {
+  try {
+    return await which(binary);
+  } catch {
+    return null;
+  }
+}
+async function runInteractive(command, args = [], options = {}) {
+  await execa(command, args, { stdio: "inherit", ...options });
+}
+var cachedNeedsSudo = null;
+async function npmGlobalNeedsSudo() {
+  if (cachedNeedsSudo !== null) return cachedNeedsSudo;
+  if (currentPlatform() === "win32") return cachedNeedsSudo = false;
+  if (process.getuid?.() === 0) return cachedNeedsSudo = false;
+  try {
+    const { stdout } = await execa("npm", ["prefix", "-g"]);
+    const prefix = stdout.trim();
+    if (!prefix) return cachedNeedsSudo = false;
+    accessSync(prefix, constants.W_OK);
+    return cachedNeedsSudo = false;
+  } catch {
+    return cachedNeedsSudo = true;
+  }
+}
+async function npmInstallGlobal(packages) {
+  const useSudo = await npmGlobalNeedsSudo();
+  const args = ["install", "-g", ...packages];
+  if (useSudo) {
+    await runInteractive("sudo", ["-E", "npm", ...args]);
+  } else {
+    await runInteractive("npm", args);
+  }
+}
+
+// src/daemon-setup.ts
+async function installAppostleGlobal() {
+  await npmInstallGlobal([`${INSTALLER_PACKAGE}@latest`]);
+}
+async function installAutostart() {
+  const os = currentPlatform();
+  if (os === "darwin") return installLaunchd();
+  if (os === "linux") return installSystemdUser();
+  if (os === "win32") return installWindowsStartup();
+}
+async function installLaunchd() {
+  const fs = await import("node:fs/promises");
+  const path = await import("node:path");
+  const osHome = (await import("node:os")).homedir();
+  const plistPath = path.join(osHome, "Library", "LaunchAgents", "agency.ohlord.appostle.plist");
+  const logPath = path.join(osHome, "Library", "Logs", "appostle.log");
+  const appostleBin = await resolveBinary("appostle") ?? "/usr/local/bin/appostle";
+  const plist = `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key><string>agency.ohlord.appostle</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>${appostleBin}</string>
+    <string>daemon</string>
+    <string>start</string>
+    <string>--foreground</string>
+  </array>
+  <key>RunAtLoad</key><true/>
+  <key>KeepAlive</key><true/>
+  <key>StandardOutPath</key><string>${logPath}</string>
+  <key>StandardErrorPath</key><string>${logPath}</string>
+  <key>EnvironmentVariables</key>
+  <dict>
+    <key>PATH</key><string>/opt/homebrew/bin:/usr/local/bin:/usr/bin:/bin</string>
+    <key>HOME</key><string>${osHome}</string>
+    <key>NODE_ENV</key><string>production</string>
+    <key>APPOSTLE_RELAY_ENDPOINT</key><string>${APPOSTLE_RELAY_ENDPOINT}</string>
+  </dict>
+</dict>
+</plist>
+`;
+  await fs.mkdir(path.dirname(plistPath), { recursive: true });
+  await fs.writeFile(plistPath, plist);
+  await writeAppostleConfig(osHome);
+  try {
+    await runInteractive("launchctl", ["unload", plistPath], { stdio: "ignore" });
+  } catch {
+  }
+  await runInteractive("launchctl", ["load", plistPath]);
+}
+async function writeAppostleConfig(osHome) {
+  const fs = await import("node:fs/promises");
+  const path = await import("node:path");
+  const configDir = path.join(osHome, ".appostle");
+  const configPath = path.join(configDir, "config.json");
+  const config = {
+    version: 1,
+    daemon: {
+      listen: "127.0.0.1:6767",
+      cors: { allowedOrigins: [APPOSTLE_WEB_URL] },
+      relay: { enabled: true, endpoint: APPOSTLE_RELAY_ENDPOINT }
+    },
+    app: { baseUrl: APPOSTLE_WEB_URL }
+  };
+  await fs.mkdir(configDir, { recursive: true });
+  await fs.writeFile(configPath, JSON.stringify(config, null, 2));
+}
+async function installSystemdUser() {
+  const fs = await import("node:fs/promises");
+  const path = await import("node:path");
+  const osHome = (await import("node:os")).homedir();
+  const unitDir = path.join(osHome, ".config", "systemd", "user");
+  const unitPath = path.join(unitDir, "appostle.service");
+  const appostleBin = await resolveBinary("appostle") ?? "/usr/bin/appostle";
+  const logPath = path.join(osHome, ".local", "state", "appostle", "daemon.log");
+  const unit = `[Unit]
+Description=Appostle Daemon
+After=network.target
+
+[Service]
+Type=simple
+ExecStart=${appostleBin} daemon start --foreground
+Restart=on-failure
+RestartSec=10
+Environment=NODE_ENV=production
+Environment=HOME=${osHome}
+Environment=APPOSTLE_RELAY_ENDPOINT=${APPOSTLE_RELAY_ENDPOINT}
+StandardOutput=append:${logPath}
+StandardError=append:${logPath}
+
+[Install]
+WantedBy=default.target
+`;
+  await fs.mkdir(unitDir, { recursive: true });
+  await fs.mkdir(path.dirname(logPath), { recursive: true });
+  await fs.writeFile(unitPath, unit);
+  await writeAppostleConfig(osHome);
+  await runInteractive("systemctl", ["--user", "daemon-reload"]);
+  await runInteractive("systemctl", ["--user", "enable", "--now", "appostle.service"]);
+}
+async function installWindowsStartup() {
+  const fs = await import("node:fs/promises");
+  const path = await import("node:path");
+  const osHome = (await import("node:os")).homedir();
+  const appostleBin = await resolveBinary("appostle") ?? "appostle.cmd";
+  const logDir = path.join(osHome, "AppData", "Local", "Appostle");
+  const logPath = path.join(logDir, "daemon.log");
+  const batPath = path.join(logDir, "appostle-daemon.bat");
+  const vbsPath = path.join(
+    osHome,
+    "AppData",
+    "Roaming",
+    "Microsoft",
+    "Windows",
+    "Start Menu",
+    "Programs",
+    "Startup",
+    "appostle.vbs"
+  );
+  const bat = `@echo off
+set NODE_ENV=production
+set APPOSTLE_RELAY_ENDPOINT=${APPOSTLE_RELAY_ENDPOINT}
+"${appostleBin}" daemon start --foreground >> "${logPath}" 2>&1
+`;
+  const vbs = `Set WshShell = CreateObject("WScript.Shell")
+WshShell.Run """${batPath}""", 0, False
+`;
+  await fs.mkdir(logDir, { recursive: true });
+  await fs.mkdir(path.dirname(vbsPath), { recursive: true });
+  await fs.writeFile(batPath, bat);
+  await fs.writeFile(vbsPath, vbs);
+  await writeAppostleConfig(osHome);
+  await runInteractive("wscript", [vbsPath]);
+}
+async function printPairingLink() {
+  const { execa: execa2 } = await import("execa");
+  const { APPOSTLE_WEB_URL: APPOSTLE_WEB_URL2 } = await Promise.resolve().then(() => (init_config(), config_exports));
+  const result = await execa2("appostle", ["daemon", "pair"], { reject: false });
+  const raw = (typeof result.stdout === "string" ? result.stdout : "") + (typeof result.stderr === "string" ? result.stderr : "");
+  const rewritten = raw.replace(/https?:\/\/[^/]+\/#offer=/g, `${APPOSTLE_WEB_URL2}/#offer=`);
+  process.stdout.write(rewritten);
+}
+
+// src/providers.ts
+var claude = {
+  id: "claude",
+  label: "Claude Code",
+  description: "Anthropic's agent CLI (MCP, streaming, deep reasoning)",
+  async detect() {
+    return has("claude");
+  },
+  async install() {
+    await npmInstallGlobal(["@anthropic-ai/claude-code@latest"]);
+  },
+  async auth() {
+    await runInteractive("claude", ["/login"]);
+  }
+};
+var codex = {
+  id: "codex",
+  label: "Codex",
+  description: "OpenAI's Codex workspace agent",
+  async detect() {
+    return has("codex");
+  },
+  async install() {
+    await npmInstallGlobal(["@openai/codex@latest"]);
+  },
+  async auth() {
+    await runInteractive("codex", ["login"]);
+  }
+};
+var copilot = {
+  id: "copilot",
+  label: "GitHub Copilot",
+  description: "Standalone Copilot CLI with ACP support",
+  async detect() {
+    return has("copilot");
+  },
+  async install() {
+    await npmInstallGlobal(["@github/copilot@latest"]);
+  },
+  async auth() {
+    await runInteractive("copilot", ["auth", "login"]);
+  }
+};
+var opencode = {
+  id: "opencode",
+  label: "OpenCode",
+  description: "Open-source multi-provider coding assistant",
+  async detect() {
+    return has("opencode");
+  },
+  async install() {
+    await npmInstallGlobal(["opencode-ai@latest"]);
+  },
+  async auth() {
+    await runInteractive("opencode", ["auth", "login"]);
+  }
+};
+var pi = {
+  id: "pi",
+  label: "Pi",
+  description: "Minimal terminal-based agent with multi-provider LLM support",
+  async detect() {
+    return has("pi");
+  },
+  async install() {
+    await npmInstallGlobal(["@mariozechner/pi-coding-agent@latest"]);
+  },
+  async auth() {
+    await runInteractive("pi", ["login"]);
+  }
+};
+var PROVIDERS = [claude, codex, copilot, opencode, pi];
+
+// src/index.ts
+function parseArgs() {
+  const args = process.argv.slice(2);
+  const yes = args.includes("--yes") || args.includes("-y");
+  const noAuth = args.includes("--no-auth");
+  const update = args.includes("--update");
+  const pair = args.includes("--pair");
+  const providersArg = args.find((a) => a.startsWith("--providers="));
+  const providerIds = providersArg ? providersArg.replace("--providers=", "").split(",").map((s) => s.trim()).filter(Boolean) : [];
+  return { yes, providerIds, noAuth, update, pair };
+}
+async function main() {
+  const { yes, providerIds, noAuth, update, pair } = parseArgs();
+  intro(
+    chalk.magentaBright("Appostle") + chalk.dim(pair ? " \u2014 pairing link" : update ? " \u2014 daemon updater" : " \u2014 daemon installer")
+  );
+  const os = currentPlatform();
+  log.info(`Detected OS: ${os}`);
+  if (!await has("npm")) {
+    log.error("`npm` not found on PATH. Install Node.js from https://nodejs.org and re-run.");
+    process.exit(1);
+  }
+  if (pair) {
+    note(`Paste the pairing link below into ${APPOSTLE_WEB_URL} (or scan the QR).`, "Pair");
+    try {
+      await printPairingLink();
+    } catch (err) {
+      log.error(`Could not generate pairing link: ${err.message}`);
+      log.info("Is the daemon installed? If not, run `npx appostle-installer` first.");
+      process.exit(1);
+    }
+    outro(chalk.green("Done."));
+    return;
+  }
+  if (update) {
+    const us = spinner();
+    us.start("Updating Appostle (npm install -g appostle-installer@latest)\u2026");
+    try {
+      await installAppostleGlobal();
+      us.stop("Daemon package up to date");
+    } catch (err) {
+      us.stop("Daemon update failed");
+      log.error(err.message);
+      process.exit(1);
+    }
+    us.start(`Re-applying auto-start (${os}) to restart service\u2026`);
+    try {
+      await installAutostart();
+      us.stop("Auto-start refreshed; service restarted");
+    } catch (err) {
+      us.stop("Auto-start refresh failed");
+      log.error(err.message);
+      process.exit(1);
+    }
+    outro(chalk.green("Update complete."));
+    return;
+  }
+  let chosen = [];
+  if (yes && providerIds.length === 0) {
+    log.info("--yes: skipping provider selection");
+  } else if (providerIds.length > 0) {
+    chosen = PROVIDERS.filter((p) => providerIds.includes(p.id));
+    const unknown = providerIds.filter((id) => !PROVIDERS.find((p) => p.id === id));
+    if (unknown.length > 0) log.warn(`Unknown provider ids ignored: ${unknown.join(", ")}`);
+    log.info(`Providers to install: ${chosen.map((p) => p.label).join(", ")}`);
+  } else {
+    const selection = await multiselect({
+      message: "Which agent CLIs do you want installed?",
+      required: false,
+      options: PROVIDERS.map((p) => ({
+        value: p.id,
+        label: p.label,
+        hint: p.description
+      }))
+    });
+    if (isCancel(selection)) {
+      cancel("Cancelled.");
+      process.exit(0);
+    }
+    chosen = PROVIDERS.filter((p) => selection.includes(p.id));
+  }
+  for (const provider of chosen) {
+    const s2 = spinner();
+    s2.start(`Checking ${provider.label}\u2026`);
+    const alreadyInstalled = await provider.detect();
+    s2.stop(
+      alreadyInstalled ? `${provider.label} already installed` : `${provider.label} not found \u2014 installing`
+    );
+    if (!alreadyInstalled) {
+      try {
+        await provider.install();
+      } catch (err) {
+        log.error(`${provider.label} install failed: ${err.message}`);
+        if (yes || noAuth) {
+          log.warn(`Skipping ${provider.label} due to --yes/--no-auth`);
+          continue;
+        }
+        const keepGoing = await confirm({
+          message: `Skip ${provider.label} and continue?`,
+          initialValue: true
+        });
+        if (isCancel(keepGoing) || !keepGoing) {
+          cancel("Aborting.");
+          process.exit(1);
+        }
+        continue;
+      }
+    }
+    if (yes || noAuth) {
+      log.info(`Skipping ${provider.label} auth (--no-auth / --yes)`);
+      continue;
+    }
+    const doAuth = await confirm({
+      message: `Authenticate ${provider.label} now?`,
+      initialValue: true
+    });
+    if (isCancel(doAuth)) {
+      cancel("Cancelled.");
+      process.exit(0);
+    }
+    if (doAuth) {
+      try {
+        await provider.auth();
+      } catch (err) {
+        log.warn(
+          `${provider.label} auth returned non-zero \u2014 retry later with its own CLI. (${err.message})`
+        );
+      }
+    } else {
+      log.info(`Skipping ${provider.label} auth \u2014 you can run it later.`);
+    }
+  }
+  if (!yes) {
+    note(
+      "Installing Appostle globally (daemon + appostle CLI ship in the same package).",
+      "Daemon"
+    );
+    const proceed = await confirm({ message: "Continue?", initialValue: true });
+    if (isCancel(proceed) || !proceed) {
+      cancel("Stopped before daemon install. Re-run any time.");
+      process.exit(0);
+    }
+  }
+  const s = spinner();
+  s.start("Installing daemon (npm install -g appostle-installer)\u2026");
+  try {
+    await installAppostleGlobal();
+    s.stop("Daemon + appostle CLI installed");
+  } catch (err) {
+    s.stop("Install failed");
+    log.error(err.message);
+    process.exit(1);
+  }
+  s.start(`Configuring auto-start (${os})\u2026`);
+  await installAutostart();
+  s.stop("Auto-start configured");
+  if (os === "linux") {
+    log.info(
+      "Tip: run `loginctl enable-linger $USER` if you want the daemon to stay up when you're logged out."
+    );
+  }
+  if (!yes) {
+    note(`Paste the pairing link below into ${APPOSTLE_WEB_URL} (or scan the QR).`, "Pair");
+  }
+  await printPairingLink();
+  outro(chalk.green(`Done. Open ${APPOSTLE_WEB_URL}`));
+}
+main().catch((err) => {
+  console.error(chalk.red("\nInstaller failed:"), err);
+  process.exit(1);
+});
+//# sourceMappingURL=appostle-installer.js.map