@ccmsg/cli 0.9.0 → 0.10.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ccmsg/cli",
-  "version": "0.9.0",
+  "version": "0.10.1",
   "description": "The ccmsg daemon, CLI and agent plugins for one instance (= one config home)",
   "license": "MIT",
   "author": "kawaz",

package/src/auth/admin.ts

@@ -22,23 +22,49 @@ export type AdminRequest =
       readonly sub?: Subject;
     }
   | { readonly admin: "passkey_list"; readonly request_id: string }
-  | { readonly admin: "passkey_remove"; readonly request_id: string; readonly sub: Subject };
+  | { readonly admin: "passkey_remove"; readonly request_id: string; readonly sub: Subject }
+  /** Stop being a peer of this endpoint, now rather than at the next start.
+   *
+   * Here with the passkey requests because it is the same kind of thing: what
+   * this host is prepared to talk to, said from the machine it runs on, on the
+   * socket where reaching the address is the permission. `ccmsg mesh remove`
+   * has already taken it off the list; this is the running instance being told
+   * so, because a revocation that waited for a restart would leave the link it
+   * revoked standing. */
+  | { readonly admin: "mesh_forget"; readonly request_id: string; readonly endpoint: Endpoint };
+
+const ADMIN_NAMES = ["passkey_add", "passkey_list", "passkey_remove", "mesh_forget"];
 
 /** Whether a frame is one of these, without deciding anything about it. */
 export function adminRequestOf(frame: unknown): AdminRequest | undefined {
   if (typeof frame !== "object" || frame === null) return undefined;
   const fields = frame as Record<string, unknown>;
-  const name = fields["admin"];
-  if (name !== "passkey_add" && name !== "passkey_list" && name !== "passkey_remove") {
-    return undefined;
-  }
+  if (!ADMIN_NAMES.includes(fields["admin"] as string)) return undefined;
   return typeof fields["request_id"] === "string" ? (frame as AdminRequest) : undefined;
 }
 
+/** What an administrative request is asked of: the passkeys, and the mesh on an
+ * instance that has one. */
+export interface Administered {
+  readonly auth: Auth;
+  readonly mesh?: { forget(peer: Endpoint): boolean };
+}
+
 /** Run one administrative request. */
