@ccmsg/cli 0.9.1 → 0.11.0

package/src/cli.ts

@@ -30,10 +30,19 @@ import {
   tailOf,
   type Target,
   targetFor,
+  targetNamed,
 } from "./daemon/index.ts";
-import { readFileSync, writeFileSync } from "node:fs";
+import {
+  copyFileSync,
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  readFileSync,
+  statSync,
+  writeFileSync,
+} from "node:fs";
 import { homedir } from "node:os";
-import { isAbsolute, join } from "node:path";
+import { dirname, isAbsolute, join, relative } from "node:path";
 import { document } from "./transcript/items/index.ts";
 import { currentSession, DEFAULT_HARNESS, HARNESS, HARNESSES, isHarness } from "./harness/index.ts";
 
@@ -42,23 +51,20 @@ import { currentSession, DEFAULT_HARNESS, HARNESS, HARNESSES, isHarness } from "
 const SESSION_ENV = HARNESSES.flatMap((harness) => [...HARNESS[harness].sessionEnv]);
 import { hookEvent, type StatedMeta, statedMeta } from "./greeting/index.ts";
 import {
+  applied,
+  configFiles,
+  evaluate,
   isRunning,
-  MERGE_RULES,
+  REJECTED_DIR,
+  resolveConfigDir,
   resolveConfigHome,
   resolvePaths,
   resolvePathsFor,
+  SATISFIED_FILE,
+  type Satisfied,
+  STATE_CONFIG_DIR,
   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,22 +157,23 @@ 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]),
         },
         {
           name: "supervise",
-          summary: "共通 config の instance を子プロセスとして起動し、落ちたら上げる",
+          summary: "検証済みの設定が挙げる instance を子として起動し、落ちたら上げる",
           usage: "ccmsg daemon supervise",
           bare: true,
           run: () => supervise(),
         },
         {
           name: "add",
-          summary: "共通 config の instances[] に足し、監督者が居れば起こさせる",
-          usage: "ccmsg daemon add <dir> [--harness <種別>]",
+          summary: "config home を instance として書き留め、監督者が居れば起こさせる",
+          usage: "ccmsg daemon add <dir> [--port <番号>] [--harness <種別>]",
           options: [
+            ["--port <番号>", "entry の待ち受けポート (既定は登録済みの最大 + 1 の空きポート)"],
             [
               "--harness <種別>",
               `config home が動かすもの: ${HARNESSES.join(" | ")} (既定 ${DEFAULT_HARNESS})`,
@@ -174,48 +181,59 @@ const ROOT: Command = {
           ],
           notes: [
             {
-              title:
-                "共通 config で instances[] の値が defaults に重なる規則 (掲載の無いパスは丸ごと置換):",
-              docs: MERGE_DOCS,
+              title: "何がどのファイルに載るか (載っていないファイルは読まない):",
+              docs: [
+                ["config_v2.ts", "全 instance が受け取る値。`({builtin, config}) => config`"],
+                ["endpoints.json", "mesh の一覧 `[{id, endpoint}]`。別 host の分は人が足す"],
+                ["supervisor.json", "この host が起こす instance の 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: "両 JSON から外して instances/instance-<id>.ts を消す (子は止めない)",
+          usage: "ccmsg daemon remove <name | id | dir>",
           run: (args) => removed(args[0]),
         },
         {
           name: "list",
-          summary: "登録されている config home と、動いているかを並べる",
+          summary: "この host が起こす 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),
         },
@@ -229,10 +247,7 @@ const ROOT: Command = {
               summary: "登録用 URL と 6 桁コードを 1 組発行する (10 分で失効)",
               usage: "ccmsg daemon passkey add <unit> [endpoint] [--name <ラベル>]",
               options: [
-                [
-                  "[endpoint]",
-                  "登録先の公開 base URL (末尾 /)。既定はこの instance が確定した endpoint",
-                ],
+                ["[endpoint]", "登録先の公開 base URL (末尾 /)。既定はこの instance の endpoint"],
                 ["--name <ラベル>", "誰宛に発行した URL かの管理ラベル"],
               ],
               run: (args) => passkeyAdd(args),
@@ -255,13 +270,63 @@ const ROOT: Command = {
         {
           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: "config",
+      summary: "設定ファイルの検証と、適用済みとの差を見る",
+      usage: "ccmsg config <subcommand> [file] [options]",
+      notes: [
+        {
+          title: "人が編集するのは config dir、instance が読むのは検証済みの写し:",
+          docs: [
+            [
+              "編集用",
+              "$CCMSG_CONFIG_DIR (config_v2.ts / endpoints.json / supervisor.json / instances/)",
+            ],
+            ["適用用", "$CCMSG_STATE_DIR/config (検証を通った時だけ書かれる写しと satisfied.json)"],
+            ["通らない時", "適用済みのまま起動する。エラーは log と daemon status に出る"],
+          ],
+        },
+      ],
+      children: [
+        {
+          name: "list",
+          summary: "設定ファイルごとの検証結果と、適用済みとの差の有無を並べる",
+          usage: "ccmsg config list",
+          bare: true,
+          run: () => configList(),
+        },
+        {
+          name: "diff",
+          summary: "編集中のファイルと適用済みの写しの差 (--satisfied は適用したら何が変わるか)",
+          usage: "ccmsg config diff [file] | --satisfied",
+          options: [["--satisfied", "今の satisfied.json と、編集中から評価し直した物の差"]],
+          bare: true,
+          run: (args) => configDiff(args),
+        },
+        {
+          name: "show",
+          summary: "編集中を検証・評価して satisfied の形で表示する (書き込まない)",
+          usage: "ccmsg config show [--applied]",
+          options: [["--applied", "今使っている satisfied.json を表示する"]],
+          bare: true,
+          run: (args) => configShow(args),
+        },
+        {
+          name: "revert",
+          summary: "適用済みの写しで編集中を上書きする (壊れた方は退避してパスを出す)",
+          usage: "ccmsg config revert <file> | --all",
+          options: [["--all", "差のあるファイルを全部戻す"]],
+          run: (args) => configRevert(args),
+        },
+      ],
+    },
     {
       name: "service",
       summary: "監督者 (ccmsg daemon supervise) を launchd / systemd に登録する",
@@ -568,15 +633,19 @@ 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
   // another harness would answer for that session's config home (§3.8).
-  const outcome = await start({ configHome: home });
+  // With a supervisor up, it is the one that reads the files and writes down
+  // what held (§8.2); this start reads what it applied. With none, this
+  // process is the only one there is, so it does both.
+  const outcome = await start({ configHome: home, settle: !(await reachable()) });
   if (!isRunning(outcome)) {
     throw new CommandError(
       "file_exists",
@@ -620,36 +689,268 @@ 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"]);
   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> [--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, {
+    ...(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. */
+/** `ccmsg daemon remove <name | id | dir>`: 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(ref: string | undefined): Promise<unknown> {
+  if (ref === undefined) {
+    throw new CommandError("invalid_args", "使い方: ccmsg daemon remove <name | id | dir>");
   }
-  const row = removeFromConfig(process.env, dir);
+  const row = await removeFromConfig(process.env, ref);
   if (!(await reachable())) return { ...row, supervised: false };
   await ask({ op: "supervise_remove", dir: row.dir });
   return { ...row, supervised: false };
 }
 
+async function configList(): Promise<unknown> {
+  const configDir = resolveConfigDir();
+  const stateRoot = resolvePaths().stateRoot;
+  const read = await evaluate(configDir);
+  const ids = (read.satisfied ?? applied(stateRoot))?.supervisor.instances ?? [];
+  const files = configFiles(configDir, ids).map((file) => {
+    const copy = join(stateRoot, STATE_CONFIG_DIR, relative(configDir, file));
+    return {
+      file,
+      present: existsSync(file),
+      // What is wrong with this one, as the check said it: a person reading
+      // this is about to open the file, so the line they need is beside it.
+      problems: read.problems.filter((one) => one.file === file).map((one) => one.msg),
+      applied: existsSync(copy),
+      differs: existsSync(file) && existsSync(copy) ? !same(file, copy) : existsSync(file),
+    };
+  });
+  const rejected = rejectedFiles(stateRoot);
+  return {
+    ok: read.satisfied !== undefined,
+    files,
+    ...(read.problems.length === 0 ? {} : { problems: read.problems }),
+    rejected: {
+      count: rejected.length,
+      ...(rejected[0] === undefined
+        ? {}
+        : { latest: rejected[0].at, dir: join(stateRoot, REJECTED_DIR) }),
+    },
+  };
+}
+
+/** What one edited file and its checked copy differ by, or what applying the
+ * edits would change about the whole. */
+async function configDiff(args: readonly string[]): Promise<unknown> {
+  const parsed = options(args, [], ["satisfied"]);
+  const configDir = resolveConfigDir();
+  const stateRoot = resolvePaths().stateRoot;
+  if (parsed.flags.has("satisfied")) {
+    const read = await evaluate(configDir);
+    if (read.satisfied === undefined) {
+      throw new CommandError(
+        "invalid_args",
+        `設定が通らないので比べられません: ${read.problems.map((one) => `${one.file}: ${one.msg}`).join("; ")}`,
+      );
+    }
+    const standing = applied(stateRoot);
+    return {
+      file: join(stateRoot, STATE_CONFIG_DIR, SATISFIED_FILE),
+      diff: unified(
+        standing === undefined ? "" : `${JSON.stringify(standing, null, 2)}\n`,
+        `${JSON.stringify(read.satisfied, null, 2)}\n`,
+      ),
+    };
+  }
+  const named = parsed.rest[0];
+  const ids =
+    (await evaluate(configDir)).satisfied?.supervisor.instances ??
+    applied(stateRoot)?.supervisor.instances ??
+    [];
+  const wanted =
+    named === undefined
+      ? configFiles(configDir, ids)
+      : [isAbsolute(named) ? named : join(configDir, named)];
+  const diffs = wanted.flatMap((file) => {
+    const copy = join(stateRoot, STATE_CONFIG_DIR, relative(configDir, file));
+    const before = readOr(copy);
+    const after = readOr(file);
+    if (before === after) return [];
+    return [{ file, applied: copy, diff: unified(before, after) }];
+  });
+  return { files: diffs };
+}
+
+async function configShow(args: readonly string[]): Promise<unknown> {
+  const parsed = options(args, [], ["applied"]);
+  const stateRoot = resolvePaths().stateRoot;
+  if (parsed.flags.has("applied")) {
+    const standing = applied(stateRoot);
+    if (standing === undefined) throw new CommandError("not_found", "まだ何も適用されていません");
+    return standing;
+  }
+  // A dry run: the files are read and the settings functions are called, and
+  // nothing is written. They are expected to have no side effects for exactly
+  // this reason (§8.2).
+  const read = await evaluate(resolveConfigDir());
+  if (read.satisfied === undefined) {
+    throw new CommandError(
+      "invalid_args",
+      read.problems.map((one) => `${one.file}: ${one.msg}`).join("; "),
+    );
+  }
+  return read.satisfied as Satisfied;
+}
+
+/** Put the checked copy back over what is being edited.
+ *
+ * What is overwritten is kept, under the time it was taken, and its path is
+ * printed: a person reverting has just lost an edit, and the one thing they
+ * need is where it went. */
+async function configRevert(args: readonly string[]): Promise<unknown> {
+  const parsed = options(args, [], ["all"]);
+  const named = parsed.rest[0];
+  const all = parsed.flags.has("all");
+  if (named === undefined && !all) {
+    throw new CommandError("invalid_args", "使い方: ccmsg config revert <file> | --all");
+  }
+  const configDir = resolveConfigDir();
+  const stateRoot = resolvePaths().stateRoot;
+  const ids = applied(stateRoot)?.supervisor.instances ?? [];
+  const wanted = all
+    ? configFiles(configDir, ids)
+    : [isAbsolute(named as string) ? (named as string) : join(configDir, named as string)];
+  const at = new Date().toISOString().replace(/[:.]/g, "-");
+  const done: { file: string; kept?: string }[] = [];
+  for (const file of wanted) {
+    const copy = join(stateRoot, STATE_CONFIG_DIR, relative(configDir, file));
+    if (!existsSync(copy)) {
+      if (!all) throw new CommandError("not_found", `${file} の検証済みの写しがありません`);
+      continue;
+    }
+    if (readOr(file) === readOr(copy)) continue;
+    let kept: string | undefined;
+    if (existsSync(file)) {
+      kept = join(stateRoot, REJECTED_DIR, `${relative(configDir, file)}.${at}`);
+      mkdirSync(dirname(kept), { recursive: true });
+      copyFileSync(file, kept);
+    }
+    mkdirSync(dirname(file), { recursive: true });
+    copyFileSync(copy, file);
+    done.push({ file, ...(kept === undefined ? {} : { kept }) });
+  }
+  return { reverted: done };
+}
+
+/** What was put aside by a revert, newest first. */
+function rejectedFiles(stateRoot: string): { file: string; at: string }[] {
+  const dir = join(stateRoot, REJECTED_DIR);
+  const found: { file: string; at: string }[] = [];
+  const walk = (at: string): void => {
+    let entries: string[];
+    try {
+      entries = readdirSync(at);
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const path = join(at, entry);
+      if (statSync(path).isDirectory()) walk(path);
+      else found.push({ file: path, at: statSync(path).mtime.toISOString() });
+    }
+  };
+  walk(dir);
+  return found.sort((one, two) => (one.at < two.at ? 1 : -1));
+}
+
+function readOr(file: string): string {
+  try {
+    return readFileSync(file, "utf8");
+  } catch {
+    return "";
+  }
+}
+
+function same(one: string, two: string): boolean {
+  return readOr(one) === readOr(two);
+}
+
+/** A diff a person can read, line by line.
+ *
+ * Written here rather than shelled out to: what this compares is two files
+ * this process already has, and a command that answers in JSON cannot hand its
+ * caller a pager. */
+function unified(before: string, after: string): string[] {
+  const from = before === "" ? [] : before.split("\n");
+  const to = after === "" ? [] : after.split("\n");
+  const lines: string[] = [];
+  let at = 0;
+  let here = 0;
+  while (at < from.length || here < to.length) {
+    const left = from[at];
+    const right = to[here];
+    if (left === right) {
+      at += 1;
+      here += 1;
+      continue;
+    }
+    if (right !== undefined && !from.slice(at).includes(right)) {
+      lines.push(`+ ${right}`);
+      here += 1;
+      continue;
+    }
+    if (left !== undefined && !to.slice(here).includes(left)) {
+      lines.push(`- ${left}`);
+      at += 1;
+      continue;
+    }
+    if (left !== undefined) {
+      lines.push(`- ${left}`);
+      at += 1;
+    }
+    if (right !== undefined) {
+      lines.push(`+ ${right}`);
+      here += 1;
+    }
+  }
+  return lines;
+}
+
 /** The four commands that are requests to the supervisor rather than things
  * this process does.
  *
@@ -666,14 +967,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,7 +1007,7 @@ 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 };
     }),
@@ -704,12 +1017,12 @@ async function serviceOp(
 /** The passkey commands, which are asked of the instance itself rather than of
  * the supervisor.
  *
- * They travel on the instance's unix socket and nowhere else: registration is
+ * They travel on that 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());
+/** 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 +1040,13 @@ async function passkeyAsk(unit: string | undefined, request: Record<string, unkn
   }
 }
 
+async function passkeyAsk(unit: string | undefined, request: Record<string, unknown>) {
+  return await askInstance(
+    targetFor(process.env, (await dirOf(unit)) ?? resolveConfigHome()),
+    request,
+  );
+}
+
 /** `ccmsg daemon passkey add`: one registration URL, and the code that goes
  * with it.
  *
@@ -772,7 +1092,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 +1511,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