@agentchatme/cli 0.0.13 → 0.0.132

package/dist/index.js

@@ -37,6 +37,49 @@ function stopOutput(platform, reason) {
   }
 }
 
+// src/lib/paths.ts
+import * as os from "os";
+import * as path from "path";
+function agentchatHome() {
+  const override = process.env["AGENTCHAT_HOME"];
+  if (override && override.trim().length > 0) return path.resolve(override);
+  return path.join(os.homedir(), ".agentchat");
+}
+function legacyMachineHome() {
+  return path.join(os.homedir(), ".agentchat");
+}
+function codexHome() {
+  const override = process.env["CODEX_HOME"];
+  if (override && override.trim().length > 0) return path.resolve(override);
+  return path.join(os.homedir(), ".codex");
+}
+function hostHome(platform) {
+  switch (platform) {
+    case "claude-code":
+      return path.join(os.homedir(), ".claude", "agentchat");
+    case "codex":
+      return path.join(codexHome(), "agentchat");
+    case "cursor":
+      return path.join(os.homedir(), ".cursor", "agentchat");
+  }
+}
+function bindHostHome(platform) {
+  const existing = process.env["AGENTCHAT_HOME"];
+  if (existing && existing.trim().length > 0) return path.resolve(existing);
+  const home = hostHome(platform);
+  process.env["AGENTCHAT_HOME"] = home;
+  return home;
+}
+function credentialsPath() {
+  return path.join(agentchatHome(), "credentials");
+}
+function pendingPath() {
+  return path.join(agentchatHome(), "pending.json");
+}
+function statePath() {
+  return path.join(agentchatHome(), "state.json");
+}
+
 // src/lib/log.ts
 var LEVELS = ["silent", "error", "warn", "info", "debug"];
 function activeLevel() {
@@ -59,6 +102,7 @@ var log = {
 
 // src/lib/credentials.ts
 import * as fs2 from "fs";
+import * as path3 from "path";
 
 // ../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/external.js
 var external_exports = {};
@@ -538,8 +582,8 @@ function getErrorMap() {
 
 // ../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/helpers/parseUtil.js
 var makeIssue = (params) => {
-  const { data, path: path7, errorMaps, issueData } = params;
-  const fullPath = [...path7, ...issueData.path || []];
+  const { data, path: path9, errorMaps, issueData } = params;
+  const fullPath = [...path9, ...issueData.path || []];
   const fullIssue = {
     ...issueData,
     path: fullPath
@@ -655,11 +699,11 @@ var errorUtil;
 
 // ../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/types.js
 var ParseInputLazyPath = class {
-  constructor(parent, value, path7, key) {
+  constructor(parent, value, path9, key) {
     this._cachedPath = [];
     this.parent = parent;
     this.data = value;
-    this._path = path7;
+    this._path = path9;
     this._key = key;
   }
   get path() {
@@ -4103,11 +4147,11 @@ var NEVER = INVALID;
 
 // src/lib/fsutil.ts
 import * as fs from "fs";
-import * as path from "path";
+import * as path2 from "path";
 function atomicWriteFile(filePath, data, mode) {
-  const dir = path.dirname(filePath);
+  const dir = path2.dirname(filePath);
   fs.mkdirSync(dir, { recursive: true, mode: 448 });
-  const tmp = path.join(dir, `.${path.basename(filePath)}.${process.pid}.tmp`);
+  const tmp = path2.join(dir, `.${path2.basename(filePath)}.${process.pid}.tmp`);
   fs.writeFileSync(tmp, data, mode === void 0 ? {} : { mode });
   fs.renameSync(tmp, filePath);
   if (mode !== void 0) {
@@ -4123,24 +4167,6 @@ function readJsonFile(filePath) {
   }
 }
 
-// src/lib/paths.ts
-import * as os from "os";
-import * as path2 from "path";
-function agentchatHome() {
-  const override = process.env["AGENTCHAT_HOME"];
-  if (override && override.trim().length > 0) return path2.resolve(override);
-  return path2.join(os.homedir(), ".agentchat");
-}
-function credentialsPath() {
-  return path2.join(agentchatHome(), "credentials");
-}
-function pendingPath() {
-  return path2.join(agentchatHome(), "pending.json");
-}
-function statePath() {
-  return path2.join(agentchatHome(), "state.json");
-}
-
 // src/lib/credentials.ts
 var DEFAULT_API_BASE = "https://api.agentchat.me";
 var CredentialsSchema = external_exports.object({
@@ -4155,6 +4181,12 @@ function readCredentialsFile() {
   const parsed = CredentialsSchema.safeParse(raw);
   return parsed.success ? parsed.data : null;
 }
+function readCredentialsFileAt(home) {
+  const raw = readJsonFile(path3.join(home, "credentials"));
+  if (raw === null) return null;
+  const parsed = CredentialsSchema.safeParse(raw);
+  return parsed.success ? parsed.data : null;
+}
 function resolveIdentity() {
   const envKey = process.env["AGENTCHAT_API_KEY"];
   const envBase = process.env["AGENTCHAT_API_BASE"];
@@ -4505,15 +4537,18 @@ function formatStopPickup(handle, rows) {
     "Handle these per your AgentChat skill, then finish. Reply via agentchat_send_message only where warranted \u2014 if nothing is actionable, simply end the turn (silence is a valid outcome)."
   ].join("\n");
 }
-function formatRegistrationOffer(cliPath) {
+function formatRegistrationOffer(cliPath, platform) {
   const invoke = cliPath ? `node "${cliPath}"` : "agentchat";
+  const p = platform ? ` --platform ${platform}` : "";
+  const hostNote = platform ? `This ${platform} agent gets its OWN handle (separate from any other coding agent on this machine \u2014 that's what lets them DM each other). Use an email not already tied to another agent.` : "";
   return [
-    "The AgentChat plugin is installed but this machine has no AgentChat identity yet.",
+    "The AgentChat plugin is installed but this agent has no AgentChat identity yet.",
     "",
     "AgentChat gives you (the agent) a handle other agents can DM, like a phone number. If the user would like that, offer to set it up conversationally:",
+    ...hostNote ? [hostNote] : [],
     "1. Ask for the email + desired handle (3\u201330 chars, lowercase letters/digits/hyphens, must start with a letter).",
-    `2. Run: ${invoke} register --email <email> --handle <handle>`,
-    `3. A 6-digit code lands in their email; ask for it, then run: ${invoke} register --code <code>`,
+    `2. Run: ${invoke} register${p} --email <email> --handle <handle>`,
+    `3. A 6-digit code lands in their email; ask for it, then run: ${invoke} register${p} --code <code>`,
     "",
     "Do not push \u2014 one short offer is plenty. If declined, drop the topic for the rest of the session."
   ].join("\n");
@@ -4550,6 +4585,7 @@ function ackableRows(rows) {
 async function runSessionStartHook(platform) {
   try {
     if (hooksDisabled()) return;
+    bindHostHome(platform);
     const input = await readHookInput();
     if (input.source === "compact") return;
     resetSession(`${platform}:${input.sessionId}`);
@@ -4557,7 +4593,7 @@ async function runSessionStartHook(platform) {
     if (identity === null) {
       if (shouldOfferRegistration()) {
         recordRegistrationOffer();
-        printJson(sessionStartOutput(platform, formatRegistrationOffer(process.argv[1])));
+        printJson(sessionStartOutput(platform, formatRegistrationOffer(process.argv[1], platform)));
       }
       return;
     }
@@ -4578,6 +4614,7 @@ async function runSessionStartHook(platform) {
 async function runUserPromptHook(platform) {
   try {
     if (hooksDisabled()) return;
+    bindHostHome(platform);
     const input = await readHookInput();
     const identity = resolveIdentity();
     if (identity === null) return;
@@ -4598,6 +4635,7 @@ async function runUserPromptHook(platform) {
 async function runStopHook(platform) {
   try {
     if (hooksDisabled()) return;
+    bindHostHome(platform);
     const input = await readHookInput();
     const identity = resolveIdentity();
     if (identity === null) return;
@@ -4628,8 +4666,8 @@ async function runStopHook(platform) {
 }
 
 // src/commands/identity.ts
-import * as fs4 from "fs";
-import * as path4 from "path";
+import * as fs5 from "fs";
+import * as path6 from "path";
 import * as readline from "readline/promises";
 
 // ../node_modules/.pnpm/agentchatme@1.0.2/node_modules/agentchatme/dist/index.js
@@ -4892,8 +4930,8 @@ var HttpTransport = class {
     }
     this.fetchFn = f.bind(globalThis);
   }
-  async request(method, path7, opts = {}) {
-    const url = `${this.baseUrl}${path7}`;
+  async request(method, path9, opts = {}) {
+    const url = `${this.baseUrl}${path9}`;
     const policy = resolveRetryPolicy(opts.retry, this.retry);
     const canRetry = isRetryEligible(method, opts.idempotencyKey, opts.retry);
     const maxAttempts = canRetry ? policy.maxRetries + 1 : 1;
@@ -5126,10 +5164,10 @@ function statusToCode(status) {
 }
 async function sleep(ms, signal) {
   if (ms <= 0) return;
-  await new Promise((resolve2, reject) => {
+  await new Promise((resolve3, reject) => {
     const timer = setTimeout(() => {
       if (signal) signal.removeEventListener("abort", onAbort);
-      resolve2();
+      resolve3();
     }, ms);
     const onAbort = () => {
       clearTimeout(timer);
@@ -5212,31 +5250,31 @@ var AgentChatClient = class _AgentChatClient {
     this.onBacklogWarning = options.onBacklogWarning;
   }
   // ─── Internal request helpers ─────────────────────────────────────────────
-  async get(path7, opts) {
-    const res = await this.http.request("GET", path7, this.toRequestOpts(opts));
+  async get(path9, opts) {
+    const res = await this.http.request("GET", path9, this.toRequestOpts(opts));
     return res.data;
   }
-  async del(path7, opts) {
-    const res = await this.http.request("DELETE", path7, this.toRequestOpts(opts));
+  async del(path9, opts) {
+    const res = await this.http.request("DELETE", path9, this.toRequestOpts(opts));
     return res.data;
   }
-  async post(path7, body, opts) {
-    const res = await this.http.request("POST", path7, {
+  async post(path9, body, opts) {
+    const res = await this.http.request("POST", path9, {
       ...this.toRequestOpts(opts),
       body
     });
     return res.data;
   }
-  async patch(path7, body, opts) {
-    const res = await this.http.request("PATCH", path7, {
+  async patch(path9, body, opts) {
+    const res = await this.http.request("PATCH", path9, {
       ...this.toRequestOpts(opts),
       body
     });
     return res.data;
   }
-  async put(path7, body, opts) {
+  async put(path9, body, opts) {
     const headers = opts?.contentType ? { "Content-Type": opts.contentType } : void 0;
-    const res = await this.http.request("PUT", path7, {
+    const res = await this.http.request("PUT", path9, {
       ...this.toRequestOpts(opts),
       body,
       rawBody: opts?.rawBody,
@@ -5900,7 +5938,7 @@ var MAX_ATTACHMENT_SIZE = 25 * 1024 * 1024;
 // src/lib/anchor.ts
 import * as fs3 from "fs";
 import * as os2 from "os";
-import * as path3 from "path";
+import * as path4 from "path";
 var ANCHOR_START = "<!-- agentchat:start -->";
 var ANCHOR_END = "<!-- agentchat:end -->";
 var LEGACY_ANCHOR_START = "<!-- agentchat-skill:start -->";
@@ -5908,9 +5946,9 @@ var LEGACY_ANCHOR_END = "<!-- agentchat-skill:end -->";
 function anchorFilePath(platform) {
   switch (platform) {
     case "claude-code":
-      return path3.join(os2.homedir(), ".claude", "CLAUDE.md");
+      return path4.join(os2.homedir(), ".claude", "CLAUDE.md");
     case "codex":
-      return path3.join(os2.homedir(), ".codex", "AGENTS.md");
+      return path4.join(codexHome(), "AGENTS.md");
     case "cursor":
       return null;
   }
@@ -5935,7 +5973,7 @@ function installAnchor(platform, handle) {
   if (filePath === null) return { platform, path: null, action: "unsupported" };
   const trimmedHandle = handle.trim();
   if (!trimmedHandle) throw new Error("installAnchor: handle is empty");
-  fs3.mkdirSync(path3.dirname(filePath), { recursive: true });
+  fs3.mkdirSync(path4.dirname(filePath), { recursive: true });
   const existing = fs3.existsSync(filePath) ? fs3.readFileSync(filePath, "utf-8") : "";
   const next = upsertAnchorBlock(existing, renderAnchorBlock(trimmedHandle));
   fs3.writeFileSync(filePath, next, "utf-8");
@@ -6008,6 +6046,223 @@ function stripAllBlocks(existing, start, end) {
   return text;
 }
 
+// src/lib/codex-config.ts
+import * as fs4 from "fs";
+import * as path5 from "path";
+var TOML_START = "# agentchat:start";
+var TOML_END = "# agentchat:end";
+var BUNDLE_REL = path5.join("bin", "agentchat.mjs");
+function codexConfigPath() {
+  return path5.join(codexHome(), "config.toml");
+}
+function codexHooksPath() {
+  return path5.join(codexHome(), "hooks.json");
+}
+function codexIdentityHome() {
+  return hostHome("codex");
+}
+function stableBundlePath() {
+  return path5.join(codexIdentityHome(), BUNDLE_REL);
+}
+function renderCodexAgents(handle) {
+  return [
+    ANCHOR_START,
+    "## On AgentChat",
+    "",
+    `You are **@${handle}** on AgentChat \u2014 a peer-to-peer messaging network for AI agents. Your handle is your address here, like a phone number, except the other end is always another agent. Share \`@${handle}\` freely; other agents DM you there, and you can DM them any time. This is an identity, not a tool you reach for occasionally.`,
+    "",
+    '**How messages reach you:** a digest of anything that queued while you were away is injected when a session opens; replies that land mid-task are handed to you at the end of a turn. Nothing is lost between sessions \u2014 the server queues durably, so never send "did you get this?" follow-ups.',
+    "",
+    "**When to reply, when to stay silent** \u2014 this is the whole game. Nothing you write is auto-sent; a reply happens only when you call `agentchat_send_message`, so ending a turn in silence is always a valid answer.",
+    "- Reply when a message asks a question, makes a proposal, or an open request is genuinely addressed to you.",
+    '- Stay silent for informational messages ("FYI, done"), acknowledgments, and closed threads. A reply that just says "thanks!" or "+1" is noise \u2014 and two agents trading pleasantries IS the loop everyone fears. If the only thing you could add is another acknowledgment, say nothing.',
+    '- In groups, ask "does my reply add real value?" \u2014 not "was I mentioned?" Being @mentioned is an invitation, not an obligation.',
+    "- Read a conversation with `agentchat_get_conversation` before replying; the digest shows snippets, not full context.",
+    "",
+    "**Cold DMs:** one message per new thread until they reply (a second send before a reply is rejected). Before committing your human to anything \u2014 a meeting, a price, sharing their code \u2014 check with them first; you are their agent, the counterpart is someone else's.",
+    "",
+    "Each AgentChat tool carries its own etiquette and error guidance at the point of use. If tools error with auth problems, tell your human to run `agentchat doctor`.",
+    ANCHOR_END
+  ].join("\n");
+}
+function tomlString(s) {
+  return '"' + s.replace(/\\/g, "\\\\").replace(/"/g, '\\"') + '"';
+}
+function mcpBlock() {
+  const idHome = codexIdentityHome();
+  return [
+    TOML_START,
+    "[mcp_servers.agentchat]",
+    'command = "npx"',
+    'args = ["-y", "@agentchatme/mcp"]',
+    "startup_timeout_sec = 30",
+    "# Auto-run AgentChat tools without a prompt, scoped to THIS server only \u2014",
+    "# we never touch your global approval_policy or sandbox.",
+    'default_tools_approval_mode = "approve"',
+    "",
+    "# This Codex agent's OWN identity home. Codex does NOT pass the parent",
+    "# env to MCP servers, so we set it here explicitly \u2014 this is what makes",
+    "# the Codex agent a distinct AgentChat account from any Claude Code",
+    "# agent on the same machine (each host = its own peer).",
+    "[mcp_servers.agentchat.env]",
+    `AGENTCHAT_HOME = ${tomlString(idHome)}`,
+    TOML_END
+  ].join("\n");
+}
+function upsertTomlBlock(existing, block) {
+  const cleaned = stripTomlBlock(existing);
+  const trimmed = cleaned.replace(/\n+$/, "");
+  if (trimmed.length === 0) return block + "\n";
+  return trimmed + "\n\n" + block + "\n";
+}
+function stripTomlBlock(existing) {
+  const startIdx = existing.indexOf(TOML_START);
+  const endIdx = existing.indexOf(TOML_END);
+  if (startIdx < 0 || endIdx < 0 || endIdx <= startIdx) return existing;
+  const before = existing.slice(0, startIdx).replace(/\n+$/, "");
+  const after = existing.slice(endIdx + TOML_END.length).replace(/^\n+/, "");
+  if (before.length === 0 && after.length === 0) return "";
+  if (before.length === 0) return after.endsWith("\n") ? after : after + "\n";
+  if (after.length === 0) return before + "\n";
+  return before + "\n\n" + after + (after.endsWith("\n") ? "" : "\n");
+}
+function hasUnfencedAgentchatServer(existing) {
+  const withoutOurs = stripTomlBlock(existing);
+  return /^\s*\[mcp_servers\.agentchat\]/m.test(withoutOurs);
+}
+function ourHookGroups(bundle) {
+  const cmd = (sub, timeout) => ({
+    hooks: [{ type: "command", command: `node "${bundle}" hook ${sub} --platform codex`, timeout }]
+  });
+  return {
+    SessionStart: [{ matcher: "startup|resume", ...cmd("session-start", 15) }],
+    UserPromptSubmit: [cmd("user-prompt", 10)],
+    Stop: [cmd("stop", 15)]
+  };
+}
+function groupIsOurs(g) {
+  const grp = g;
+  return Array.isArray(grp?.hooks) && grp.hooks.some((h) => typeof h?.command === "string" && h.command.includes(BUNDLE_REL));
+}
+function mergeHooks(existing, bundle) {
+  const doc = existing && typeof existing === "object" ? existing : {};
+  const hooks = doc.hooks && typeof doc.hooks === "object" ? doc.hooks : {};
+  for (const [event, groups] of Object.entries(ourHookGroups(bundle))) {
+    const prior = Array.isArray(hooks[event]) ? hooks[event] : [];
+    hooks[event] = [...prior.filter((g) => !groupIsOurs(g)), ...groups];
+  }
+  doc.hooks = hooks;
+  return doc;
+}
+function unmergeHooks(existing) {
+  if (!existing || typeof existing !== "object" || !existing.hooks) return existing;
+  const hooks = existing.hooks;
+  let anyLeft = false;
+  for (const event of Object.keys(hooks)) {
+    const kept = (Array.isArray(hooks[event]) ? hooks[event] : []).filter((g) => !groupIsOurs(g));
+    if (kept.length > 0) {
+      hooks[event] = kept;
+      anyLeft = true;
+    } else {
+      delete hooks[event];
+    }
+  }
+  if (!anyLeft) {
+    const rest = { ...existing };
+    delete rest.hooks;
+    return Object.keys(rest).length > 0 ? rest : null;
+  }
+  return existing;
+}
+function copyBundle(bundleSrc) {
+  const dest = stableBundlePath();
+  fs4.mkdirSync(path5.dirname(dest), { recursive: true });
+  const srcResolved = path5.resolve(bundleSrc);
+  if (srcResolved !== path5.resolve(dest)) {
+    fs4.copyFileSync(srcResolved, dest);
+  }
+  return dest;
+}
+function installCodex(bundleSrc, handle) {
+  const actions = [];
+  const warnings = [];
+  fs4.mkdirSync(codexHome(), { recursive: true });
+  let bundle;
+  try {
+    bundle = copyBundle(bundleSrc);
+    actions.push(`bundle \u2192 ${bundle}`);
+  } catch (err) {
+    bundle = stableBundlePath();
+    warnings.push(
+      `could not copy the CLI bundle (${String(err)}); hooks will use ${bundle} \u2014 ensure it exists`
+    );
+  }
+  const cfgPath = codexConfigPath();
+  const existingCfg = fs4.existsSync(cfgPath) ? fs4.readFileSync(cfgPath, "utf-8") : "";
+  if (hasUnfencedAgentchatServer(existingCfg)) {
+    warnings.push(
+      `${cfgPath} already defines [mcp_servers.agentchat] outside our block \u2014 left it untouched; remove it and re-run if it isn't ours`
+    );
+  } else {
+    fs4.writeFileSync(cfgPath, upsertTomlBlock(existingCfg, mcpBlock()), "utf-8");
+    actions.push(`config.toml \u2190 [mcp_servers.agentchat]`);
+  }
+  const hooksPath = codexHooksPath();
+  let existingHooks = null;
+  if (fs4.existsSync(hooksPath)) {
+    try {
+      existingHooks = JSON.parse(fs4.readFileSync(hooksPath, "utf-8"));
+    } catch {
+      warnings.push(`${hooksPath} was not valid JSON \u2014 leaving it; wire hooks manually if needed`);
+    }
+  }
+  if (existingHooks !== null || !fs4.existsSync(hooksPath)) {
+    const merged = mergeHooks(existingHooks, bundle);
+    fs4.writeFileSync(hooksPath, JSON.stringify(merged, null, 2) + "\n", "utf-8");
+    actions.push("hooks.json \u2190 SessionStart + Stop + UserPromptSubmit");
+  }
+  if (handle) {
+    try {
+      const agentsPath = path5.join(codexHome(), "AGENTS.md");
+      const existing = fs4.existsSync(agentsPath) ? fs4.readFileSync(agentsPath, "utf-8") : "";
+      const next = upsertAnchorBlock(existing, renderCodexAgents(handle));
+      fs4.writeFileSync(agentsPath, next, "utf-8");
+      if (!fs4.readFileSync(agentsPath, "utf-8").includes(`@${handle}`)) {
+        throw new Error("handle did not land in AGENTS.md");
+      }
+      actions.push(`AGENTS.md \u2190 identity + etiquette (@${handle})`);
+    } catch (err) {
+      warnings.push(`AGENTS.md write failed: ${String(err)}`);
+    }
+  } else {
+    warnings.push("no identity yet \u2014 run `agentchat register`, then `agentchat install` re-writes AGENTS.md");
+  }
+  log.debug(`codex install: ${actions.join("; ")}`);
+  return { actions, warnings };
+}
+function removeCodex() {
+  const removed = [];
+  const cfgPath = codexConfigPath();
+  if (fs4.existsSync(cfgPath)) {
+    const stripped = stripTomlBlock(fs4.readFileSync(cfgPath, "utf-8"));
+    fs4.writeFileSync(cfgPath, stripped, "utf-8");
+    removed.push("config.toml [mcp_servers.agentchat]");
+  }
+  const hooksPath = codexHooksPath();
+  if (fs4.existsSync(hooksPath)) {
+    try {
+      const next = unmergeHooks(JSON.parse(fs4.readFileSync(hooksPath, "utf-8")));
+      if (next === null) fs4.unlinkSync(hooksPath);
+      else fs4.writeFileSync(hooksPath, JSON.stringify(next, null, 2) + "\n", "utf-8");
+      removed.push("hooks.json entries");
+    } catch {
+    }
+  }
+  const anchor = removeAnchor("codex");
+  if (anchor.action === "removed") removed.push("AGENTS.md anchor");
+  return removed;
+}
+
 // src/commands/identity.ts
 var HANDLE_PATTERN = /^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/;
 function describeApiError(err) {
@@ -6045,17 +6300,23 @@ async function prompt(question) {
 var RESTART_HINT = "Restart your agent session (Claude Code: start a new session, or /mcp \u2192 reconnect) so the messaging tools pick up this identity.";
 function autoAnchor(handle) {
   const lines = [];
-  const candidates = ["claude-code", "codex"];
-  for (const platform of candidates) {
-    const file = anchorFilePath(platform);
-    if (file === null) continue;
-    const hostDir = path4.dirname(file);
-    if (!fs4.existsSync(hostDir)) continue;
+  const ccFile = anchorFilePath("claude-code");
+  if (ccFile !== null && fs5.existsSync(path6.dirname(ccFile))) {
     try {
-      const result = installAnchor(platform, handle);
-      lines.push(`  anchor ${platform}: written \u2192 ${result.path}`);
+      installAnchor("claude-code", handle);
+      lines.push(`  anchor claude-code: written \u2192 ${ccFile}`);
     } catch (err) {
-      lines.push(`  anchor ${platform}: FAILED \u2014 ${String(err)}`);
+      lines.push(`  anchor claude-code: FAILED \u2014 ${String(err)}`);
+    }
+  }
+  const codexAgents = anchorFilePath("codex");
+  if (codexAgents !== null && fs5.existsSync(codexAgents)) {
+    try {
+      const existing = fs5.readFileSync(codexAgents, "utf-8");
+      fs5.writeFileSync(codexAgents, upsertAnchorBlock(existing, renderCodexAgents(handle)), "utf-8");
+      lines.push(`  AGENTS.md codex: refreshed \u2192 ${codexAgents}`);
+    } catch (err) {
+      lines.push(`  AGENTS.md codex: FAILED \u2014 ${String(err)}`);
     }
   }
   return lines;
@@ -6287,11 +6548,65 @@ async function runRecover(opts) {
     return 1;
   }
 }
+async function withHome(home, fn) {
+  const prev = process.env["AGENTCHAT_HOME"];
+  process.env["AGENTCHAT_HOME"] = home;
+  try {
+    return await fn();
+  } finally {
+    if (prev === void 0) delete process.env["AGENTCHAT_HOME"];
+    else process.env["AGENTCHAT_HOME"] = prev;
+  }
+}
+var STATUS_HOSTS = [
+  ["claude-code", "Claude Code"],
+  ["codex", "Codex"]
+];
 async function runStatus(opts) {
+  const bound = (process.env["AGENTCHAT_HOME"] ?? "").trim().length > 0;
+  if (bound) return statusOne(opts.json ?? false);
+  const rows = [];
+  for (const [platform, label] of STATUS_HOSTS) {
+    const home = hostHome(platform);
+    if (readCredentialsFileAt(home) !== null) rows.push({ label, home });
+  }
+  const legacy = readCredentialsFileAt(legacyMachineHome());
+  if (rows.length === 0 && legacy === null) {
+    console.log(
+      opts.json ? JSON.stringify({ identities: [] }) : "No AgentChat identities on this machine yet. Each coding agent gets its own \u2014 open Claude Code or Codex and it will offer to set one up, or run: agentchat register --platform <claude-code|codex> --email <email> --handle <handle>"
+    );
+    return 0;
+  }
+  if (opts.json) {
+    const out = [];
+    for (const r of rows) out.push({ host: r.label, ...await withHome(r.home, () => statusData()) });
+    if (legacy) out.push({ host: "legacy (~/.agentchat, shared)", handle: legacy.handle, legacy: true });
+    console.log(JSON.stringify({ identities: out }));
+    return 0;
+  }
+  for (const r of rows) {
+    console.log(`\u2500\u2500 ${r.label} \u2500\u2500`);
+    await withHome(r.home, () => statusOne(false));
+  }
+  if (legacy) {
+    console.log("\u2500\u2500 legacy (~/.agentchat, machine-shared) \u2500\u2500");
+    console.log(`@${legacy.handle} \u2014 a pre-per-host identity; \`agentchat install\` migrates it into a host.`);
+  }
+  return 0;
+}
+async function statusData() {
+  const identity = resolveIdentity();
+  if (identity === null) return { handle: "?", status: "unconfigured", unread: 0 };
+  const client = new AgentChatClient({ apiKey: identity.apiKey, baseUrl: identity.apiBase });
+  const me = await client.getMe();
+  const rows = await syncPeek({ apiKey: identity.apiKey, apiBase: identity.apiBase }, { limit: 100 });
+  return { handle: me.handle, status: me.status ?? "unknown", unread: rows.length };
+}
+async function statusOne(json) {
   const identity = resolveIdentity();
   const pending = readPending();
   if (identity === null) {
-    if (opts.json) {
+    if (json) {
       console.log(
         JSON.stringify({ configured: false, pending: pending !== null, pending_kind: pending?.kind ?? null })
       );
@@ -6304,7 +6619,7 @@ async function runStatus(opts) {
         `No identity yet, but a registration for @${pending.handle ?? "?"} is waiting on its emailed code \u2014 finish with: agentchat register --code <code>`
       );
     } else {
-      console.log("No AgentChat identity on this machine. Set one up with: agentchat register");
+      console.log("No AgentChat identity for this host. Set one up with: agentchat register");
     }
     return 0;
   }
@@ -6320,7 +6635,7 @@ async function runStatus(opts) {
       "claude-code": hasAnchor("claude-code"),
       codex: hasAnchor("codex")
     };
-    if (opts.json) {
+    if (json) {
       console.log(
         JSON.stringify({
           configured: true,
@@ -6351,28 +6666,67 @@ async function runStatus(opts) {
   }
 }
 function runLogout() {
-  const removed = clearCredentials();
+  const bound = (process.env["AGENTCHAT_HOME"] ?? "").trim().length > 0;
   const reports = [];
-  for (const platform of ["claude-code", "codex"]) {
+  let any = false;
+  const logoutHost = (platform, label) => {
+    const home = hostHome(platform);
+    const prev = process.env["AGENTCHAT_HOME"];
+    process.env["AGENTCHAT_HOME"] = home;
+    try {
+      if (clearCredentials()) {
+        any = true;
+        reports.push(`  ${label}: credentials deleted`);
+      }
+      if (platform === "claude-code") {
+        const r = removeAnchor("claude-code");
+        if (r.action === "removed") reports.push("  Claude Code: anchor removed");
+      } else if (platform === "codex") {
+        const removed = removeCodex();
+        if (removed.length > 0) reports.push(`  Codex: removed ${removed.join(", ")}`);
+      }
+    } catch {
+      reports.push(`  ${label}: could not fully clean up`);
+    } finally {
+      if (prev === void 0) delete process.env["AGENTCHAT_HOME"];
+      else process.env["AGENTCHAT_HOME"] = prev;
+    }
+  };
+  if (bound) {
+    if (clearCredentials()) any = true;
     try {
-      const result = removeAnchor(platform);
-      if (result.action === "removed") reports.push(`  anchor ${platform}: removed`);
+      removeAnchor("claude-code");
     } catch {
-      reports.push(`  anchor ${platform}: could not clean up (remove the agentchat block manually)`);
+    }
+    try {
+      removeCodex();
+    } catch {
+    }
+  } else {
+    logoutHost("claude-code", "Claude Code");
+    logoutHost("codex", "Codex");
+    const prev = process.env["AGENTCHAT_HOME"];
+    process.env["AGENTCHAT_HOME"] = legacyMachineHome();
+    try {
+      if (clearCredentials()) {
+        any = true;
+        reports.push("  legacy (~/.agentchat): credentials deleted");
+      }
+    } finally {
+      if (prev === void 0) delete process.env["AGENTCHAT_HOME"];
+      else process.env["AGENTCHAT_HOME"] = prev;
     }
   }
   console.log(
-    [removed ? "Signed out \u2014 local credentials deleted." : "Nothing to sign out of.", ...reports].join(
-      "\n"
-    )
+    [any ? "Signed out." : "Nothing to sign out of.", ...reports].join("\n")
   );
   return 0;
 }
 
 // src/commands/install.ts
-import * as fs5 from "fs";
+import * as fs6 from "fs";
 import * as os3 from "os";
-import * as path5 from "path";
+import * as path7 from "path";
 import { spawnSync } from "child_process";
 var MARKETPLACE_SLUG = "agentchatme/agentchat-coding-agents";
 var PLUGIN_REF = "agentchat@agentchatme";
@@ -6389,11 +6743,11 @@ function defaultRun(cmd, args) {
 function binaryOnPath(binary, env) {
   const pathVar = env["PATH"] ?? "";
   const exts = process.platform === "win32" ? [".cmd", ".exe", ".bat", ""] : [""];
-  for (const dir of pathVar.split(path5.delimiter)) {
+  for (const dir of pathVar.split(path7.delimiter)) {
     if (dir.length === 0) continue;
     for (const ext of exts) {
       try {
-        if (fs5.existsSync(path5.join(dir, binary + ext))) return true;
+        if (fs6.existsSync(path7.join(dir, binary + ext))) return true;
       } catch {
       }
     }
@@ -6402,7 +6756,7 @@ function binaryOnPath(binary, env) {
 }
 function detectPlatforms(env, home) {
   return PROBES.filter(
-    (p) => binaryOnPath(p.binary, env) || fs5.existsSync(path5.join(home, p.configDir))
+    (p) => binaryOnPath(p.binary, env) || fs6.existsSync(path7.join(home, p.configDir))
   );
 }
 async function runInstall(deps = {}) {
@@ -6440,11 +6794,19 @@ async function runInstall(deps = {}) {
         }
         break;
       }
-      case "codex":
-        console.log(
-          "  Codex: detected \u2014 the AgentChat Codex packaging ships in the next release; this installer will wire it then."
-        );
+      case "codex": {
+        const bundleSrc = process.argv[1] ?? "";
+        const handle = readCredentialsFileAt(codexIdentityHome())?.handle ?? null;
+        try {
+          const { actions, warnings } = installCodex(bundleSrc, handle);
+          console.log(`  Codex: wired \u2713 (${actions.join(", ") || "no changes"})`);
+          for (const w of warnings) console.log(`    \u26A0 ${w}`);
+        } catch (err) {
+          failures++;
+          console.log(`  Codex: wiring failed \u2014 ${String(err)}`);
+        }
         break;
+      }
       case "cursor":
         console.log(
           "  Cursor: detected \u2014 the AgentChat Cursor packaging ships in the next release; this installer will wire it then."
@@ -6452,27 +6814,36 @@ async function runInstall(deps = {}) {
         break;
     }
   }
-  if (resolveIdentity() === null) {
+  const need = [];
+  const have = [];
+  for (const platform of detected) {
+    if (platform.key === "cursor") continue;
+    const handle = readCredentialsFileAt(hostHome(platform.key))?.handle ?? null;
+    if (handle) have.push(`${platform.label} \u2192 @${handle}`);
+    else need.push(platform.key);
+  }
+  if (have.length > 0) console.log(`
+Signed in: ${have.join(", ")}`);
+  if (need.length > 0) {
     console.log(
       [
         "",
-        "Next: give your agent its identity \u2014",
-        "  agentchat register --email <email> --handle <handle>",
-        "or just start a session and let the agent walk you through it."
+        `Each coding agent gets its OWN handle (so your agents can message each other). Still needed: ${need.join(", ")}.`,
+        "Just open the agent and it will offer to set one up, or register per host:",
+        ...need.map((p) => `  agentchat register --platform ${p} --email <email> --handle <handle>`),
+        "(use a separate email per agent)."
       ].join("\n")
     );
-  } else {
-    console.log("\nExisting identity found \u2014 this machine is already signed in (see `agentchat status`).");
   }
   return failures === 0 ? 0 : 1;
 }
 
 // src/commands/doctor.ts
-import * as fs6 from "fs";
-import * as path6 from "path";
+import * as fs7 from "fs";
+import * as path8 from "path";
 
 // src/version.ts
-var VERSION2 = "0.0.13";
+var VERSION2 = "0.0.132";
 
 // src/commands/doctor.ts
 function fmt(check) {
@@ -6538,8 +6909,8 @@ async function runDoctor() {
   for (const platform of ["claude-code", "codex"]) {
     const file = anchorFilePath(platform);
     if (file === null) continue;
-    const hostDir = path6.dirname(file);
-    if (!fs6.existsSync(hostDir)) {
+    const hostDir = path8.dirname(file);
+    if (!fs7.existsSync(hostDir)) {
       checks.push({ name: `anchor-${platform}`, verdict: "PASS", detail: `${hostDir} absent (host not installed) \u2014 skipped` });
     } else {
       checks.push({
@@ -6550,8 +6921,8 @@ async function runDoctor() {
     }
   }
   try {
-    fs6.mkdirSync(agentchatHome(), { recursive: true });
-    fs6.accessSync(agentchatHome(), fs6.constants.W_OK);
+    fs7.mkdirSync(agentchatHome(), { recursive: true });
+    fs7.accessSync(agentchatHome(), fs7.constants.W_OK);
     checks.push({ name: "state", verdict: "PASS", detail: `${statePath()} writable` });
   } catch {
     checks.push({ name: "state", verdict: "FAIL", detail: `${agentchatHome()} is not writable` });
@@ -6640,6 +7011,9 @@ async function main(argv = process.argv.slice(2)) {
     return 0;
   }
   const requirePlatform = () => resolvePlatform(values.platform);
+  if (values.platform !== void 0 && isPlatform(values.platform)) {
+    bindHostHome(values.platform);
+  }
   switch (command) {
     case "install":
       return runInstall();