-export function handleAdmin(auth: Auth, request: AdminRequest): DispatchResult {
+export function handleAdmin(at: Administered, request: AdminRequest): DispatchResult {
+  const auth = at.auth;
   try {
     switch (request.admin) {
+      case "mesh_forget": {
+        const mesh = at.mesh;
+        if (mesh === undefined) {
+          return reply(request.request_id, { endpoint: request.endpoint, dropped: false });
+        }
+        return reply(request.request_id, {
+          endpoint: request.endpoint,
+          dropped: mesh.forget(request.endpoint),
+        });
+      }
       case "passkey_add":
         return reply(
           request.request_id,

package/src/cli.ts

@@ -1,5 +1,6 @@
 #!/usr/bin/env bun
 import {
+  type Endpoint,
   type MessageSendArgs,
   type NotifySendArgs,
   PROTOCOL_VERSION,
@@ -26,10 +27,12 @@ import {
   rowFor,
   snapshots,
   type SuperviseOp,
+  clusterFor,
   Supervisor,
   tailOf,
   type Target,
   targetFor,
+  targetNamed,
 } from "./daemon/index.ts";
 import { readFileSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
@@ -43,22 +46,15 @@ const SESSION_ENV = HARNESSES.flatMap((harness) => [...HARNESS[harness].sessionE
 import { hookEvent, type StatedMeta, statedMeta } from "./greeting/index.ts";
 import {
   isRunning,
-  MERGE_RULES,
+  loadClusters,
+  resolveConfigDir,
   resolveConfigHome,
   resolvePaths,
   resolvePathsFor,
+  saveCluster,
+  saveClusters,
   start,
 } from "./instance/index.ts";
-
-/** The merge rules as the help prints them: one line per field path, in the
- * order the schema declares them, so the table a person reads is the table the
- * merge runs on. */
-const MERGE_DOCS: readonly Doc[] = Object.entries(MERGE_RULES).map(([path, rule]) => [
-  path,
-  rule === "merge"
-    ? "instances[] 側にある field だけを defaults に重ねる"
-    : "instances[] 側にあれば丸ごと置換する (追加・和にはならない)",
-]);
 import {
   type Agent,
   AGENTS,
@@ -151,7 +147,7 @@ const ROOT: Command = {
         {
           name: "run",
           summary: "この config home の instance を foreground で起動する (監督者の管理外)",
-          usage: "ccmsg daemon run [dir]",
+          usage: "ccmsg daemon run [name | id | dir]",
           bare: true,
           run: (args) => runInstance(args[0]),
         },
@@ -164,9 +160,14 @@ const ROOT: Command = {
         },
         {
           name: "add",
-          summary: "共通 config の instances[] に足し、監督者が居れば起こさせる",
-          usage: "ccmsg daemon add <dir> [--harness <種別>]",
+          summary: "config home を cluster に足し、instances/instance-<id>.ts を書く",
+          usage: "ccmsg daemon add <dir> [--cluster <id|name>] [--port <番号>] [--harness <種別>]",
           options: [
+            [
+              "--cluster <id|name>",
+              "入れる cluster (既定: 1 つならそれ、無ければ新規。知らない id ならその id で作る)",
+            ],
+            ["--port <番号>", "entry の待ち受けポート (既定は登録済みの最大 + 1 の空きポート)"],
             [
               "--harness <種別>",
               `config home が動かすもの: ${HARNESSES.join(" | ")} (既定 ${DEFAULT_HARNESS})`,
@@ -174,94 +175,169 @@ const ROOT: Command = {
           ],
           notes: [
             {
-              title:
-                "共通 config で instances[] の値が defaults に重なる規則 (掲載の無いパスは丸ごと置換):",
-              docs: MERGE_DOCS,
+              title: "何がどのファイルに載るか (載っていないファイルは読まない):",
+              docs: [
+                ["config_v2.ts", "全 instance が受け取る値。`({builtin, config}) => config`"],
+                ["clusters.json", "この host が知る cluster の id 一覧"],
+                [
+                  "clusters/cluster-<id>.json",
+                  "name / peers (別 host の endpoint) / instances (id)",
+                ],
+                [
+                  "instances/instance-<id>.ts",
+                  "1 instance 分の差分。`({builtin, default, config}) => config`",
+                ],
+                [
+                  "ccmsg-config_v2.d.ts",
+                  "設定ファイルが `import type` で参照する型 (ccmsg が置く)",
+                ],
+              ],
             },
           ],
           run: (args) => added(args),
         },
         {
           name: "remove",
-          summary: "instances[] から外す (監督者は以後見ないが、子は止めない)",
-          usage: "ccmsg daemon remove <dir>",
+          summary: "cluster から外して instances/instance-<id>.ts を消す (子は止めない)",
+          usage: "ccmsg daemon remove <name | id | dir>",
           run: (args) => removed(args[0]),
         },
         {
           name: "list",
-          summary: "登録されている config home と、動いているかを並べる",
+          summary: "cluster ごとに instance と、動いているかを並べる",
           usage: "ccmsg daemon list",
           bare: true,
-          run: () => Promise.resolve(listInstances(process.env)),
+          run: () => listInstances(process.env),
         },
         {
           name: "start",
           summary: "監督者に、この config home の子を起こさせる",
-          usage: "ccmsg daemon start <dir> | --all",
+          usage: "ccmsg daemon start <name | dir> | --all",
           run: (args) => supervised("supervise_start", args),
         },
         {
           name: "stop",
           summary: "監督者に、子を止めさせる (instance.shutdown、以後は上げ直さない)",
-          usage: "ccmsg daemon stop <dir> | --all",
+          usage: "ccmsg daemon stop <name | dir> | --all",
           run: (args) => supervised("supervise_stop", args),
         },
         {
           name: "restart",
           summary: "監督者に、止めてから起こし直させる",
-          usage: "ccmsg daemon restart <dir> | --all",
+          usage: "ccmsg daemon restart <name | dir> | --all",
           run: (args) => supervised("supervise_restart", args),
         },
         {
           name: "status",
           summary: "監督者が各子に instance.ping して version・network・peers を答える",
-          usage: "ccmsg daemon status [dir] | --all",
+          usage: "ccmsg daemon status [name | id | dir] | --all",
           bare: true,
           run: (args) => supervised("supervise_status", args, true),
         },
         {
           name: "passkey",
-          summary: "この config home の instance に登録された passkey を扱う",
-          usage: "ccmsg daemon passkey <subcommand>",
+          summary: "cluster に登録された利用者の passkey を扱う",
+          usage: "ccmsg daemon passkey <subcommand> [--cluster <id|name>]",
+          options: [["--cluster <id|name>", "どの cluster か (既定: cluster が 1 つならそれ)"]],
+          notes: [
+            {
+              title: "passkey は cluster のもの (記録は cluster 内に複製される):",
+              docs: [
+                ["どこへ問うか", "その cluster で動いている instance のどれか (どれでも同じ答え)"],
+                ["動いていない時", "instance を起動してから (登録は動いている instance が行う)"],
+              ],
+            },
+          ],
           children: [
             {
               name: "add",
               summary: "登録用 URL と 6 桁コードを 1 組発行する (10 分で失効)",
-              usage: "ccmsg daemon passkey add <unit> [endpoint] [--name <ラベル>]",
+              usage: "ccmsg daemon passkey add [endpoint] [--cluster <id|name>] [--name <ラベル>]",
               options: [
                 [
                   "[endpoint]",
-                  "登録先の公開 base URL (末尾 /)。既定はこの instance が確定した endpoint",
+                  "登録先の公開 base URL (末尾 /)。既定は答えた instance が確定した endpoint",
                 ],
                 ["--name <ラベル>", "誰宛に発行した URL かの管理ラベル"],
               ],
+              bare: true,
               run: (args) => passkeyAdd(args),
             },
             {
               name: "list",
               summary: "登録済みの credential を、新しい順に並べる",
-              usage: "ccmsg daemon passkey list [unit]",
+              usage: "ccmsg daemon passkey list [--cluster <id|name>]",
               bare: true,
-              run: (args) => passkeyAsk(args[0], { admin: "passkey_list" }),
+              run: (args) => passkeyCommand(args, () => ({ admin: "passkey_list" })),
             },
             {
               name: "remove",
               summary: "利用者を消す (credential と token を失効させ、その WS を切る)",
-              usage: "ccmsg daemon passkey remove <sub> [unit]",
-              run: (args) => passkeyRemove(args),
+              usage: "ccmsg daemon passkey remove <sub> [--cluster <id|name>]",
+              run: (args) =>
+                passkeyCommand(args, (rest) => {
+                  const sub = rest[0];
+                  if (sub === undefined) {
+                    throw new CommandError(
+                      "invalid_args",
+                      "使い方: ccmsg daemon passkey remove <sub> [--cluster <id|name>]",
+                    );
+                  }
+                  return { admin: "passkey_remove", sub };
+                }),
             },
           ],
         },
         {
           name: "log",
           summary: "instance の daemon.log を出す (--all は行に id を足して多重化)",
-          usage: "ccmsg daemon log [dir] | --all [--follow]",
+          usage: "ccmsg daemon log [name | id | dir] | --all [--follow]",
           options: [["--follow", "書き足される行を待ち続ける (Ctrl-C で終わり)"]],
           bare: true,
           run: (args) => daemonLog(args),
         },
       ],
     },
+    {
+      name: "mesh",
+      summary: "cluster の mesh に別 host の endpoint を出し入れする",
+      usage: "ccmsg mesh <subcommand> [endpoint] [--cluster <id|name>]",
+      options: [["--cluster <id|name>", "どの cluster の mesh か (既定: cluster が 1 つならそれ)"]],
+      notes: [
+        {
+          title: "cluster 内の instance 同士は自動で mesh に入る (各 TS の endpoint / port):",
+          docs: [
+            [
+              "cluster の peers",
+              "別 host の endpoint だけを並べる。instance id は handshake で伝わる",
+            ],
+            ["add の反映", "次に instance が起動した時 (config は起動時に 1 回だけ読む)"],
+            ["remove の反映", "即時。繋がっている相手なら切る"],
+          ],
+        },
+      ],
+      children: [
+        {
+          name: "add",
+          summary: "endpoint を cluster の peer に足す (知らない cluster id ならその id で作る)",
+          usage: "ccmsg mesh add <endpoint> [--cluster <id|name>]",
+          run: (args) => meshPeers("add", args),
+        },
+        {
+          name: "list",
+          summary: "cluster の peer を並べる (--cluster 無しで cluster が複数なら全部)",
+          usage: "ccmsg mesh list [--cluster <id|name>]",
+          bare: true,
+          run: (args) => meshPeers("list", args),
+        },
+        {
+          name: "remove",
+          summary: "endpoint を cluster の peer から外し、繋がっていれば切る",
+          usage: "ccmsg mesh remove <endpoint> [--cluster <id|name>]",
+          run: (args) => meshPeers("remove", args),
+        },
+      ],
+    },
     {
       name: "service",
       summary: "監督者 (ccmsg daemon supervise) を launchd / systemd に登録する",
@@ -568,10 +644,11 @@ function section(lines: string[], title: string, docs: readonly Doc[] | undefine
   lines.push("");
 }
 
-/** `ccmsg daemon run [dir]`: this config home's instance, in the foreground. */
-async function runInstance(dir: string | undefined): Promise<unknown> {
-  const named = dir ?? resolveConfigHome();
-  const home = configHome(named, harnessFor(process.env, named));
+/** `ccmsg daemon run [name | dir]`: this config home's instance, in the
+ * foreground. */
+async function runInstance(given: string | undefined): Promise<unknown> {
+  const named = (await dirOf(given)) ?? resolveConfigHome();
+  const home = configHome(named, await harnessFor(process.env, named));
   // The directory is handed over rather than put in the environment: the
   // instance would otherwise read it back through the question "which session
   // is this process inside", and a `daemon run` issued from a session of
@@ -620,31 +697,142 @@ async function supervise(): Promise<unknown> {
  * the supervisor reads the list once (DV-Q8) and would otherwise not know
  * until it is restarted. */
 async function added(args: readonly string[]): Promise<unknown> {
-  const { named, rest } = options(args, ["harness"]);
+  const { named, rest } = options(args, ["harness", "port", "cluster"]);
   const dir = rest[0];
   const stated = named.get("harness");
+  const port = named.get("port");
   if (dir === undefined) {
-    throw new CommandError("invalid_args", "使い方: ccmsg daemon add <dir> [--harness <種別>]");
+    throw new CommandError(
+      "invalid_args",
+      "使い方: ccmsg daemon add <dir> [--cluster <id|name>] [--port <番号>] [--harness <種別>]",
+    );
   }
   if (stated !== undefined && !isHarness(stated)) {
     throw new CommandError("invalid_args", `--harness は ${HARNESSES.join(" | ")} のどれかです`);
   }
-  const row = addToConfig(process.env, dir, stated ?? DEFAULT_HARNESS);
+  if (port !== undefined && !/^\d{1,5}$/.test(port)) {
+    throw new CommandError("invalid_args", "--port は 0 から 65535 の番号です");
+  }
+  const row = await addToConfig(process.env, dir, {
+    ...(named.get("cluster") === undefined ? {} : { cluster: named.get("cluster") as string }),
+    ...(stated === undefined ? {} : { harness: stated }),
+    ...(port === undefined ? {} : { port: Number(port) }),
+  });
   if (!(await reachable())) return { ...row, supervised: false };
   const started = (await ask({ op: "supervise_add", dir: row.dir })) as Record<string, unknown>;
-  return { ...started, supervised: true };
+  return { ...started, name: row.name, supervised: true };
 }
 
-/** `ccmsg daemon remove <dir>`: take it off the list, and stop looking after it.
+/** `ccmsg mesh <what> [endpoint]`: the mesh endpoints this host does not serve
+ * itself.
+ *
+ * Its own command rather than one under `daemon`, because what it edits is not
+ * one instance's anything: every instance of this host is in the same mesh
+ * (§7.1), so the list is the host's. `peers` is what a session list is called,
+ * which is why this is called what the thing itself is called.
  *
- * The instance itself is left alone: a list edit is not a shutdown, and a
+ * An addition takes effect when the instances next start, for the reason
+ * nothing else reloads either (DV-Q8). A removal is told to whoever is running
+ * as well as written down: an endpoint taken off the list is one this host is
+ * not to be talking to, and leaving a live link up until the next restart would
+ * be leaving exactly the connection that was just revoked. */
+async function meshPeers(what: "add" | "list" | "remove", args: readonly string[]) {
+  const parsed = options(args, ["cluster"]);
+  const configDir = resolveConfigDir();
+  const clusters = loadClusters(configDir);
+  if (what === "list" && parsed.named.get("cluster") === undefined && clusters.length !== 1) {
+    // Every cluster's own, because a list of addresses with no cluster beside
+    // them would not say which mesh each belongs to.
+    return {
+      clusters: clusters.map((one) => ({ id: one.id, name: one.name, peers: one.peers })),
+    };
+  }
+  const cluster = clusterFor(clusters, parsed.named.get("cluster"));
+  if (what === "list") {
+    return { cluster_id: cluster.id, cluster_name: cluster.name, peers: cluster.peers };
+  }
+  const given = parsed.rest[0];
+  if (given === undefined) {
+    throw new CommandError(
+      "invalid_args",
+      `使い方: ccmsg mesh ${what} <endpoint> [--cluster <id|name>]`,
+    );
+  }
+  const endpoint = endpointGiven(given);
+  const known = clusters.some((one) => one.id === cluster.id);
+  if (what === "add") {
+    if (cluster.peers.includes(endpoint)) {
+      throw new CommandError("file_exists", `${endpoint} は既に ${cluster.name} の peer です`);
+    }
+    saveCluster(configDir, { ...cluster, peers: [...cluster.peers, endpoint] });
+    if (!known) saveClusters(configDir, [...clusters.map((one) => one.id), cluster.id]);
+    // Said rather than left to be noticed: the running instances read the list
+    // when they started, so the one thing a person wants to know here is that
+    // this peer is not dialled yet.
+    return {
+      cluster_id: cluster.id,
+      cluster_name: cluster.name,
+      endpoint,
+      added: true,
+      restart_needed: (await runningIn(cluster.id)).length > 0,
+    };
+  }
+  if (!cluster.peers.includes(endpoint)) {
+    throw new CommandError("not_found", `${endpoint} は ${cluster.name} の peer ではありません`);
+  }
+  saveCluster(configDir, {
+    ...cluster,
+    peers: cluster.peers.filter((peer) => peer !== endpoint),
+  });
+  const cut: string[] = [];
+  for (const target of await runningIn(cluster.id)) {
+    const answer = (await askInstance(target, { admin: "mesh_forget", endpoint })) as {
+      dropped?: boolean;
+    };
+    if (answer.dropped === true) cut.push(target.name ?? target.dir);
+  }
+  return {
+    cluster_id: cluster.id,
+    cluster_name: cluster.name,
+    endpoint,
+    removed: true,
+    disconnected: cut,
+  };
+}
+
+/** The instances of one cluster that have something answering right now, which
+ * are the ones a change to that cluster's mesh has to reach. */
+async function runningIn(cluster: string): Promise<Target[]> {
+  return (await registered(process.env)).filter(
+    (target) => (target.clusters ?? []).some((one) => one.id === cluster) && rowFor(target).running,
+  );
+}
+
+/** An endpoint as the contract spells it, from what a person typed: the base
+ * URL of an instance, ending in the slash everything it serves hangs off. The
+ * slash is added rather than demanded — a person pasting an address from a
+ * browser has one without it, and the two are the same address. */
+function endpointGiven(given: string): Endpoint {
+  const text = given.endsWith("/") ? given : `${given}/`;
+  if (!/^https?:\/\/[^\s?#]*\/$/.test(text)) {
+    throw new CommandError(
+      "invalid_args",
+      `${given} は endpoint になりません (http:// か https:// で始まる base URL)`,
+    );
+  }
+  return text as Endpoint;
+}
+
+/** `ccmsg daemon remove <name>`: take its file away, and stop looking after it.
+ *
+ * The instance itself is left alone: removing the file is not a shutdown, and a
  * session already talking to that instance keeps it. `daemon stop` is how one
  * is stopped, and keeping the two apart is what makes that true. */
-async function removed(dir: string | undefined): Promise<unknown> {
-  if (dir === undefined) {
-    throw new CommandError("invalid_args", "使い方: ccmsg daemon remove <dir>");
+async function removed(name: string | undefined): Promise<unknown> {
+  if (name === undefined) {
+    throw new CommandError("invalid_args", "使い方: ccmsg daemon remove <name>");
   }
-  const row = removeFromConfig(process.env, dir);
+  const row = await removeFromConfig(process.env, name);
   if (!(await reachable())) return { ...row, supervised: false };
   await ask({ op: "supervise_remove", dir: row.dir });
   return { ...row, supervised: false };
@@ -666,14 +854,26 @@ async function supervised(
   const all = parsed.flags.has("all");
   const named = parsed.rest[0];
   if (all && named !== undefined) {
-    throw new CommandError("invalid_args", "--all と dir は同時に指定できません");
+    throw new CommandError("invalid_args", "--all と name は同時に指定できません");
   }
   if (all) return await ask({ op, all: true });
-  const dir = named ?? (hereByDefault ? resolveConfigHome() : undefined);
-  if (dir === undefined) throw new CommandError("invalid_args", "dir か --all が要ります");
+  const dir = (await dirOf(named)) ?? (hereByDefault ? resolveConfigHome() : undefined);
+  if (dir === undefined) throw new CommandError("invalid_args", "name か --all が要ります");
   return await ask({ op, dir });
 }
 
+/** The config home a command was given, by either of the two things a person
+ * has to hand: the name they added it under, or the directory itself.
+ *
+ * A name first, because that is what `daemon add` took and so what a person
+ * has written down; anything nobody registered under that name is taken as the
+ * directory it looks like, which is what makes `daemon run` on an unregistered
+ * config home reachable. */
+async function dirOf(given: string | undefined): Promise<string | undefined> {
+  if (given === undefined) return undefined;
+  return (await targetNamed(process.env, given))?.dir ?? given;
+}
+
 /** `ccmsg service <what>`: the supervisor's registration with the host. */
 async function serviceOp(
   what: "register" | "unregister" | "start" | "stop" | "status",
@@ -694,22 +894,26 @@ async function serviceOp(
     kind: service.kind,
     unit: service.unitFile,
     ...state,
-    instances: registered(process.env).map((target) => {
+    instances: (await registered(process.env)).map((target) => {
       const row = rowFor(target);
       return { id: row.id, dir: row.dir, running: row.running };
     }),
   };
 }
 
-/** The passkey commands, which are asked of the instance itself rather than of
- * the supervisor.
+/** The passkey commands, which are asked of an instance of the cluster rather
+ * than of the supervisor.
  *
- * They travel on the instance's unix socket and nowhere else: registration is
+ * They travel on an instance's unix socket and nowhere else: registration is
  * local by design (DR-0001 §2.2), and reaching that address is what says the
  * caller is on the machine. They are not ops of the contract for the same
- * reason — the contract is what reaches an instance over a network. */
-async function passkeyAsk(unit: string | undefined, request: Record<string, unknown>) {
-  const target = targetFor(process.env, unit ?? resolveConfigHome());
+ * reason — the contract is what reaches an instance over a network.
+ *
+ * Which instance is asked does not matter, and that is the point of the
+ * cluster: a credential registered at one is replicated to the others, so the
+ * cluster is what a passkey belongs to and any instance of it can answer. */
+/** One administrative request, on one instance's own unix socket. */
+async function askInstance(target: Target, request: Record<string, unknown>) {
   const conn = await connect(target.paths.socket);
   if (conn === undefined) {
     throw new CommandError("not_found", `${target.dir} の instance は動いていません`);
@@ -727,6 +931,31 @@ async function passkeyAsk(unit: string | undefined, request: Record<string, unkn
   }
 }
 
+async function passkeyCommand(
+  args: readonly string[],
+  request: (rest: readonly string[]) => Record<string, unknown>,
+): Promise<unknown> {
+  const parsed = options(args, ["cluster", "name"]);
+  const asked = request(parsed.rest);
+  const cluster = clusterFor(loadClusters(resolveConfigDir()), parsed.named.get("cluster"));
+  const reachable = await runningIn(cluster.id);
+  const target = reachable[0];
+  if (target === undefined) {
+    throw new CommandError(
+      "instance_unreachable",
+      `${cluster.name} で動いている instance がありません (ccmsg daemon start で起こしてください)`,
+    );
+  }
+  // Any one of them: what is registered is replicated across the cluster
+  // (DR-0001 §2.6), so which instance answered is not part of the answer.
+  return {
+    cluster_id: cluster.id,
+    cluster_name: cluster.name,
+    instance: target.name ?? target.dir,
+    ...((await askInstance(target, asked)) as Record<string, unknown>),
+  };
+}
+
 /** `ccmsg daemon passkey add`: one registration URL, and the code that goes
  * with it.
  *
@@ -734,30 +963,18 @@ async function passkeyAsk(unit: string | undefined, request: Record<string, unkn
  * anything the instance hands out — so that holding the URL is not enough to
  * register (DR-0001 §2.2). */
 async function passkeyAdd(args: readonly string[]): Promise<unknown> {
-  const parsed = options(args, ["name"]);
-  const [unit, endpoint] = parsed.rest;
-  if (unit === undefined) {
-    throw new CommandError(
-      "invalid_args",
-      "使い方: ccmsg daemon passkey add <unit> [endpoint] [--name <ラベル>]",
-    );
-  }
-  const name = parsed.named.get("name");
-  return await passkeyAsk(unit, {
-    admin: "passkey_add",
-    ...(endpoint === undefined ? {} : { endpoint }),
-    ...(name === undefined ? {} : { name }),
+  return await passkeyCommand(args, (rest) => {
+    const endpoint = rest[0];
+    const parsed = options(args, ["cluster", "name"]);
+    const name = parsed.named.get("name");
+    return {
+      admin: "passkey_add",
+      ...(endpoint === undefined ? {} : { endpoint }),
+      ...(name === undefined ? {} : { name }),
+    };
   });
 }
 
-async function passkeyRemove(args: readonly string[]): Promise<unknown> {
-  const [sub, unit] = args;
-  if (sub === undefined) {
-    throw new CommandError("invalid_args", "使い方: ccmsg daemon passkey remove <sub> [unit]");
-  }
-  return await passkeyAsk(unit, { admin: "passkey_remove", sub });
-}
-
 /** `ccmsg daemon log`: what one instance wrote down, or what all of them did.
  *
  * JSON lines rather than one document, because a log is a stream and `--follow`
@@ -772,7 +989,7 @@ async function daemonLog(args: readonly string[]): Promise<undefined> {
   // shape whether the host runs one or five.
   const many = parsed.flags.has("all");
   const targets = many
-    ? registered(process.env)
+    ? await registered(process.env)
     : [targetFor(process.env, parsed.rest[0] ?? resolveConfigHome())];
   const write = (target: Target, lines: readonly string[]): void => {
     for (const line of lines) {
@@ -1191,7 +1408,7 @@ async function plugin(
   }
   // `status` with no agent named answers for the config home this process
   // belongs to, which is what the instance there runs.
-  const which = agent ?? harnessFor(process.env, resolvePaths().configHome);
+  const which = agent ?? (await harnessFor(process.env, resolvePaths().configHome));
   // The config home is that agent's own, and not whichever variable happens to
   // be set: a Codex session started from a Claude Code session carries both,
   // and an install that read the wrong one would write Codex's hooks into