@ccmsg/cli 0.9.1 → 0.10.1

package/src/daemon/control.ts

@@ -2,9 +2,10 @@ import { PROTOCOL_VERSION } from "@ccmsg/protocol";
 
 /** One short exchange over an instance's unix socket.
  *
- * The CLI asks one thing at a time, so a `request_id` is a counter and the
- * answer is the next frame: nothing here needs correlation, and the connection
- * lives no longer than the command that opened it. */
+ * The CLI asks one thing at a time, so a `request_id` is a counter — and the
+ * answer is the frame carrying it, not the next one to arrive: an instance
+ * pushes topic frames of its own accord, and one landing mid-exchange would
+ * otherwise be read as the reply. */
 export interface Conn {
   ask(request: Record<string, unknown>): Promise<Record<string, unknown>>;
   /** The next frame the instance sends without having been asked for one: a
@@ -35,8 +36,12 @@ export async function connect(path: string): Promise<Conn | undefined> {
   return {
     ask(request) {
       counter += 1;
-      socket.write(`${JSON.stringify({ request_id: `${counter}`, ...request })}\n`);
-      return replies.next();
+      const id = `${counter}`;
+      // Registered before the write, so a reply that arrives in the same turn
+      // is the one this call settles on.
+      const answer = replies.answer(id);
+      socket.write(`${JSON.stringify({ request_id: id, ...request })}\n`);
+      return answer;
     },
     next() {
       return replies.next();
@@ -55,9 +60,18 @@ export function greetAsUser(conn: Conn): Promise<Record<string, unknown>> {
   return conn.ask({ op: "hello.user", protocol_version: PROTOCOL_VERSION });
 }
 
-/** Reassemble the replies of one exchange, by arrival order. */
+/** Sort what arrives on one connection into the answer somebody is waiting for
+ * and everything else.
+ *
+ * By `request_id` rather than by arrival order, because the two are not the
+ * same stream: an instance pushes topic frames of its own accord (§6), and one
+ * of those landing between a request and its reply would otherwise be read as
+ * the reply. It is not a rare window — greeting an instance that has mesh peers
+ * is enough, since a peer connecting moves a row on `instances`. */
 class Replies {
-  readonly #ready: Record<string, unknown>[] = [];
+  readonly #unasked: Record<string, unknown>[] = [];
+  readonly #answers = new Map<string, (frame: Record<string, unknown>) => void>();
+  readonly #ready = new Map<string, Record<string, unknown>>();
   #waiting: ((frame: Record<string, unknown>) => void) | undefined;
   #buffer = "";
 
@@ -69,8 +83,33 @@ class Replies {
       this.#buffer = this.#buffer.slice(at + 1);
       if (line.trim() === "") continue;
       const frame = JSON.parse(line) as Record<string, unknown>;
+      const id = frame["request_id"];
+      if (typeof id === "string") {
+        const asked = this.#answers.get(id);
+        if (asked !== undefined) {
+          this.#answers.delete(id);
+          asked(frame);
+          continue;
+        }
+        if (this.#answers.size > 0) {
+          // A reply to something still being waited for by somebody who has not
+          // got here yet: held by its id rather than queued as unasked-for.
+          this.#ready.set(id, frame);
+          continue;
+        }
+      } else if (frame["ev"] === undefined && this.#answers.size === 1) {
+        // An answer that named nothing, while exactly one thing is waiting for
+        // one: it is that one. Matching only by id would leave a caller waiting
+        // for ever on a refusal raised before the request could be read, which
+        // is the moment an answer is most needed.
+        for (const [pending, settle] of this.#answers) {
+          this.#answers.delete(pending);
+          settle(frame);
+        }
+        continue;
+      }
       const waiting = this.#waiting;
-      if (waiting === undefined) this.#ready.push(frame);
+      if (waiting === undefined) this.#unasked.push(frame);
       else {
         this.#waiting = undefined;
         waiting(frame);
@@ -78,8 +117,21 @@ class Replies {
     }
   }
 
+  /** The reply to one request, whenever it lands. */
+  answer(id: string): Promise<Record<string, unknown>> {
+    const already = this.#ready.get(id);
+    if (already !== undefined) {
+      this.#ready.delete(id);
+      return Promise.resolve(already);
+    }
+    return new Promise((resolve) => {
+      this.#answers.set(id, resolve);
+    });
+  }
+
+  /** The next frame nobody asked for. */
   next(): Promise<Record<string, unknown>> {
-    const first = this.#ready.shift();
+    const first = this.#unasked.shift();
     if (first !== undefined) return Promise.resolve(first);
     return new Promise((resolve) => {
       this.#waiting = resolve;

package/src/daemon/registry.ts

@@ -1,17 +1,23 @@
-import { existsSync, mkdirSync, watch } from "node:fs";
+import { existsSync, mkdirSync, rmSync, watch, writeFileSync } from "node:fs";
 import { basename, isAbsolute, join, resolve } from "node:path";
 import type { Endpoint, InstanceId, InstancePingResult } from "@ccmsg/protocol";
-import { DEFAULT_HARNESS, type Harness, HARNESS, isHarness } from "../harness/index.ts";
+import { DEFAULT_HARNESS, type Harness, HARNESS, HARNESSES } from "../harness/index.ts";
 import {
+  type ClusterInfo,
+  type ClusterSetting,
+  CONFIG_FILE,
+  CONFIG_NAME,
   type InstanceConfig,
-  type InstanceEntry,
+  instanceFileName,
+  loadAll,
   loadConfig,
-  loadShared,
-  saveShared,
-  settingsFor,
-  type SharedConfig,
+  loadInstances,
+  saveCluster,
+  saveClusters,
+  TYPES_FILE,
+  writeConfigTypes,
 } from "../instance/config.ts";
-import { instanceIdentity } from "../instance/identity.ts";
+import { ID, instanceIdentity, newId } from "../instance/identity.ts";
 import { alive, lockHolder } from "../instance/lock.ts";
 import { type Env, type InstancePaths, resolvePaths, resolvePathsFor } from "../instance/paths.ts";
 import { prepareSocketDir } from "../instance/socket.ts";
@@ -37,25 +43,33 @@ export function configHome(dir: string, harness: Harness = DEFAULT_HARNESS): str
   return path;
 }
 
-/** Which harness a registered config home runs, as the shared file records it.
+/** Which harness a registered config home runs, as its own file says.
  *
- * Read from the same entry the instance itself will read (§8.2), so a command
+ * Read from the same file the instance itself will read (§8.2), so a command
  * that has to know before anything is running — `run`, and the supervisor's
- * own start — reaches the same answer the instance does. A directory the file
- * does not list runs the default, which is what an unregistered `daemon run`
- * is. */
-export function harnessFor(env: Env, dir: string): Harness {
+ * own start — reaches the same answer the instance does. A directory no file
+ * names runs whatever the defaults say, which is what an unregistered
+ * `daemon run` is. */
+export async function harnessFor(env: Env, dir: string): Promise<Harness> {
   const path = isAbsolute(dir) ? dir : resolve(dir);
-  const settings = settingsFor(loadShared(resolvePaths(env).configFile), path);
-  const named = settings["harness"];
-  return isHarness(named) ? named : DEFAULT_HARNESS;
+  return (await loadConfig(resolvePaths(env).configDir, path)).harness;
 }
 
 /** One row of `daemon list`: which config home, and whether anything answers
  * for it right now. */
 export interface InstanceRow {
   readonly id: InstanceId;
+  /** The label this instance is listed under: its own file's `name`, which
+   * defaults to its id. A `daemon run` on a config home no cluster lists has
+   * none. */
+  readonly name?: string;
+  /** Which cluster this row was read through. An instance in two clusters is
+   * one instance and one process, listed once under each of them. */
+  readonly cluster_id?: string;
+  readonly cluster_name?: string;
   readonly dir: string;
+  /** Where peers reach it, as its file states or as its entry implies. */
+  readonly port?: number;
   readonly running: boolean;
   readonly pid?: number;
 }
@@ -81,18 +95,46 @@ export interface StatusRow extends InstanceRow {
 
 /** Everything one command needs to reach one config home. */
 export interface Target {
+  /** The label this instance is listed under, where a cluster lists it. */
+  readonly name?: string;
+  /** Its id, which is what its file is called. */
+  readonly id?: string;
+  /** The clusters it belongs to, as the host writes them down. */
+  readonly clusters?: readonly ClusterInfo[];
   readonly dir: string;
   readonly paths: InstancePaths;
 }
 
-export function targetFor(env: Env, dir: string): Target {
-  return { dir, paths: resolvePathsFor(dir, env) };
+export function targetFor(
+  env: Env,
+  dir: string,
+  name?: string,
+  id?: string,
+  clusters?: readonly ClusterInfo[],
+): Target {
+  return {
+    ...(name === undefined ? {} : { name }),
+    ...(id === undefined ? {} : { id }),
+    ...(clusters === undefined ? {} : { clusters }),
+    dir,
+    paths: resolvePathsFor(dir, env),
+  };
 }
 
-/** The config homes the shared file lists, in the order it lists them. */
-export function registered(env: Env): Target[] {
+/** The config homes this host's clusters list, each once. */
+export async function registered(env: Env): Promise<Target[]> {
   const paths = resolvePaths(env);
-  return loadShared(paths.configFile).instances.map((entry) => targetFor(env, entry.dir));
+  return (await loadInstances(paths.configDir)).map((entry) =>
+    targetFor(env, entry.dir, entry.name, entry.id, entry.clusters),
+  );
+}
+
+/** The instance a command was given, by any of the three things a person has
+ * to hand: the label it is listed under, its id, or the directory itself. */
+export async function targetNamed(env: Env, ref: string): Promise<Target | undefined> {
+  return (await registered(env)).find(
+    (target) => target.name === ref || target.id === ref || target.dir === ref,
+  );
 }
 
 /** The selections the shared file starts with.
@@ -138,55 +180,294 @@ const STARTING_PRESETS = [
   },
 ];
 
-/** Add a config home to the shared file. The settings it will run with are the
- * defaults until somebody edits its entry, so the entry starts empty — save
- * for the harness, which is written down when it is not the default because it
- * is the one setting the directory itself cannot be asked for (§3.8).
+/** What `daemon add` takes: the config home the instance answers for, and the
+ * two settings a person would otherwise open the file to write. */
+export interface AddOptions {
+  /** Which cluster the instance joins, by id or by name. With none said: the
+   * one cluster there is, a new one where there is none, and a refusal where
+   * there are several — the last because which management unit an instance
+   * belongs to is not something to guess at. An id nothing answers to is a
+   * cluster this host has not met yet and is made under that id, which is how
+   * a second host joins one. */
+  readonly cluster?: string;
+  readonly harness?: Harness;
+  readonly port?: number;
+}
+
+/** What a config home is called, for a person reading a listing: its own last
+ * segment, without the dot a config home is usually hidden by.
  *
- * The dump presets above go to `defaults`, and only where the file names none:
- * they are the same for every instance and are examples to edit, so writing
- * them per entry would repeat them and re-adding a config home would bring
- * back what somebody deleted. */
-export function add(env: Env, dir: string, harness: Harness = DEFAULT_HARNESS): InstanceRow {
-  const home = configHome(dir, harness);
-  const file = resolvePaths(env).configFile;
-  const shared = loadShared(file);
-  if (shared.instances.some((entry) => entry.dir === home)) {
-    throw new CommandError("file_exists", `${home} は既に登録されています`);
+ * A label and not an identity — the file and everything the instance issued
+ * are keyed by its id, so this may be changed in the file afterwards. Taken
+ * from the directory because that is the one of the two that already exists;
+ * a directory whose name could not be a label leaves the id as the name, which
+ * is what a name defaults to anyway. */
+export function nameFor(dir: string): string {
+  const name = basename(dir).replace(/^\.+/, "");
+  return CONFIG_NAME.test(name) ? name : "";
+}
+
+/** Which harness a config home runs, as the directory itself says.
+ *
+ * The marker file is the evidence: Claude Code keeps `settings.json` and Codex
+ * keeps `config.toml`, so a directory that holds one of them is that harness's
+ * (§3.8). A directory holding both, or neither, is not answered for — the
+ * first is two answers and the second is none, and guessing either way writes
+ * down a setting the instance will act on for the whole of its life. */
+export function harnessOf(dir: string): Harness {
+  const found = HARNESSES.filter((harness) => existsSync(join(dir, HARNESS[harness].marker)));
+  const only = found[0];
+  if (found.length !== 1 || only === undefined) {
+    throw new CommandError(
+      "invalid_args",
+      found.length === 0
+        ? `${dir} がどの harness の config home か分かりません (${HARNESSES.map((one) => HARNESS[one].marker).join(" / ")} がありません)。--harness で指定してください`
+        : `${dir} は ${found.join(" と ")} の両方の目印を持っています。--harness で指定してください`,
+    );
   }
-  const entry: InstanceEntry = {
-    dir: home,
-    settings: harness === DEFAULT_HARNESS ? {} : { harness },
-  };
-  const defaults =
-    shared.defaults["dump"] === undefined
-      ? { ...shared.defaults, dump: { presets: STARTING_PRESETS } }
-      : shared.defaults;
-  saveShared(file, { defaults, instances: [...shared.instances, entry] });
+  return only;
+}
+
+/** The port the next instance listens on: one past the highest any registered
+ * instance holds, or the first of the range when there are none.
+ *
+ * Counted from what is configured and then confirmed against the kernel,
+ * because the two answer different questions — the first is what this host has
+ * already handed out, and the second is whether anything else on the machine
+ * is on it. A person who wants a particular port says so and gets it or gets
+ * the refusal. */
+export const FIRST_PORT = 8643;
+
+/** How far the search walks before it says so rather than going on. A run of
+ * this many taken ports is a host whose ports are somebody else's business. */
+const PORT_SEARCH = 64;
+
+export async function freePort(taken: readonly number[]): Promise<number> {
+  const first = taken.length === 0 ? FIRST_PORT : Math.max(...taken) + 1;
+  for (let port = first; port < first + PORT_SEARCH; port += 1) {
+    if (taken.includes(port)) continue;
+    if (await bindable(port)) return port;
+  }
+  throw new CommandError(
+    "internal_error",
+    `${String(first)} から ${String(PORT_SEARCH)} 個のポートが全部塞がっています。--port で指定してください`,
+  );
+}
+
+/** Whether this host will give out an address, asked by taking it and letting
+ * it go again. Nothing else answers it: a port is free when the kernel says
+ * so, and every other account of it is out of date the moment it is read. */
+async function bindable(port: number): Promise<boolean> {
+  try {
+    const server = Bun.serve({ hostname: "127.0.0.1", port, fetch: () => new Response("") });
+    await server.stop(true);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/** Write down one more instance: one file under `instances/`, called by the
+ * name the instance is called.
+ *
+ * A template rather than an empty file, because what the file has to say —
+ * which config home, and how a setting is written at all — is exactly what a
+ * person adding their second instance does not yet know. It states only what
+ * differs from the shared file, which is what makes that file worth having:
+ * everything left out is whatever that file returns.
+ *
+ * The shared file is written the first time, with the dump presets in it, and never
+ * again: what a preset names is an interest this instance has no opinion on, so
+ * they are examples in a file to edit rather than a default in the code that
+ * would come back after being deleted. */
+export async function add(env: Env, dir: string, options: AddOptions = {}): Promise<InstanceRow> {
+  const where = isAbsolute(dir) ? dir : resolve(dir);
+  const harness = options.harness ?? harnessOf(where);
+  const home = configHome(where, harness);
+  const paths = resolvePaths(env);
+  const all = await loadAll(paths.configDir);
+  const taken = all.instances.find((one) => one.dir === home);
+  if (taken !== undefined) {
+    throw new CommandError("file_exists", `${home} は既に ${taken.name} として登録されています`);
+  }
+  const cluster = clusterFor(all.clusters, options.cluster);
+  // The id the state directory already holds, or a new one written there now:
+  // a config home that was registered before keeps the id everything it issued
+  // is keyed by, and a fresh one gets its id here rather than at its first
+  // start (DR-0001 §2.1).
   const target = targetFor(env, home);
-  // The id is made here rather than at the first start, so that what `add`
-  // prints is what the instance will answer to and so that a person can write
-  // the id into a peer's config before anything has run (DR-0001 §2.1).
-  instanceIdentity(target.paths.instanceIdFile);
-  return rowFor(target);
+  const id = instanceIdentity(target.paths.instanceIdFile);
+  // Every instance listens, because an instance is in the mesh of its cluster
+  // (§7.1) and a mesh is reached over the entry: what `--port` settles is which
+  // address, not whether there is one.
+  const port =
+    options.port ??
+    (await freePort(
+      all.instances.flatMap((one) =>
+        one.config.entry === undefined ? [] : [one.config.entry.port],
+      ),
+    ));
+  const name = nameFor(home) || id;
+  writeConfigTypes(paths.configDir);
+  if (!existsSync(paths.configFile)) writeFileSync(paths.configFile, defaultsTemplate());
+  mkdirSync(paths.instancesDir, { recursive: true });
+  writeFileSync(
+    join(paths.instancesDir, instanceFileName(id)),
+    instanceTemplate(name, home, harness, port),
+  );
+  saveCluster(paths.configDir, {
+    ...cluster,
+    instances: cluster.instances.includes(id) ? cluster.instances : [...cluster.instances, id],
+  });
+  saveClusters(
+    paths.configDir,
+    all.clusters.some((one) => one.id === cluster.id)
+      ? all.clusters.map((one) => one.id)
+      : [...all.clusters.map((one) => one.id), cluster.id],
+  );
+  return {
+    ...rowFor(targetFor(env, home, name, id)),
+    cluster_id: cluster.id,
+    cluster_name: cluster.name,
+    port,
+  };
+}
+
+/** The cluster a command is about.
+ *
+ * Named or not, the answer has to be one cluster: a command that acted on "the
+ * clusters" would be deciding for a person which management unit a thing
+ * belongs to. An id this host has not met is a cluster that exists elsewhere —
+ * a cluster spans hosts — so it is written down under that id rather than
+ * refused, which is what lets a second host join one. */
+export function clusterFor(
+  clusters: readonly ClusterSetting[],
+  named: string | undefined,
+): ClusterSetting {
+  if (named !== undefined) {
+    const found = clusters.find((one) => one.id === named || one.name === named);
+    if (found !== undefined) return found;
+    if (!ID.test(named)) {
+      throw new CommandError(
+        "not_found",
+        `${named} という cluster はありません (新しく作るなら id を渡してください)`,
+      );
+    }
+    return { id: named, name: named, peers: [], instances: [] };
+  }
+  const only = clusters[0];
+  if (clusters.length === 1 && only !== undefined) return only;
+  if (clusters.length === 0) {
+    const id = newId();
+    return { id, name: id, peers: [], instances: [] };
+  }
+  throw new CommandError(
+    "invalid_args",
+    `cluster が ${String(clusters.length)} 個あります。--cluster <id|name> で選んでください (${clusters.map((one) => one.name).join(", ")})`,
+  );
 }
 
-/** Take a config home off the list.
+/** Take one instance's file away.
  *
- * The instance it names is left alone: what this changes is what the supervisor
+ * The instance it named is left alone: what this changes is what the supervisor
  * starts and what `--all` reaches, and an instance already serving a session is
- * not something a list edit should take away from it. `daemon stop` is how one
+ * not something a file edit should take away from it. `daemon stop` is how one
  * is stopped, and saying so is the point of keeping the two apart. */
-export function remove(env: Env, dir: string): { dir: string; removed: boolean } {
-  const home = isAbsolute(dir) ? dir : resolve(dir);
-  const file = resolvePaths(env).configFile;
-  const shared: SharedConfig = loadShared(file);
-  const kept = shared.instances.filter((entry) => entry.dir !== home);
-  if (kept.length === shared.instances.length) {
-    throw new CommandError("not_found", `${home} は登録されていません`);
+export async function remove(
+  env: Env,
+  ref: string,
+): Promise<{ id: string; name: string; dir: string; removed: boolean }> {
+  const paths = resolvePaths(env);
+  const all = await loadAll(paths.configDir);
+  const found = all.instances.find((one) => one.id === ref || one.name === ref || one.dir === ref);
+  if (found === undefined) throw new CommandError("not_found", `${ref} は登録されていません`);
+  // Out of every cluster that listed it: a person removing an instance is
+  // removing it from this host, and leaving it in the second cluster would
+  // leave the supervisor starting it.
+  for (const cluster of all.clusters) {
+    if (!cluster.instances.includes(found.id)) continue;
+    saveCluster(paths.configDir, {
+      ...cluster,
+      instances: cluster.instances.filter((one) => one !== found.id),
+    });
   }
-  saveShared(file, { ...shared, instances: kept });
-  return { dir: home, removed: true };
+  rmSync(join(paths.instancesDir, instanceFileName(found.id)), { force: true });
+  // The state directory stays, its id with it: what the instance issued is
+  // keyed by that id, and re-adding the same config home has to answer to the
+  // same one.
+  return { id: found.id, name: found.name, dir: found.dir, removed: true };
+}
+
+/** The file every instance's settings start from, as it is first written. */
+function defaultsTemplate(): string {
+  return `import type { Defaults } from "./${TYPES_FILE.replace(/\.d\.ts$/, "")}";
+
+/** 全 instance に配る値。\`builtin\` は組み込みの既定値 (凍結済み)、\`config\` は
+ * そのコピーなので、書き換えて返す。ここに書いた値を各 instance が受け取る。 */
+const defaults: Defaults = ({ config }) => {
+  // mesh の相手はここには書かない。cluster 内の instance は各 TS の endpoint /
+  // port から、別 host の endpoint は cluster の peers (ccmsg mesh add) から入る。
+
+  // dump の名前付き選択。prefix は一族を、\`@name\` は他の選択をその場に広げる。
+  config.dump.presets = [
+${STARTING_PRESETS.map((preset) => presetLiteral(preset)).join("\n")}
+  ];
+
+  return config;
+};
+
+export default defaults;
+`;
+}
+
+/** One starting preset as a person would have typed it.
+ *
+ * Written out rather than stringified, because what this produces is a file
+ * somebody edits: JSON's quoted keys in the middle of a TypeScript file are
+ * the shape of a thing that was generated, and the next preset a person adds
+ * beside it would not look like it. */
+function presetLiteral(preset: (typeof STARTING_PRESETS)[number]): string {
+  const types = preset.opts.types.map((type) => JSON.stringify(type)).join(", ");
+  return [
+    "    {",
+    `      name: ${JSON.stringify(preset.name)},`,
+    `      description: ${JSON.stringify(preset.description)},`,
+    `      opts: { types: [${types}] },`,
+    "    },",
+  ].join("\n");
+}
+
+/** One instance's file, as `add` first writes it: what differs from
+ * the shared file, and nothing else. */
+function instanceTemplate(name: string, dir: string, harness: Harness, port: number): string {
+  const lines = [
+    `  config.name = ${JSON.stringify(name)};`,
+    `  config.dir = ${JSON.stringify(dir)};`,
+    "",
+    "  // reverse proxy の後ろに居るなら、peer と人が届く公開 URL (末尾 /) を書く。",
+    "  // 書かなければ下の待ち受け address がそのまま mesh の一覧に載る。",
+    `  // config.endpoint = "https://ccmsg-${name}.<host>/";`,
+    "",
+  ];
+  if (harness !== DEFAULT_HARNESS) lines.push(`  config.harness = ${JSON.stringify(harness)};`);
+  lines.push(
+    `  config.entry = {`,
+    `    ...(config.entry ?? { host: "127.0.0.1", source_ips: [], trusted_proxies: [] }),`,
+    `    port: ${String(port)},`,
+    `  };`,
+  );
+  return `import type { Instance } from "../${TYPES_FILE.replace(/\.d\.ts$/, "")}";
+
+/** ${name}: この instance だけの設定。\`default\` は ${CONFIG_FILE} が返した値
+ * (凍結済み)、\`config\` はそのコピーなので、差分だけ書き換えて返す。 */
+const instance: Instance = ({ config }) => {
+${lines.join("\n")}
+
+  return config;
+};
+
+export default instance;
+`;
 }
 
 /** What an instance is called, whether or not it is running.
@@ -204,20 +485,44 @@ export function rowFor(target: Target): InstanceRow {
   const running = pid !== undefined && alive(pid);
   return {
     id: idOf(target),
+    ...(target.name === undefined ? {} : { name: target.name }),
     dir: target.dir,
     running,
     ...(running ? { pid } : {}),
   };
 }
 
-export function list(env: Env): InstanceRow[] {
-  return registered(env).map((target) => rowFor(target));
+/** What `daemon list` answers: one row per instance per cluster it is in.
+ *
+ * By cluster because that is the unit a person manages — which mesh, which
+ * authentication records — and an instance in two of them is in both listings,
+ * as the same id with the same process. */
+export async function list(env: Env): Promise<InstanceRow[]> {
+  const all = await loadAll(resolvePaths(env).configDir);
+  const rows: InstanceRow[] = [];
+  for (const cluster of all.clusters) {
+    for (const id of cluster.instances) {
+      const found = all.instances.find((one) => one.id === id);
+      if (found === undefined) continue;
+      const target = targetFor(env, found.dir, found.name, found.id, found.clusters);
+      rows.push({
+        ...rowFor(target),
+        cluster_id: cluster.id,
+        cluster_name: cluster.name,
+        ...(found.config.entry === undefined ? {} : { port: found.config.entry.port }),
+      });
+    }
+  }
+  return rows;
 }
 
 /** Ask one instance how it is. A config home with nothing behind it answers the
  * list's row and nothing more: not running is a state, not a failure. */
 export async function status(target: Target): Promise<StatusRow> {
-  const row = { ...rowFor(target), config: loadConfig(target.paths.configFile, target.dir) };
+  const row = {
+    ...rowFor(target),
+    config: await loadConfig(target.paths.configDir, target.dir),
+  };
   const conn = await connect(target.paths.socket);
   if (conn === undefined) return row;
   try {

package/src/daemon/supervise.ts

@@ -118,7 +118,18 @@ export class Supervisor {
     this.#startTimeoutMs = options.startTimeoutMs ?? START_TIMEOUT_MS;
     this.#stopTimeoutMs = options.stopTimeoutMs ?? STOP_TIMEOUT_MS;
     this.#log = options.log ?? ((line) => process.stderr.write(`${JSON.stringify(line)}\n`));
-    for (const target of registered(this.#env)) this.#units.set(target.dir, new Supervised(target));
+  }
+
+  /** Read which config homes there are.
+   *
+   * In `run` rather than in the constructor because the files are TypeScript
+   * and reading one is an import: a caller holding a supervisor that has not
+   * run yet is holding one that has not read the list yet, which is the same
+   * moment it was already true that nothing had been started. */
+  async #adopt(): Promise<void> {
+    for (const target of await registered(this.#env)) {
+      this.#units.set(target.dir, new Supervised(target));
+    }
   }
 
   /** The config homes this supervisor is looking after right now. */
@@ -138,6 +149,7 @@ export class Supervisor {
   }
 
   async #serve(): Promise<void> {
+    await this.#adopt();
     await this.#listen();
     for (const unit of this.#units.values()) this.#keep(unit);
     // What ends the run is being asked to, not the children ending: a
@@ -307,7 +319,7 @@ export class Supervisor {
    * behind it is the state `add` exists to leave behind only when there is no
    * supervisor to tell. */
   async addOne(dir: string): Promise<StatusRow> {
-    const home = configHome(dir, harnessFor(this.#env, dir));
+    const home = configHome(dir, await harnessFor(this.#env, dir));
     if (this.#units.has(home)) {
       throw new CommandError("file_exists", `${home} は既に見ています`);
     }