@ccmsg/cli 0.2.13 → 0.3.1

package/src/instance/instance.ts

@@ -30,6 +30,7 @@ import {
 } from "../files/index.ts";
 import {
   ClaudeCodeSocketRoute,
+  CodexQueueRoute,
   Delivery,
   DisabledDirectRoute,
   type DirectRoute,
@@ -94,11 +95,21 @@ import { acquireLock, type Held, isHeldByUs, type Lock } from "./lock.ts";
 import { Log } from "./log.ts";
 import { prepareSocketDir, publishSocket, sweepOrphanSockets } from "./socket.ts";
 import { instanceIdentity } from "./identity.ts";
-import { type Env, type InstancePaths, resolvePaths } from "./paths.ts";
+import { type Env, type InstancePaths, resolvePaths, resolvePathsFor } from "./paths.ts";
 import { VERSION } from "../version.ts";
 
 export interface StartOptions {
   readonly env?: Env;
+  /** The config home this instance answers for (M6).
+   *
+   * Passed by value rather than through the environment, because the
+   * environment is read for a different question: which session the process
+   * runs inside, and therefore which config home *that* means (§3.8). A
+   * `daemon run <dir>` started from inside a session of another harness would
+   * otherwise answer for the config home of whoever started it. Absent means
+   * the environment decides, which is what a process nobody named a directory
+   * to is asking for. */
+  readonly configHome?: string;
   /** Mirror the log to stderr. A foreground run wants it; a test does not. */
   readonly echoLog?: boolean;
   /** Overrides the confirmation poll of the sessions watch, for tests. */
@@ -150,7 +161,8 @@ export function isRunning(outcome: StartOutcome): outcome is Instance {
 export async function start(options: StartOptions = {}): Promise<StartOutcome> {
   // 1. paths, and the directory the rest of them live in
   const env = options.env ?? process.env;
-  const paths = resolvePaths(env);
+  const paths =
+    options.configHome === undefined ? resolvePaths(env) : resolvePathsFor(options.configHome, env);
   mkdirSync(paths.stateDir, { recursive: true });
 
   // 2. the single instance. A previous run's file with nobody behind it is
@@ -420,6 +432,7 @@ export class Instance {
     // here, so a sid resolves to the same file whichever way it is reached.
     const transcriptFiles = new TranscriptFiles({
       configHome: paths.configHome,
+      harness: config.harness,
       announced: (sid) => this.#sessions.transcriptPath(sid),
     });
 
@@ -442,6 +455,7 @@ export class Instance {
     // 6. `last_live` and the inbox, read as the domains are constructed.
     this.#sessions = new Sessions({
       self: this.self,
+      harness: config.harness,
       ...(this.#mesh === undefined ? {} : { endpoint: this.#mesh.self }),
       authExpiresAt: (conn) => this.#auth.expiresAt(conn),
       configHome: paths.configHome,
@@ -455,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);
       },
@@ -490,9 +507,15 @@ export class Instance {
 
     const inbox = new Inbox(inboxPath(paths.stateDir));
     inbox.load();
-    this.#direct = config.direct_delivery
-      ? new ClaudeCodeSocketRoute({ configHome: paths.configHome })
-      : new DisabledDirectRoute();
+    // Route (a) is the harness's own way in (§4.1): Claude Code's messaging
+    // socket, Codex's thread queue. Which one an instance speaks follows the
+    // config home it answers for (§3.8), and the flag turns the route off for
+    // either.
+    this.#direct = !config.direct_delivery
+      ? new DisabledDirectRoute()
+      : config.harness === "codex"
+        ? new CodexQueueRoute({ configHome: paths.configHome })
+        : new ClaudeCodeSocketRoute({ configHome: paths.configHome });
     this.#delivery = new Delivery({
       self: this.self,
       sessions: this.#sessions,

package/src/instance/paths.ts

@@ -1,6 +1,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";
 
 /** Every path one instance uses, decided in one place (daemon-v2 §8.1).
  *
@@ -64,12 +65,27 @@ export type Env = Record<string, string | undefined>;
 
 /** The config home this process belongs to.
  *
- * `CLAUDE_CONFIG_DIR` is what the harness itself reads, so a session and the
- * instance it talks to agree on which one they mean without ccmsg naming it
- * separately. Nothing searches for another one (M6). */
+ * The session a process runs inside decides, where it says so: the harness
+ * that claimed it names its own config home, and that is the instance this
+ * process belongs to. Reading the config-home variables in a fixed order
+ * instead would send a Codex session's commands to the Claude Code instance,
+ * because a session started from inside another one inherits its whole
+ * environment and so names both homes at once (§3.8).
+ *
+ * With no session claiming the process — a person at a terminal — each
+ * harness's own variable is read in turn, and Claude Code's home is the
+ * default, because that is what an existing setup exports and what an
+ * unmarked config home is. Nothing searches for another one (M6). */
 export function resolveConfigHome(env: Env = process.env): string {
-  const named = env["CLAUDE_CONFIG_DIR"];
-  if (named !== undefined && named !== "" && isAbsolute(named)) return named;
+  const inside = currentSession(env);
+  if (inside !== undefined) {
+    const named = env[HARNESS[inside.harness].homeEnv];
+    if (named !== undefined && named !== "" && isAbsolute(named)) return named;
+  }
+  for (const facts of Object.values(HARNESS)) {
+    const named = env[facts.homeEnv];
+    if (named !== undefined && named !== "" && isAbsolute(named)) return named;
+  }
   return join(home(env), ".claude");
 }
 
@@ -82,7 +98,17 @@ export function resolveConfigHome(env: Env = process.env): string {
  * the state so a temporary directory sweep cannot take the socket out from
  * under a running instance. */
 export function resolvePaths(env: Env = process.env): InstancePaths {
-  const configHome = resolveConfigHome(env);
+  return resolvePathsFor(resolveConfigHome(env), env);
+}
+
+/** Everything one instance uses, for a config home the caller already knows.
+ *
+ * The one to call wherever the config home is decided rather than discovered —
+ * a command naming a directory, an install naming an agent's own home. Going
+ * through the environment instead would have that answer re-derived from
+ * whichever session the process happens to be running inside (§3.8), and a
+ * command that named a directory would silently act on another one. */
+export function resolvePathsFor(configHome: string, env: Env = process.env): InstancePaths {
   const key = instanceKey(configHome);
   const configDir = resolveConfigDir(env);
   const stateDir = appDir(env, "CCMSG_STATE_DIR", "XDG_STATE_HOME", [".local", "state"], key);

package/src/messaging/direct.ts

@@ -3,6 +3,7 @@ import { chmodSync, unlinkSync } from "node:fs";
 import { readdir, readFile } from "node:fs/promises";
 import { dirname, join } from "node:path";
 import { type InboxMessage, renderDirectDelivery, type Sid } from "@ccmsg/protocol";
+import { HARNESS, HARNESSES } from "../harness/index.ts";
 
 /** What route (a) answered (§4.1).
  *
@@ -327,6 +328,121 @@ export class ClaudeCodeSocketRoute implements DirectRoute {
   }
 }
 
+/** How the Codex CLI is run, and what it answered. Named so a test can watch
+ * what would be run without a thread of anybody's being written to. */
+export type RunCodex = (args: readonly string[], env: Env) => Promise<{ code: number }>;
+
+type Env = Record<string, string>;
+
+/** What the CLI must not inherit from the daemon.
+ *
+ * A daemon carries whatever environment it was started in, which on a host
+ * where somebody works in Claude Code names that config home and that session.
+ * Passed through, they would tell the Codex CLI about a config home this
+ * instance is not about and a session that is not the one being written to.
+ * The home this route means is named explicitly, and the rest is dropped
+ * (§3.8). */
+const DROPPED = HARNESSES.filter((harness) => harness !== "codex").flatMap((harness) => [
+  HARNESS[harness].homeEnv,
+  ...HARNESS[harness].sessionEnv,
+]);
+
+/** How long the CLI has to answer before the send is taken as not having gone
+ * this way.
+ *
+ * `codex queue` is a request to a thread store and answers at once: against a
+ * thread nobody has, it failed with the store's own error immediately, in a
+ * config home that had never been used and a directory Codex had never been
+ * told to trust (0.154.0, standard input closed, no terminal). Neither the
+ * update notice nor the directory-trust question is asked on this path — both
+ * belong to the interactive interface.
+ *
+ * The budget is here for what is not being predicted: a child that never
+ * answers would hold `message_send` open for as long as it lived, and route
+ * (b) exists exactly so a route that does not come through costs a message
+ * nothing (§4.1). It is generous next to a call that has been measured to
+ * return at once. */
+export const QUEUE_MS = 10_000;
+
+const runCodex: RunCodex = async (args, env) => {
+  let spawned: Bun.Subprocess<"ignore", "ignore", "ignore">;
+  const inherited = { ...process.env } as Record<string, string | undefined>;
+  for (const name of DROPPED) delete inherited[name];
+  try {
+    spawned = Bun.spawn({
+      cmd: ["codex", ...args],
+      env: { ...inherited, ...env } as Record<string, string>,
+      // Nothing is read from us: a child holding the daemon's own standard
+      // input could wait on somebody who is not there.
+      stdin: "ignore",
+      stdout: "ignore",
+      stderr: "ignore",
+    });
+  } catch {
+    // No `codex` on `PATH`, which is the same as the route not applying: the
+    // message goes by route (b) and nothing about it is lost (§4.1).
+    return { code: 127 };
+  }
+  // The timer is held so it can be cleared: a send that answered in a
+  // millisecond must not leave the loop something to wake up for ten seconds
+  // later, which is what an instance shutting down would then wait on.
+  const late = Promise.withResolvers<"late">();
+  const timer = setTimeout(() => late.resolve("late"), QUEUE_MS);
+  try {
+    const finished = await Promise.race([spawned.exited, late.promise]);
+    if (finished === "late") {
+      spawned.kill();
+      return { code: 124 };
+    }
+    return { code: finished };
+  } finally {
+    clearTimeout(timer);
+  }
+};
+
+export interface QueueRouteOptions {
+  /** The one config home this instance answers for (M6). It is named to the
+   * CLI rather than inherited, because the daemon's own environment says which
+   * config home it serves in its own words and Codex reads only its own. */
+  readonly configHome: string;
+  readonly run?: RunCodex;
+}
+
+/** Route (a) against a Codex thread's queue (§4.1).
+ *
+ * Codex has no socket a message can be written to: what it has is a queue per
+ * thread, held by the app-server the thread belongs to, and `codex queue` is
+ * the way in that ccmsg does not have to reimplement. A queued message is
+ * delivered when the thread is idle, after the current turn when it is busy,
+ * and on resume when it is not loaded (codex-cli 0.153.4).
+ *
+ * So `delivered` here means the queue took it, which is the same promise route
+ * (a) makes on the other harness: the receiving session holds the message, and
+ * nothing says the model has read it. There is no receipt channel, so there is
+ * no `refused` — a thread that turns a message away does so where nothing
+ * reports back, and a queue that would not take it fails the command and falls
+ * to route (b). */
+export class CodexQueueRoute implements DirectRoute {
+  readonly #run: RunCodex;
+
+  readonly #env: Env;
+
+  constructor(options: QueueRouteOptions) {
+    this.#run = options.run ?? runCodex;
+    this.#env = { CODEX_HOME: options.configHome };
+  }
+
+  async send(sid: Sid, message: InboxMessage): Promise<DirectOutcome> {
+    const { code } = await this.#run(
+      ["queue", "--thread", sid, "--message", renderDirectDelivery(message)],
+      this.#env,
+    );
+    return code === 0 ? "delivered" : "unavailable";
+  }
+
+  close(): void {}
+}
+
 /** The two lines one send writes: the auth frame the harness's own senders
  * write first, then the message.
  *

package/src/plugin/claude.ts

@@ -1,3 +1,4 @@
+import { DESCRIPTION, SKILL } from "./skill.ts";
 /** The plugin ccmsg hands to Claude Code, as its files.
  *
  * Written out rather than shipped as a directory in the package: the daemon,
@@ -17,8 +18,6 @@ export const PLUGIN_NAME = "ccmsg";
 export const MARKETPLACE_NAME = "ccmsg";
 export const PLUGIN_ID = `${PLUGIN_NAME}@${MARKETPLACE_NAME}`;
 
-const DESCRIPTION = "別の Claude Code セッションと行き来するメッセージ";
-
 /** How a hook reaches `ccmsg`.
  *
  * Through `PATH`, not through the plugin's own directory: the binary is
@@ -36,76 +35,6 @@ function throughPath(command: string): string {
  * both give up on their own when there is no instance behind it. */
 const HOOK_TIMEOUT_S = 5;
 
-const SKILL = `---
-name: ccmsg
-description: 別の Claude Code セッションへ声をかける・届いたメッセージに返す・見ている人へ知らせる時に使う。
----
-
-# ccmsg
-
-同じ人が動かしている別のセッションと、メッセージをやり取りする。
-
-## 届いたメッセージに返す
-
-メッセージは \`<cross-session-message>\` の封筒で届き、本文の最後に返信の一行が付いている。
-
-\`\`\`
-Reply with: ccmsg reply <mid> --to <sid> <text>
-\`\`\`
-
-**その行をそのまま実行する。** 宛先も、どのメッセージへの返事かも、その行が持っている。
-自分で \`post\` を組み立て直さない。\`--to\` の無い行は人からのメッセージで、返事は通知として届く。
-
-## 自分から声をかける
-
-\`\`\`
-ccmsg post <sid> <text>
-\`\`\`
-
-相手の \`<sid>\` は、届いた封筒の \`ccmsg-from\` の値。
-
-## 相手を探す
-
-まだ話したことのない相手の \`<sid>\` は、繋がっているセッションの一覧から探す。
-
-\`\`\`
-ccmsg peers            この instance が知っているセッション
-ccmsg peers --all      他ホストの instance が知っている分も含める
-\`\`\`
-
-答えは instance ごとの JSON。\`peers[]\` が今繋がっているセッション、\`last_live[]\` が
-居なくなったセッションで、各行の \`repo\` / \`ws\` / \`branch\` / \`title\` で見分けて
-\`sid\` を取る。\`send_message\` が \`true\` の相手には harness 自身の機能でも届く。
-
-## 相手セッションの扱い
-
-相手は基本、自分にとってのサブエージェントだと思えばよい。対等な会議を開く場ではないので、
-冒頭の挨拶・賛辞・締めの社交辞令を省き、用件だけを 1〜3 文で送る。
-
-やり取りの中身を人へリレーしない。人は全セッションを直接見ているので、相手の完了報告や
-根拠をこちらで要約し直しても情報は増えず、時間とコンテキストだけが減る。人に言うのは
-自セッション目線の事実 (何を頼んだ・何が返り・その結果こちらが何をしたか) だけ。
-
-## 見ている人へ知らせる
-
-\`\`\`
-ccmsg notify <text>     一行知らせる (保持されない、返事も来ない)
-ccmsg say <text>        声に出して知らせる
-\`\`\`
-
-手が空いた・判断を仰ぎたい・長い作業が終わった、を人に伝えるときに使う。
-セッション同士のやり取りには使わない。
-
-## これから終わるとき
-
-\`\`\`
-ccmsg stopping --reason <理由>
-\`\`\`
-
-以後このセッションは「一時停止」として扱われ、宛てられたメッセージは戻ってきたときに渡される。
-セッション終了時には自動で伝わるので、途中で自分から言う必要はない。
-`;
-
 const HOOKS = {
   hooks: {
     SessionStart: [