pinomad 0.11.0 → 0.12.0

package/dist/{chunk-jt34g8st.js → chunk-np4jd070.js}

@@ -15,7 +15,7 @@ import {
   organize,
   parseRtcMaxMessageSize,
   rtcSelectedPair
-} from "./chunk-xqycs43g.js";
+} from "./chunk-47ff1d1t.js";
 import {
   SECURE_PROLOGUE,
   SecureSession,
@@ -286,6 +286,13 @@ function webSocketTransport(url, token) {
   };
 }
 
+// packages/protocol/src/terminals.ts
+function isTerminalsHello(value) {
+  return value !== null && typeof value === "object" && typeof value.limit === "number";
+}
+var terminalsStream = (id) => `terminals:${id}`;
+var terminalStream = (id) => `terminal:${id}`;
+
 // packages/protocol/src/transcript.ts
 function isBusy(view) {
   const live = view.docs?.["pi.live"];
@@ -458,6 +465,11 @@ class RemoteClient {
   #helloModels = [];
   #helloDefaults = {};
   #hostVersion;
+  #hostTerminals;
+  #terminalWatchers = new Map;
+  #terminalSinks = new Map;
+  #terminalPositions = new Map;
+  #terminalSizes = new Map;
   #attempt = 0;
   #rtcAttemptNonce = randomHex(8);
   #closed = false;
@@ -710,6 +722,7 @@ class RemoteClient {
     this.#helloModels = frame.models;
     this.#helloDefaults = frame.defaults ?? {};
     this.#hostVersion = frame.hostVersion;
+    this.#hostTerminals = isTerminalsHello(frame.terminals) ? frame.terminals : undefined;
     this.#fresh.clear();
     const covered = new Set(hostStreams(hostMinor));
     for (const name of HOST_STREAM_NAMES) {
@@ -727,6 +740,7 @@ class RemoteClient {
     if (this.#side !== undefined)
       for (const stream of this.#conversationStreams(this.#side))
         this.#wanted.add(stream);
+    this.#terminalsAvailability();
     for (const stream of this.#wanted)
       this.#subscribe(stream);
     if (frame.endpointSet !== undefined) {
@@ -815,6 +829,7 @@ class RemoteClient {
       this.#resolveReady({
         view: this.#viewSource(),
         controller: this.#controller(),
+        terminals: this.#terminals(),
         setConnectionMode: (mode) => this.setConnectionMode(mode),
         rtcDiagnostics: () => this.rtcDiagnostics(),
         close: () => this.#close()
@@ -828,6 +843,9 @@ class RemoteClient {
     await this.#recoverSubmissions();
     if (!this.#isActive(dial))
       return;
+    for (const [terminalId, size] of this.#terminalSizes) {
+      this.#callNow("resizeTerminal", { terminalId, ...size }).catch(() => {});
+    }
     this.#finishSyncGate();
     this.#afterCarrierReady(dial);
   }
@@ -1961,6 +1979,11 @@ class RemoteClient {
       case "snapshot":
         if (!this.#wanted.has(frame.stream))
           return;
+        if (frame.stream.startsWith("terminals:")) {
+          this.#values.set(frame.stream, frame.value);
+          this.#notifyTerminals(frame.stream, { kind: "ready", list: frame.value });
+          return;
+        }
         this.#values.set(frame.stream, frame.value);
         this.#fresh.add(frame.stream);
         this.#streamVersions.set(frame.stream, (this.#streamVersions.get(frame.stream) ?? 0) + 1);
@@ -1974,7 +1997,19 @@ class RemoteClient {
         this.#values.set(frame.stream, applyImmutable(this.#values.get(frame.stream), frame.ops));
         this.#refresh();
         return;
+      case "output": {
+        const sink = this.#terminalSinks.get(frame.stream);
+        if (sink === undefined || !this.#wanted.has(frame.stream))
+          return;
+        this.#terminalPositions.set(frame.stream, frame.seq);
+        sink.output(frame.data, frame.reset === true);
+        return;
+      }
       case "ended": {
+        if (frame.stream.startsWith("terminals:") || frame.stream.startsWith("terminal:")) {
+          this.#endTerminalStream(frame.stream, frame.reason);
+          return;
+        }
         this.#wanted.delete(frame.stream);
         this.#values.delete(frame.stream);
         this.#fresh.delete(frame.stream);
@@ -2070,7 +2105,124 @@ class RemoteClient {
   }
   #subscribe(stream) {
     const refs = stream.startsWith("conversation:") && hostSupportsFeature(this.#hostMinor, "imageRefs");
-    this.#send({ type: "subscribe", stream, ...refs ? { images: "ref" } : {} });
+    const since = this.#terminalPositions.get(stream);
+    this.#send({
+      type: "subscribe",
+      stream,
+      ...refs ? { images: "ref" } : {},
+      ...since === undefined ? {} : { since }
+    });
+  }
+  #terminalsUnavailable() {
+    if (!hostSupportsFeature(this.#hostMinor, "terminals")) {
+      return "The host is too old for terminals (needs protocol 5.27); run `pinomad upgrade` on the host";
+    }
+    if (this.#hostTerminals === undefined)
+      return "The host couldn't load its terminal module; its log says which package is missing";
+    return;
+  }
+  #terminalsAvailability() {
+    const reason = this.#terminalsUnavailable();
+    if (reason === undefined) {
+      for (const stream of this.#terminalWatchers.keys())
+        this.#wanted.add(stream);
+      for (const stream of this.#terminalSinks.keys())
+        this.#wanted.add(stream);
+      return;
+    }
+    for (const stream of [...this.#terminalWatchers.keys()]) {
+      this.#wanted.delete(stream);
+      this.#values.delete(stream);
+      this.#notifyTerminals(stream, { kind: "unavailable", reason });
+    }
+    for (const stream of [...this.#terminalSinks.keys()])
+      this.#endTerminalStream(stream, reason);
+  }
+  #notifyTerminals(stream, state) {
+    for (const listener of [...this.#terminalWatchers.get(stream) ?? []])
+      listener(state);
+  }
+  #endTerminalStream(stream, reason) {
+    this.#wanted.delete(stream);
+    this.#values.delete(stream);
+    if (stream.startsWith("terminals:")) {
+      this.#notifyTerminals(stream, { kind: "unavailable", reason });
+      return;
+    }
+    const sink = this.#terminalSinks.get(stream);
+    this.#terminalSinks.delete(stream);
+    this.#terminalPositions.delete(stream);
+    this.#terminalSizes.delete(stream.slice("terminal:".length));
+    sink?.ended(reason);
+  }
+  #terminalCall(method, args) {
+    const reason = this.#terminalsUnavailable();
+    return reason === undefined ? this.#call(method, args) : Promise.reject(new Error(reason));
+  }
+  #terminals() {
+    return {
+      watch: (conversationId, listener) => {
+        const stream = terminalsStream(conversationId);
+        let listeners = this.#terminalWatchers.get(stream);
+        const first = listeners === undefined;
+        if (listeners === undefined)
+          this.#terminalWatchers.set(stream, listeners = new Set);
+        listeners.add(listener);
+        const reason = this.#terminalsUnavailable();
+        const list = this.#values.get(stream);
+        listener(reason !== undefined ? { kind: "unavailable", reason } : list !== undefined ? { kind: "ready", list } : { kind: "loading" });
+        if (first && reason === undefined) {
+          this.#wanted.add(stream);
+          if (this.#helloReceived)
+            this.#subscribe(stream);
+        }
+        return () => {
+          if (!listeners.delete(listener) || listeners.size > 0)
+            return;
+          this.#terminalWatchers.delete(stream);
+          if (!this.#wanted.delete(stream))
+            return;
+          this.#values.delete(stream);
+          this.#send({ type: "unsubscribe", stream });
+        };
+      },
+      attach: (terminalId, sink) => {
+        const stream = terminalStream(terminalId);
+        const reason = this.#terminalsUnavailable();
+        if (reason !== undefined) {
+          sink.ended(reason);
+          return () => {};
+        }
+        if (this.#terminalSinks.has(stream) && this.#wanted.has(stream))
+          this.#send({ type: "unsubscribe", stream });
+        this.#terminalSinks.set(stream, sink);
+        this.#terminalPositions.delete(stream);
+        this.#wanted.add(stream);
+        if (this.#helloReceived)
+          this.#subscribe(stream);
+        return () => {
+          if (this.#terminalSinks.get(stream) !== sink)
+            return;
+          this.#terminalSinks.delete(stream);
+          this.#terminalPositions.delete(stream);
+          this.#terminalSizes.delete(terminalId);
+          if (this.#wanted.delete(stream))
+            this.#send({ type: "unsubscribe", stream });
+        };
+      },
+      open: (conversationId, size) => this.#terminalCall("openTerminal", { conversationId, ...size }).then(({ terminalId }) => terminalId),
+      input: (terminalId, data) => {
+        this.#terminalCall("terminalInput", { terminalId, data }).catch(() => {});
+      },
+      resize: (terminalId, size) => {
+        if (this.#terminalSinks.has(terminalStream(terminalId)))
+          this.#terminalSizes.set(terminalId, size);
+        this.#terminalCall("resizeTerminal", { terminalId, ...size }).catch(() => {});
+      },
+      rename: (terminalId, name) => this.#terminalCall("renameTerminal", { terminalId, name }).then(() => {}),
+      restart: (terminalId, size) => this.#terminalCall("restartTerminal", { terminalId, ...this.#terminalSizes.get(terminalId) ?? size }).then(() => {}),
+      close: (terminalId) => this.#terminalCall("closeTerminal", { terminalId }).then(() => {})
+    };
   }
   #host(name) {
     return this.#values.get(name);

package/dist/{chunk-44pnts98.js → chunk-nppgxh6c.js}

@@ -1,6 +1,6 @@
 import {
   RTC_DEFAULT_STUN
-} from "./chunk-xqycs43g.js";
+} from "./chunk-47ff1d1t.js";
 import {
   HOST_SETTING_KEYS,
   cleanHostName,

package/dist/chunk-nq57fdnq.js

@@ -0,0 +1,106 @@
+// apps/host/src/server-config.ts
+import { randomBytes } from "node:crypto";
+import { readFile, rename, rm, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+var SERVER_CONFIG_FILE = "server.json";
+var REMOVAL_NOTICE_FILE = "server-removed.json";
+var normalizeOrigin = (origin) => origin.replace(/\/+$/, "");
+async function readServerConfig(dataDir) {
+  const config = await readServerConfigAt(join(dataDir, SERVER_CONFIG_FILE));
+  if (config === undefined)
+    return;
+  const notice = await readRemovalNotice(dataDir).catch(() => {
+    return;
+  });
+  return notice !== undefined && endsJoin(notice, config) ? undefined : config;
+}
+var endsJoin = (notice, config) => normalizeOrigin(notice.origin) === normalizeOrigin(config.origin) && notice.binding === config.binding;
+async function readServerConfigAt(path) {
+  let text;
+  try {
+    text = await readFile(path, "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT")
+      return;
+    throw error;
+  }
+  let value;
+  try {
+    value = JSON.parse(text);
+  } catch {
+    throw new Error(`${path} is not valid JSON — delete it or run \`pinomad leave\``);
+  }
+  const origin = value?.origin;
+  if (typeof origin !== "string" || origin.trim() === "") {
+    throw new Error(`${path} is missing a string "origin"`);
+  }
+  const { binding, username } = value;
+  return {
+    origin,
+    ...typeof binding === "string" && binding !== "" ? { binding } : {},
+    ...typeof username === "string" && username !== "" ? { username } : {}
+  };
+}
+async function writeJsonFile(path, value) {
+  const tmp = `${path}.tmp-${process.pid}`;
+  await writeFile(tmp, `${JSON.stringify(value)}
+`, { mode: 384 });
+  await rename(tmp, path);
+}
+async function writeServerConfig(dataDir, config) {
+  await writeJsonFile(join(dataDir, SERVER_CONFIG_FILE), {
+    origin: normalizeOrigin(config.origin),
+    binding: randomBytes(16).toString("base64url"),
+    ...config.username === undefined ? {} : { username: config.username }
+  });
+  await rm(join(dataDir, REMOVAL_NOTICE_FILE), { force: true });
+}
+async function markRemoved(dataDir, removed, removedAt = Date.now()) {
+  await writeJsonFile(join(dataDir, REMOVAL_NOTICE_FILE), {
+    origin: normalizeOrigin(removed.origin),
+    ...removed.binding === undefined ? {} : { binding: removed.binding },
+    ...removed.username === undefined ? {} : { username: removed.username },
+    removedAt
+  });
+}
+async function readRemovalNotice(dataDir) {
+  const path = join(dataDir, REMOVAL_NOTICE_FILE);
+  let text;
+  try {
+    text = await readFile(path, "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT")
+      return;
+    throw error;
+  }
+  let value;
+  try {
+    value = JSON.parse(text);
+  } catch {
+    throw new Error(`${path} is not valid JSON — delete it`);
+  }
+  const { origin, binding, username, removedAt } = value ?? {};
+  if (typeof origin !== "string" || typeof removedAt !== "number")
+    throw new Error(`${path} is missing "origin" or "removedAt" — delete it`);
+  return {
+    origin,
+    ...typeof binding === "string" && binding !== "" ? { binding } : {},
+    ...typeof username === "string" && username !== "" ? { username } : {},
+    removedAt
+  };
+}
+async function removeServerConfig(dataDir) {
+  await rm(join(dataDir, SERVER_CONFIG_FILE), { force: true });
+  await rm(join(dataDir, REMOVAL_NOTICE_FILE), { force: true });
+}
+async function readServerBinding(dataDir) {
+  return (await readServerConfig(dataDir))?.binding;
+}
+function resolveRelayOrigin(flag, config) {
+  if (flag !== undefined && config !== undefined && normalizeOrigin(flag) !== normalizeOrigin(config.origin)) {
+    throw new Error(`--relay ${flag} disagrees with ${SERVER_CONFIG_FILE} (${config.origin}) — remove one`);
+  }
+  return flag ?? config?.origin;
+}
+
+export { REMOVAL_NOTICE_FILE, normalizeOrigin, readServerConfig, writeServerConfig, markRemoved, readRemovalNotice, removeServerConfig, readServerBinding, resolveRelayOrigin };

package/dist/{chunk-vvj9b1gc.js → chunk-t5abqsva.js}

@@ -1,7 +1,7 @@
 import {
   ProtocolMismatchError,
   connectRemoteDurable
-} from "./chunk-jt34g8st.js";
+} from "./chunk-np4jd070.js";
 import {
   isParseArgsError
 } from "./chunk-kzbzacz9.js";
@@ -13,7 +13,7 @@ import {
   commandHint,
   hostEntry,
   packagedVersion
-} from "./chunk-sd5fkxjj.js";
+} from "./chunk-7wj0jh3t.js";
 
 // apps/host/src/cli/service.ts
 import { execFile as execFile2 } from "node:child_process";
@@ -245,6 +245,55 @@ import { homedir, userInfo } from "node:os";
 import { dirname, join as join2 } from "node:path";
 import { promisify } from "node:util";
 var run = promisify(execFile);
+var NOT_INSTALLED = { installed: false, stopped: false, running: false, detail: "not installed" };
+function launchdDisabled(printed) {
+  const value = /^\s*"pinomad\.host" => (\w+)\s*$/m.exec(printed)?.[1];
+  return value === "disabled" || value === "true";
+}
+function launchdState(disabled, printed) {
+  if (printed === undefined) {
+    return disabled ? { installed: true, stopped: true, running: false, detail: "stopped" } : { installed: true, stopped: false, running: false, detail: "not loaded" };
+  }
+  const field = (name) => printed.match(new RegExp(`^\\s*${name} = (.+)$`, "m"))?.[1];
+  const state = field("state") ?? "unknown";
+  const pid = field("pid");
+  const exit = field("last exit code");
+  return {
+    installed: true,
+    stopped: false,
+    running: state === "running" && pid !== undefined,
+    ...pid === undefined ? {} : { pid: Number(pid) },
+    detail: [
+      state,
+      ...pid === undefined ? [] : [`pid ${pid}`],
+      ...exit === undefined || exit === "0" || exit === "(never exited)" ? [] : [`last exit ${exit}`],
+      ...disabled ? ["turned off but still loaded"] : []
+    ].join(", ")
+  };
+}
+function systemdState(shown) {
+  const fields = Object.fromEntries(shown.trim().split(`
+`).map((line) => line.split("=", 2)));
+  if (fields.LoadState === "not-found")
+    return NOT_INSTALLED;
+  const pid = Number(fields.MainPID ?? "0");
+  const active = fields.ActiveState === "active";
+  const done = fields.ActiveState === "inactive" || fields.ActiveState === "failed";
+  if (fields.UnitFileState === "disabled" && done)
+    return { installed: true, stopped: true, running: false, detail: "stopped" };
+  return {
+    installed: true,
+    stopped: false,
+    running: active && pid > 0,
+    ...pid > 0 ? { pid } : {},
+    detail: [
+      fields.ActiveState ?? "unknown",
+      fields.SubState ?? "",
+      ...pid > 0 ? [`pid ${pid}`] : [],
+      ...fields.ExecMainStatus === undefined || fields.ExecMainStatus === "0" ? [] : [`last exit ${fields.ExecMainStatus}`]
+    ].filter((part) => part !== "").join(", ")
+  };
+}
 var launchd = {
   async install(spec) {
     await mkdir(join2(spec.dataDir, "logs"), { recursive: true });
@@ -253,6 +302,7 @@ var launchd = {
     await writeFile(path, launchdPlist(spec));
     const domain = `gui/${process.getuid()}/pinomad.host`;
     await run("launchctl", ["bootout", domain]).catch(() => {});
+    await run("launchctl", ["enable", domain]);
     await run("launchctl", ["bootstrap", `gui/${process.getuid()}`, path]);
     return path;
   },
@@ -263,26 +313,27 @@ var launchd = {
   async restart() {
     await run("launchctl", ["kickstart", "-k", `gui/${process.getuid()}/pinomad.host`]);
   },
+  async start() {
+    const domain = `gui/${process.getuid()}/pinomad.host`;
+    await run("launchctl", ["enable", domain]);
+    if (await run("launchctl", ["print", domain]).then(() => true, () => false))
+      return;
+    await run("launchctl", ["bootstrap", `gui/${process.getuid()}`, launchdPlistPath(homedir())]);
+  },
+  async stop() {
+    const domain = `gui/${process.getuid()}/pinomad.host`;
+    await run("launchctl", ["disable", domain]);
+    await run("launchctl", ["bootout", domain]).catch(() => {});
+  },
   async state() {
+    const defined = await readFile(launchdPlistPath(homedir())).then(() => true, () => false);
+    if (!defined)
+      return NOT_INSTALLED;
+    const disabled = await run("launchctl", ["print-disabled", `gui/${process.getuid()}`]).then(({ stdout }) => launchdDisabled(stdout), () => false);
     const printed = await run("launchctl", ["print", `gui/${process.getuid()}/pinomad.host`]).then(({ stdout }) => stdout, () => {
       return;
     });
-    if (printed === undefined)
-      return { installed: false, running: false, detail: "not installed" };
-    const field = (name) => printed.match(new RegExp(`^\\s*${name} = (.+)$`, "m"))?.[1];
-    const state = field("state") ?? "unknown";
-    const pid = field("pid");
-    const exit = field("last exit code");
-    return {
-      installed: true,
-      running: state === "running" && pid !== undefined,
-      ...pid === undefined ? {} : { pid: Number(pid) },
-      detail: [
-        state,
-        ...pid === undefined ? [] : [`pid ${pid}`],
-        ...exit === undefined || exit === "0" || exit === "(never exited)" ? [] : [`last exit ${exit}`]
-      ].join(", ")
-    };
+    return launchdState(disabled, printed);
   },
   async logs(dataDir, lines, follow) {
     const file = join2(dataDir, "logs", "host.log");
@@ -328,34 +379,23 @@ var systemd = {
   async restart() {
     await run("systemctl", ["--user", "restart", "pinomad.service"]);
   },
+  async start() {
+    await run("systemctl", ["--user", "enable", "--now", "pinomad.service"]);
+  },
+  async stop() {
+    await run("systemctl", ["--user", "disable", "--now", "pinomad.service"]);
+  },
   async state() {
     const shown = await run("systemctl", [
       "--user",
       "show",
       "pinomad.service",
       "-p",
-      "LoadState,ActiveState,SubState,MainPID,ExecMainStatus"
+      "LoadState,ActiveState,SubState,MainPID,ExecMainStatus,UnitFileState"
     ]).then(({ stdout }) => stdout, () => {
       return;
     });
-    if (shown === undefined)
-      return { installed: false, running: false, detail: "not installed" };
-    const fields = Object.fromEntries(shown.trim().split(`
-`).map((line) => line.split("=", 2)));
-    if (fields.LoadState === "not-found")
-      return { installed: false, running: false, detail: "not installed" };
-    const pid = Number(fields.MainPID ?? "0");
-    return {
-      installed: true,
-      running: fields.ActiveState === "active" && pid > 0,
-      ...pid > 0 ? { pid } : {},
-      detail: [
-        fields.ActiveState ?? "unknown",
-        fields.SubState ?? "",
-        ...pid > 0 ? [`pid ${pid}`] : [],
-        ...fields.ExecMainStatus === undefined || fields.ExecMainStatus === "0" ? [] : [`last exit ${fields.ExecMainStatus}`]
-      ].filter((part) => part !== "").join(", ")
-    };
+    return shown === undefined ? NOT_INSTALLED : systemdState(shown);
   },
   async logs(_dataDir, lines, follow) {
     const journal = spawn("journalctl", ["--user", "-u", "pinomad.service", "-n", String(lines), ...follow ? ["-f"] : []], {
@@ -410,6 +450,74 @@ async function install(argv) {
   console.log(`data dir: ${spec.dataDir}`);
   console.log(`browser link: ${commandHint("link")}    pairing QR: ${commandHint("pair")}`);
 }
+async function waitUntilIdle(address, connect, log) {
+  try {
+    const remote = await connect(address.url, address.token);
+    await waitForIdle(remote, (tasks) => {
+      log("waiting for running tasks to finish (Ctrl-C to cancel)");
+      for (const task of Object.values(tasks.tasks)) {
+        log(`  ${task.kind} in conversation ${task.conversationId}`);
+      }
+    });
+    remote.close();
+  } catch {}
+}
+async function stopService({
+  force,
+  argv,
+  manager = serviceManager(),
+  connect = connectToHost,
+  log = (line) => console.log(line),
+  logError = (line) => console.error(line)
+}) {
+  const state = await manager.state();
+  if (!state.installed) {
+    log(`service not installed (${commandHint("service")} install)`);
+    return 1;
+  }
+  if (state.stopped) {
+    log("already stopped");
+    return 0;
+  }
+  if (!force) {
+    const spec = argv.length === 0 ? await manager.read() : undefined;
+    const port = spec === undefined ? undefined : argValue(spec.hostArgs, "--port");
+    const flags = spec === undefined ? argv : ["--data-dir", spec.dataDir, ...port === undefined ? [] : ["--url", `ws://127.0.0.1:${port}`]];
+    const address = await hostAddress(flags).catch((error) => {
+      if (isParseArgsError(error))
+        throw error;
+      return;
+    });
+    if (address !== undefined)
+      await waitUntilIdle(address, connect, log);
+  }
+  const holdInterrupt = () => {};
+  process.on("SIGINT", holdInterrupt);
+  try {
+    await manager.stop();
+  } finally {
+    process.off("SIGINT", holdInterrupt);
+  }
+  const after = await manager.state();
+  if (!after.stopped) {
+    logError(`the host is still running (${after.detail}); run \`${commandHint("service")} stop\` again`);
+    return 1;
+  }
+  log(`stopped; it stays off, also after a restart, until \`${commandHint("service")} start\``);
+  return 0;
+}
+async function startService({
+  manager = serviceManager(),
+  log = (line) => console.log(line)
+} = {}) {
+  if (!(await manager.state()).installed) {
+    log(`service not installed (${commandHint("service")} install)`);
+    return 1;
+  }
+  await manager.start();
+  log("started");
+  return 0;
+}
 async function versionLine() {
   if (packagedVersion !== undefined)
     return `version: ${packagedVersion}`;
@@ -432,8 +540,19 @@ async function reachabilityLine(argv) {
     return `host: unreachable (${message(error)})`;
   }
 }
+var serviceStatusJson = (state) => JSON.stringify({
+  installed: state.installed,
+  stopped: state.stopped,
+  running: state.running,
+  ...state.pid === undefined ? {} : { pid: state.pid },
+  detail: state.detail
+});
 async function status(argv) {
   const state = await serviceManager().state();
+  if (argv.includes("--json")) {
+    console.log(serviceStatusJson(state));
+    return;
+  }
   console.log(`service: ${state.installed ? state.detail : "not installed"}`);
   console.log(await versionLine());
   console.log(await reachabilityLine(argv));
@@ -447,27 +566,22 @@ async function restartService({
   pollTimeoutMs = 30000,
   pollDelayMs = 500
 }) {
-  if (!(await manager.state()).installed) {
+  const state = await manager.state();
+  if (!state.installed) {
     console.log(`service not installed (${commandHint("service")} install)`);
     return 1;
   }
+  if (state.stopped && restart === undefined) {
+    console.log(`service stopped (${commandHint("service")} start)`);
+    return 1;
+  }
   const address = await hostAddress(argv).catch((error) => {
     if (isParseArgsError(error))
       throw error;
     return;
   });
-  if (!force && address !== undefined) {
-    try {
-      const remote = await connect(address.url, address.token);
-      await waitForIdle(remote, (tasks) => {
-        console.log("waiting for running tasks to finish (Ctrl-C to cancel)");
-        for (const task of Object.values(tasks.tasks)) {
-          console.log(`  ${task.kind} in conversation ${task.conversationId}`);
-        }
-      });
-      remote.close();
-    } catch {}
-  }
+  if (!force && address !== undefined)
+    await waitUntilIdle(address, connect, (line) => console.log(line));
   await (restart?.() ?? manager.restart());
   if (address === undefined) {
     console.log("restart requested (host address unknown; not polling)");
@@ -525,11 +639,19 @@ async function main(argv) {
         process.exitCode = await restartService({ force, argv: args.filter((arg) => arg !== "--force") });
         break;
       }
+      case "stop": {
+        const force = args.includes("--force");
+        process.exitCode = await stopService({ force, argv: args.filter((arg) => arg !== "--force") });
+        break;
+      }
+      case "start":
+        process.exitCode = await startService();
+        break;
       case "logs":
         await logs(args);
         break;
       default:
-        console.error(`usage: ${commandHint("service")} install|uninstall|status|restart|logs`);
+        console.error(`usage: ${commandHint("service")} install|uninstall|status|restart|stop|start|logs`);
         process.exitCode = 1;
     }
   } catch (error) {
@@ -541,4 +663,4 @@ async function main(argv) {
 }
 if (false) {}
 
-export { installSpec, argValue, withoutArg, withoutRelayArgs, serviceManager, versionLine, reachabilityLine, restartService, main };
+export { installSpec, argValue, withoutArg, withoutRelayArgs, serviceManager, stopService, startService, versionLine, reachabilityLine, serviceStatusJson, restartService, main };

package/dist/{chunk-tj57aqav.js → chunk-vqkb70d7.js}

@@ -1,7 +1,7 @@
 import {
   connectRemoteDurable
-} from "./chunk-jt34g8st.js";
-import"./chunk-xqycs43g.js";
+} from "./chunk-np4jd070.js";
+import"./chunk-47ff1d1t.js";
 import {
   isLoopbackUrl
 } from "./chunk-pqe7q1s7.js";