@ccmsg/cli 0.9.1 → 0.10.1

package/src/instance/identity.ts

@@ -9,7 +9,16 @@ import type { InstanceId } from "@ccmsg/protocol";
  * spelling is sized for. */
 const ID_BYTES = 16;
 
-const ID = /^[0-9a-f]{32}$/;
+export const ID = /^[0-9a-f]{32}$/;
+
+/** A fresh id of that width, for whatever is being named.
+ *
+ * Shared with the cluster ids rather than written again there: what an id has
+ * to be is unguessable-by-accident and the same width wherever it is read, and
+ * a second generator is a second answer to how wide that is. */
+export function newId(): string {
+  return randomBytes(ID_BYTES).toString("hex");
+}
 
 /** This instance's identity, read from the state directory and generated there
  * the first time it is asked for.
@@ -26,7 +35,7 @@ const ID = /^[0-9a-f]{32}$/;
 export function instanceIdentity(file: string): InstanceId {
   const held = read(file);
   if (held !== undefined) return held;
-  const made = randomBytes(ID_BYTES).toString("hex");
+  const made = newId();
   mkdirSync(dirname(file), { recursive: true });
   writeFileSync(file, `${made}\n`);
   return made;

package/src/instance/instance.ts

@@ -176,7 +176,7 @@ export async function start(options: StartOptions = {}): Promise<StartOutcome> {
   try {
     // 3. the config. A broken one ends the start rather than turning the
     // setting it carried silently off (DV-Q9).
-    const config = loadConfig(paths.configFile, paths.configHome);
+    const config = await loadConfig(paths.configDir, paths.configHome);
     // What the config says of the gateway, resolved before anything is built
     // from it: a webhook source whose secret cannot be read ends the start
     // here, for the same reason a broken config does (DV-Q9).
@@ -675,7 +675,14 @@ export class Instance {
         // address is what says the caller is local (DR-0001 §2.2).
         handle: (frame, conn) => {
           const admin = adminRequestOf(frame);
-          if (admin !== undefined) return Promise.resolve(handleAdmin(this.#auth, admin));
+          if (admin !== undefined) {
+            return Promise.resolve(
+              handleAdmin(
+                { auth: this.#auth, ...(this.#mesh === undefined ? {} : { mesh: this.#mesh }) },
+                admin,
+              ),
+            );
+          }
           return this.handle(frame, conn);
         },
       }),

package/src/instance/paths.ts

@@ -2,6 +2,7 @@ import { createHash } from "node:crypto";
 import { homedir } from "node:os";
 import { basename, isAbsolute, join } from "node:path";
 import { currentSession, HARNESS } from "../harness/index.ts";
+import { CLUSTERS_DIR, CLUSTERS_FILE, CONFIG_FILE, INSTANCES_DIR } from "./config.ts";
 
 /** Every path one instance uses, decided in one place (daemon-v2 §8.1).
  *
@@ -14,10 +15,17 @@ export interface InstancePaths {
   readonly configHome: string;
   /** What distinguishes this instance's files from another instance's. */
   readonly key: string;
-  /** The one file a person edits, shared by every instance on this host: it
-   * carries the defaults and the list of config homes, so it is not derived
-   * from the config home the way the rest of these are. */
+  /** Where a person writes settings, shared by every instance on this host: it
+   * holds what every instance starts from and one file per instance, so it is
+   * not derived from the config home the way the rest of these are. */
+  readonly configDir: string;
+  /** The file every instance's settings start from. */
   readonly configFile: string;
+  /** Where the file naming this config home lives, one per instance. */
+  readonly instancesDir: string;
+  /** Which clusters this host knows of, and where each one's file is. */
+  readonly clustersFile: string;
+  readonly clustersDir: string;
   readonly stateDir: string;
   /** The address clients connect to. A symlink to whichever `socketReal` is
    * currently serving, so a client's path outlives the process behind it. */
@@ -116,7 +124,11 @@ export function resolvePathsFor(configHome: string, env: Env = process.env): Ins
   return {
     configHome,
     key,
-    configFile: join(configDir, "config.json"),
+    configDir,
+    configFile: join(configDir, CONFIG_FILE),
+    instancesDir: join(configDir, INSTANCES_DIR),
+    clustersFile: join(configDir, CLUSTERS_FILE),
+    clustersDir: join(configDir, CLUSTERS_DIR),
     stateDir,
     socketDir,
     socket: join(socketDir, SOCKET_NAME),
@@ -169,9 +181,10 @@ export function resolveSupervisorSocket(env: Env = process.env): string {
 
 export const SUPERVISOR_SOCKET = "supervise.sock";
 
-/** The shared config file, for a caller that has no instance to resolve. */
+/** The file every instance's settings start from, for a caller that has no
+ * instance to resolve. */
 export function resolveConfigFile(env: Env = process.env): string {
-  return join(resolveConfigDir(env), "config.json");
+  return join(resolveConfigDir(env), CONFIG_FILE);
 }
 
 /** A name for one config home that is readable and cannot collide.

package/src/mesh/mesh.ts

@@ -334,7 +334,35 @@ export class Mesh {
    * is what found which entry that is. */
   get peers(): Endpoint[] {
     const self = this.self;
-    return this.deps.peers.filter((peer) => peer !== self);
+    return this.deps.peers.filter((peer) => peer !== self && !this.#forgotten.has(peer));
+  }
+
+  /** The peers taken off this host's list while this instance was running.
+   *
+   * Config is read once (DV-Q8) and this does not change that: what a person
+   * writes goes on taking effect at the next start. What this holds is the one
+   * edit that cannot wait for one — an endpoint this host is no longer to be
+   * talking to, which would otherwise stay connected until somebody restarted
+   * the instance. */
+  readonly #forgotten = new Set<Endpoint>();
+
+  /** Stop being a peer of this endpoint: drop the link if there is one, stop
+   * dialling it, and refuse its greeting if it dials us.
+   *
+   * Answers whether anything was actually cut, so `ccmsg mesh remove` can say
+   * which instances were talking to it rather than that it asked them all. */
+  forget(peer: Endpoint): boolean {
+    this.#forgotten.add(peer);
+    const retry = this.#retries.get(peer);
+    if (retry !== undefined) {
+      clearTimeout(retry);
+      this.#retries.delete(peer);
+    }
+    const link = this.#links.get(peer);
+    if (link === undefined) return false;
+    link.conn.close();
+    this.#drop(peer, link.conn);
+    return true;
   }
 
   /** Where peers reach this instance, as the probe settled it (§7.1).
@@ -620,7 +648,7 @@ export class Mesh {
     if (claim.ver !== MESH_VER) {
       throw new OpError("invalid_args", `this instance speaks mesh handshake ${MESH_VER}`);
     }
-    if (!this.deps.peers.includes(claim.iss)) {
+    if (!this.deps.peers.includes(claim.iss) || this.#forgotten.has(claim.iss)) {
       throw new OpError("forbidden", `${claim.iss} is not a peer of this instance`);
     }
     if (claim.aud !== self) {