@ccmsg/cli 0.3.0 → 0.3.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ccmsg/cli",
-  "version": "0.3.0",
+  "version": "0.3.2",
   "description": "The ccmsg daemon, CLI and agent plugins for one instance (= one config home)",
   "license": "MIT",
   "author": "kawaz",
@@ -20,7 +20,7 @@
     "test": "bun test"
   },
   "dependencies": {
-    "@ccmsg/protocol": "1.9.0"
+    "@ccmsg/protocol": "1.10.0"
   },
   "devDependencies": {
     "@types/bun": "^1.3.0",

package/src/instance/config.ts

@@ -286,6 +286,21 @@ function endpointOf(file: string, at: string, raw: unknown): Endpoint {
   return raw as Endpoint;
 }
 
+/** `terminal_gateway`'s shape, matched to the contract's `HelloResult` so a
+ * value this instance would refuse to report is refused here instead, at
+ * startup, rather than on the first `hello`. */
+const TERMINAL_GATEWAY = /^https?:\/\/[^/?#\s]+(\/[^?#\s]*[^/?#\s])?$/;
+
+function terminalGatewayOf(file: string, raw: string): string {
+  if (!TERMINAL_GATEWAY.test(raw)) {
+    throw new ConfigError(
+      file,
+      `upstream.terminal_gateway must be an http:// or https:// base URL with no trailing slash, got ${raw}`,
+    );
+  }
+  return raw;
+}
+
 function peersOf(file: string, raw: unknown): readonly Endpoint[] {
   if (raw === undefined) return [];
   if (!Array.isArray(raw)) throw new ConfigError(file, "peers must be an array of endpoint URLs");
@@ -334,6 +349,9 @@ function upstreamOf(file: string, raw: unknown): UpstreamConfig {
     }
     config[name] = value;
   }
+  if (config["terminal_gateway"] !== undefined) {
+    config["terminal_gateway"] = terminalGatewayOf(file, config["terminal_gateway"]);
+  }
   const launcher = fields["launcher"];
   return {
     ...(config as UpstreamConfig),

package/src/instance/instance.ts

@@ -469,6 +469,9 @@ export class Instance {
       transcript: this.#transcripts,
       gateway: this.#gateway,
       terminals: hostTerminalReader(),
+      ...(config.upstream.terminal_gateway === undefined
+        ? {}
+        : { terminalGateway: config.upstream.terminal_gateway }),
       log: (msg, fields) => {
         this.log.write(msg, fields);
       },

package/src/sessions/harness.ts

@@ -127,6 +127,7 @@ class CodexThreads implements OwnSessions {
  * so the watch is what the subscription drives, and no answer waits on it. */
 export class HarnessSessions implements OwnSessions {
   readonly #watch: DirectoryWatch;
+  readonly #lastComplete = new Map<string, AgentInfo>();
 
   constructor(
     private readonly dir: string,
@@ -174,16 +175,32 @@ export class HarnessSessions implements OwnSessions {
    * uid's own config home (M6) — a syscall or two per session, not a wait. */
   scan(): ReadonlyMap<Sid, AgentInfo> {
     const rows = new Map<Sid, AgentInfo>();
-    for (const name of this.#watch.names()) {
-      if (!STATE_FILE.test(name)) continue;
+    const names = this.#watch.names().filter((name) => STATE_FILE.test(name));
+    const present = new Set(names);
+    for (const name of names) {
       let document: unknown;
       try {
         document = JSON.parse(readFileSync(join(this.dir, name), "utf8"));
       } catch {
+        const previous = this.#lastComplete.get(name);
+        if (previous !== undefined) rows.set(previous.sid, previous);
+        continue;
+      }
+      const result = toRow(document, this.dir, this.instance);
+      if (!result.complete) {
+        const previous = this.#lastComplete.get(name);
+        if (previous !== undefined) rows.set(previous.sid, previous);
         continue;
       }
-      const row = toRow(document, this.dir, this.instance);
-      if (row !== undefined) rows.set(row.sid, row);
+      if (result.row === undefined) {
+        this.#lastComplete.delete(name);
+        continue;
+      }
+      this.#lastComplete.set(name, result.row);
+      rows.set(result.row.sid, result.row);
+    }
+    for (const name of this.#lastComplete.keys()) {
+      if (!present.has(name)) this.#lastComplete.delete(name);
     }
     return rows;
   }
@@ -248,6 +265,14 @@ export function isWaiting(row: AgentInfo): boolean {
   return row.status === WAITING;
 }
 
+/** A syntactically complete state document, and the row it states when its
+ * process is still alive. A complete document for a dead process is distinct
+ * from a document caught between truncate and write: only the latter keeps the
+ * last complete row while the writer finishes. */
+type RowResult =
+  | { readonly complete: false }
+  | { readonly complete: true; readonly row?: AgentInfo };
+
 /** The conversion of one upstream document into the contract's spelling
  * (§3.5): renamed to snake_case, instants in Unix ms, and nothing carried over
  * that the contract does not name.
@@ -255,30 +280,33 @@ export function isWaiting(row: AgentInfo): boolean {
  * A row whose process is gone is dropped: the file outlives a session that did
  * not clean up after itself, and "the session exists" is what this input is
  * for. */
-function toRow(document: unknown, configDir: string, instance: InstanceId): AgentInfo | undefined {
-  if (typeof document !== "object" || document === null) return undefined;
+function toRow(document: unknown, configDir: string, instance: InstanceId): RowResult {
+  if (typeof document !== "object" || document === null) return { complete: false };
   const raw = document as Record<string, unknown>;
   const sid = text(raw["sessionId"]);
   const pid = raw["pid"];
   const cwd = text(raw["cwd"]);
   const kind = text(raw["kind"]);
   const startedAt = raw["startedAt"];
-  if (sid === undefined || cwd === undefined || kind === undefined) return undefined;
-  if (typeof pid !== "number" || typeof startedAt !== "number") return undefined;
-  if (!alive(pid)) return undefined;
+  if (sid === undefined || cwd === undefined || kind === undefined) return { complete: false };
+  if (typeof pid !== "number" || typeof startedAt !== "number") return { complete: false };
+  if (!alive(pid)) return { complete: true };
   return {
-    sid,
-    instance,
-    pid,
-    cwd,
-    kind,
-    started_at: startedAt,
-    config_dir: configDir,
-    ...optional("name", text(raw["name"])),
-    ...optional("status", text(raw["status"])),
-    ...optional("waiting_for", text(raw["waitingFor"])),
-    ...optional("state", text(raw["state"])),
-    ...optional("background_id", text(raw["backgroundId"])),
+    complete: true,
+    row: {
+      sid,
+      instance,
+      pid,
+      cwd,
+      kind,
+      started_at: startedAt,
+      config_dir: configDir,
+      ...optional("name", text(raw["name"])),
+      ...optional("status", text(raw["status"])),
+      ...optional("waiting_for", text(raw["waitingFor"])),
+      ...optional("state", text(raw["state"])),
+      ...optional("background_id", text(raw["backgroundId"])),
+    },
   };
 }
 

package/src/sessions/registry.ts

@@ -98,6 +98,12 @@ export interface SessionsDeps {
    * domain cannot judge: a peer's, whose claim is settled by an exchange of its
    * own rather than by anything a session says (§7.2). */
   readonly mesh?: MeshSource;
+  /** Where a person opens the terminal a session runs in, which `hello` states
+   * as `terminal_gateway`. The same value that gates the `terminal` capability
+   * (`sessionCapabilities`), so a client told the capability is on is told
+   * where to reach it in the same greeting. Absent on an instance with no
+   * gateway configured. */
+  readonly terminalGateway?: string;
 }
 
 /** What `hello` needs of the mesh: verify the greeting of a peer, and say which
@@ -291,6 +297,9 @@ export class Sessions implements UpstreamResource {
       capabilities: [...this.deps.capabilities],
       version: this.deps.version,
       started_at: this.deps.startedAt,
+      ...(this.deps.terminalGateway === undefined
+        ? {}
+        : { terminal_gateway: this.deps.terminalGateway }),
       ...(expiresAt === undefined ? {} : { auth_expires_at: expiresAt }),
     };
   }