clario-agent 0.2.0 → 0.4.0

package/README.md

@@ -1,18 +1,21 @@
 # clario-agent: show your AI agent's activity in Clario 🧑‍🍳
 
-A Claude Code hook that shows what your agent is working on to everyone in your current
-Clario space. Others see a pulsing badge above your avatar while the agent works, and
-clicking your avatar shows your agent card: what Claude is doing plus the project, branch
-and commit (e.g. `graphite · feat/missions · a1b2c3d`). The badge clears when Claude finishes.
+A hook for **Claude Code, Codex and Cursor** that shows what your coding agent is working on
+to everyone in your current Clario space. Others see a pulsing badge above your avatar while
+the agent works, and clicking your avatar shows your agent card: which agent, what it's doing,
+and the project, branch and commit (e.g. `graphite · feat/missions · a1b2c3d`). The badge
+clears when the agent finishes.
 
 ## Setup (one command)
 
 1. Open your space on [clario.games](https://www.clario.games) and click **Agent** in the
-   left menu. It shows your setup command, with a key made for you:
+   left menu. It shows your setup command, with your key in it:
    ```bash
-   npx clario-agent setup --key YOUR_KEY
+   npx clario-agent@latest setup --key YOUR_KEY
    ```
-2. Copy it and run it in the terminal, inside the project you want to share.
+2. Copy it and run it in the terminal, inside the project you want to share. It sets up
+   every agent it finds on your computer (Claude Code, Codex, Cursor). To pick them
+   yourself, add `--agent codex`, `--agent claude,cursor` or `--agent all`.
 
 That's it: the Agent button disappears once your agent has connected. Setup:
 
@@ -21,19 +24,30 @@ That's it: the Agent button disappears once your agent has connected. Setup:
   same command for you. It can only post agent activity: it can't sign in, open a space or
   change anything else. No password is ever typed in the terminal.
 - **Installs the hook** at `~/.clario/hook.mjs`.
-- **Registers it with Claude Code** for this project only, in `.claude/settings.local.json`.
-  Add `--global` to use it in every project (`~/.claude/settings.json`) instead.
+- **Registers it with your agent:**
 
-Then give Claude a task in that project and click your avatar. Teammates who do the same and
-join your space show up on their avatars too.
+  | Agent | Hook file | Shared from |
+  |---|---|---|
+  | Claude Code | `.claude/settings.local.json` in this project (`~/.claude/settings.json` with `--global`) | this project |
+  | Codex | `~/.codex/hooks.json` (or `$CODEX_HOME/hooks.json`) | the projects you ran setup in |
+  | Cursor | `~/.cursor/hooks.json` | the projects you ran setup in |
 
-To add another project later, run `npx clario-agent setup` there: it reuses your saved key.
-Setup never registers the hook twice, leaves your other Claude Code settings and hooks as
-they are, and saves the previous file next to it as `*.clario-backup`.
+  Codex and Cursor read one hook file for every project, so the hook itself only reports
+  from the projects you ran setup in; add `--global` to share from all of them.
+- **Codex** asks before it runs a new hook: open Codex, run `/hooks` and trust the Clario
+  hook. **Cursor**: restart it if it was open.
+
+Then give your agent a task in that project and click your avatar. Teammates who do the same
+and join your space show up on their avatars too.
+
+To add another project or a newly installed agent later, run `npx clario-agent@latest setup` there: it reuses your
+saved key. Setup never registers the hook twice, leaves your other settings and hooks as they
+are, and saves the previous file next to it as `*.clario-backup`.
 
 ```bash
-npx clario-agent status      # server, key expiry, where the hook is registered
-npx clario-agent uninstall   # remove the hook from this project (add --global for all)
+npx clario-agent status              # server, key, which agents are set up and where
+npx clario-agent uninstall           # stop sharing from this project, for every agent
+npx clario-agent uninstall --global  # remove every Clario hook and stop sharing everywhere
 ```
 
 It uses the live server at `https://api.clario.games`. Running Clario yourself? The Agent
@@ -48,12 +62,12 @@ from `~/.viora` and replaces the old hook. You can delete `~/.viora` afterwards.
 
 ## How it behaves
 
-- While Claude runs tools (edits, bash commands…) your badge shows "cooking" with a short
-  description of the current tool (e.g. `Claude is using Edit page.tsx` or
-  `Claude is using Bash $ bun, git`)
+- While your agent works your badge shows "cooking" with a short description of what it's
+  doing, e.g. `Claude is using Edit page.tsx`, `Codex is using Shell $ bun, git` or
+  `Cursor is editing page.tsx`, and the card says which agent it is
 - Your agent card also shows the project folder, git branch and short commit the agent is
   working in
-- When Claude finishes, the badge clears automatically
+- When the agent finishes, the badge clears automatically
 - If you're not inside a Clario space, updates are silently dropped
 - Updates are throttled (2s) so fast tool bursts don't spam the room
 - The hook never blocks or fails your agent session: all errors are swallowed

package/clario-agent-hook.mjs

@@ -1,28 +1,44 @@
 #!/usr/bin/env node
 /**
- * Clario agent hook for Claude Code
+ * Clario agent hook for Claude Code, Codex and Cursor
  *
  * Broadcasts what your AI agent is doing to everyone in your current Clario space.
  * Setup guide: tools/agent-hook/README.md
  *
- * Reads Claude Code hook events from stdin and POSTs activity to
+ *   node hook.mjs [--agent claude-code|codex|cursor-agent]   (hook JSON on stdin)
+ *
+ * Reads the agent's hook events from stdin and POSTs activity to
  * POST /api/v1/agent-activity on your Clario server. Exits 0 silently on any
- * failure so it never blocks your agent session.
+ * failure so it never blocks your agent session. Without --agent it's Claude Code.
  *
  * Sent: a short status line (tool name, edited file name, or the programs a shell
- * command runs, never its arguments) plus the project folder, git branch and short
- * commit. `"shareGit": false` in ~/.clario/agent.json (or CLARIO_SHARE_GIT=0) keeps
- * project, branch and commit on this machine.
+ * command runs, never its arguments), which agent it is, and the project folder,
+ * git branch and short commit. `"shareGit": false` in ~/.clario/agent.json (or
+ * CLARIO_SHARE_GIT=0) keeps project, branch and commit on this machine.
+ *
+ * Codex and Cursor read their hooks from one file for every project, so for them this
+ * only reports from the projects setup was run in (`projects` in the config), unless
+ * setup was run with --global (`everyProject`). Cursor reads each hook's stdout as its
+ * reply, so it always gets the neutral one: carry on, change nothing.
  */
 
-import { existsSync, readFileSync, statSync } from "node:fs";
+import { existsSync, readFileSync, realpathSync, statSync } from "node:fs";
 import { homedir } from "node:os";
-import { basename, dirname, join, resolve } from "node:path";
+import { basename, dirname, join, resolve, sep } from "node:path";
 
 const CONFIG_PATH = join(homedir(), ".clario", "agent.json");
 const THROTTLE_MS = 2000;
 const STATE_PATH = join(homedir(), ".clario", ".agent-hook-state");
 
+/** Agents this hook understands, by the --agent value setup registers, with the name shown in Clario. */
+const AGENTS = { "claude-code": "Claude", codex: "Codex", "cursor-agent": "Cursor" };
+
+function agentFromArgs(argv) {
+  const i = argv.indexOf("--agent");
+  const value = i > -1 ? argv[i + 1] : argv.find((a) => a.startsWith("--agent="))?.slice("--agent=".length);
+  return value in AGENTS ? value : "claude-code";
+}
+
 function readStdin() {
   return new Promise((resolve) => {
     let raw = "";
@@ -36,7 +52,7 @@ function readStdin() {
 function loadConfig() {
   try {
     const config = JSON.parse(readFileSync(CONFIG_PATH, "utf8"));
-    // agentKey (setup.mjs, lasts 180 days) wins over a pasted 7-day login token.
+    // agentKey (from setup) wins over a pasted 7-day login token.
     const credential = config?.agentKey || config?.token;
     if (credential && config?.apiUrl) return { ...config, credential };
   } catch {
@@ -52,6 +68,28 @@ function lastSentAt() {
   }
 }
 
+/** Working directory of a hook event. Claude Code and Codex send `cwd`; Cursor sends `workspace_roots`. */
+function eventCwd(event) {
+  const roots = Array.isArray(event.workspace_roots) ? event.workspace_roots.filter((r) => typeof r === "string" && r) : [];
+  return (typeof event.cwd === "string" && event.cwd) || roots[0] || process.env.CURSOR_PROJECT_DIR || process.cwd();
+}
+
+function realPath(path) {
+  try {
+    return realpathSync(path);
+  } catch {
+    return resolve(path);
+  }
+}
+
+/** Codex and Cursor: only from the projects setup was run in, or every project after setup --global. */
+function sharedHere(config, agent, cwd) {
+  if (agent === "claude-code" || config.everyProject === true) return true; // Claude Code's hook is per project already
+  const here = realPath(cwd);
+  const projects = Array.isArray(config.projects) ? config.projects : [];
+  return projects.some((p) => typeof p === "string" && (here === p || here.startsWith(p.endsWith(sep) ? p : p + sep)));
+}
+
 // Git: project, branch and commit, read from .git directly (no git CLI).
 
 /** Walk up from `start` to the first directory containing `.git` (a dir, or a file for worktrees). */
@@ -118,10 +156,9 @@ function readRef(gitDir, name) {
 }
 
 /** Project folder, branch and short commit for the agent card; nothing when sharing is off. */
-function gitInfo(event, config) {
+function gitInfo(cwd, config) {
   const env = process.env.CLARIO_SHARE_GIT;
   if (env !== undefined ? env === "0" : config.shareGit === false) return {};
-  const cwd = typeof event.cwd === "string" && event.cwd ? event.cwd : process.cwd();
   const root = findGitRoot(cwd);
   if (!root) return { project: basename(resolve(cwd)) };
   const { branch, commit } = readHead(root);
@@ -152,42 +189,89 @@ function programNames(command) {
   return names.slice(0, 3);
 }
 
-function describe(event) {
-  const tool = typeof event.tool_name === "string" ? event.tool_name : "";
-  if (event.hook_event_name === "Stop") return { state: "done", text: "" };
-  if (event.hook_event_name === "SessionEnd") return { state: "done", text: "" };
+/** A shell tool's command line. Codex often sends it as ["bash", "-lc", "the command"]. */
+function commandText(input) {
+  const command = input?.command ?? input?.cmd;
+  if (typeof command === "string") return command;
+  if (!Array.isArray(command) || !command.every((part) => typeof part === "string")) return "";
+  const flag = command.findIndex((part) => part === "-c" || part === "-lc");
+  return flag > -1 && command[flag + 1] ? command[flag + 1] : command.join(" ");
+}
 
-  const toolLabel = tool.replace(/^(mcp__|LambdaResponse)/, "").slice(0, 40);
-  let detail = "";
-  if (tool === "Edit" || tool === "Write" || tool === "MultiEdit") {
-    const filePath = event?.tool_input?.file_path;
-    if (typeof filePath === "string") {
-      const parts = filePath.split("/");
-      detail = ` ${parts[parts.length - 1]}`;
-    }
+/** The first file a Codex apply_patch names ("*** Update File: path"), wherever the patch sits in the input. */
+function patchFile(value, depth = 0) {
+  if (depth > 3 || value == null) return undefined;
+  if (typeof value === "string") return /^\*\*\* (?:Update|Add|Delete) File:\s*(.+?)\s*$/m.exec(value)?.[1];
+  const values = Array.isArray(value) ? value : typeof value === "object" ? Object.values(value) : [];
+  for (const v of values) {
+    const found = patchFile(v, depth + 1);
+    if (found) return found;
   }
-  if (tool === "Bash" && typeof event?.tool_input?.command === "string") {
-    const names = programNames(event.tool_input.command);
+  return undefined;
+}
+
+const fileName = (path) => (typeof path === "string" && path.trim() ? basename(path.trim()) : "");
+
+const DONE_EVENTS = new Set(["Stop", "SessionEnd", "stop", "sessionEnd"]);
+const PROMPT_EVENTS = new Set(["UserPromptSubmit", "beforeSubmitPrompt"]);
+const EDIT_TOOLS = new Set(["edit", "write", "multiedit", "notebookedit"]);
+const PATCH_TOOLS = new Set(["apply_patch", "applypatch"]);
+const SHELL_TOOLS = new Set(["bash", "shell", "local_shell", "exec_command"]);
+
+/** What the agent is doing, as the one line others see; no text means there's nothing to send. */
+function describe(event, agent) {
+  const name = AGENTS[agent];
+  const hookEvent = event.hook_event_name;
+  if (DONE_EVENTS.has(hookEvent)) return { state: "done", text: "" };
+  if (PROMPT_EVENTS.has(hookEvent)) return { state: "cooking", text: `${name} is thinking` };
+  // Cursor: one event per file its agent changes, with the file at the top level.
+  if (hookEvent === "afterFileEdit") {
+    const file = fileName(event.file_path);
+    return { state: "cooking", text: file ? `${name} is editing ${file}` : `${name} is editing` };
+  }
+  if (hookEvent !== "PreToolUse" && hookEvent !== "PostToolUse") return { state: "cooking", text: "" };
+
+  const tool = typeof event.tool_name === "string" ? event.tool_name : "";
+  const key = tool.toLowerCase();
+  let label = tool.replace(/^(mcp__|LambdaResponse)/, "").slice(0, 40) || "a tool";
+  let detail = "";
+  if (EDIT_TOOLS.has(key)) {
+    const file = fileName(event?.tool_input?.file_path ?? event?.tool_input?.notebook_path);
+    if (file) detail = ` ${file}`;
+  } else if (PATCH_TOOLS.has(key)) {
+    label = "Edit";
+    const file = fileName(patchFile(event?.tool_input));
+    if (file) detail = ` ${file}`;
+  } else if (SHELL_TOOLS.has(key)) {
+    if (key !== "bash") label = "Shell";
+    const names = programNames(commandText(event?.tool_input));
     if (names.length) detail = ` $ ${names.join(", ")}`;
   }
-  return { state: "cooking", text: `Claude is using ${toolLabel || "a tool"}${detail}` };
+  return { state: "cooking", text: `${name} is using ${label}${detail}` };
 }
 
 async function main() {
-  const config = loadConfig();
-  if (!config) process.exit(0);
-
+  const agent = agentFromArgs(process.argv.slice(2));
   const raw = await readStdin();
-  if (!raw.trim()) process.exit(0);
-
-  let event;
+  let event = {};
   try {
-    event = JSON.parse(raw);
+    const parsed = JSON.parse(raw);
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) event = parsed;
   } catch {
-    process.exit(0);
   }
 
-  const { state, text } = describe(event);
+  // Cursor waits for a reply on stdout before it goes on: give it first, whatever happens next.
+  if (agent === "cursor-agent") {
+    await new Promise((done) => process.stdout.write(event.hook_event_name === "beforeSubmitPrompt" ? '{"continue":true}' : "{}", done));
+  }
+
+  const config = loadConfig();
+  if (!config || !raw.trim()) process.exit(0);
+
+  const cwd = eventCwd(event);
+  if (!sharedHere(config, agent, cwd)) process.exit(0);
+
+  const { state, text } = describe(event, agent);
   if (state === "cooking" && !text) process.exit(0);
 
   // Client-side throttle: hook events fire per tool use and can be chatty.
@@ -204,7 +288,7 @@ async function main() {
         "Content-Type": "application/json",
         Authorization: `Bearer ${config.credential}`,
       },
-      body: JSON.stringify(state === "cooking" ? { text, state, ...gitInfo(event, config) } : { text, state }),
+      body: JSON.stringify(state === "cooking" ? { text, state, agent, ...gitInfo(cwd, config) } : { text, state, agent }),
       signal: controller.signal,
     });
     if (state === "cooking") {

package/cli.mjs

@@ -1,16 +1,22 @@
 #!/usr/bin/env node
 /**
- * clario-agent: show what your Claude Code agent is doing on your Clario avatar.
+ * clario-agent: show what your coding agent (Claude Code, Codex or Cursor) is doing on
+ * your Clario avatar.
  *
- *   npx clario-agent setup --key KEY [--api-url URL] [--global]   key + hook, once
- *   npx clario-agent status                                        what is set up
- *   npx clario-agent uninstall [--global]                          remove the hook
+ *   npx clario-agent setup --key KEY [--agent claude|codex|cursor|all] [--api-url URL] [--global]
+ *                                                 every agent on this computer unless --agent picks
+ *   npx clario-agent status                       what is set up
+ *   npx clario-agent uninstall [--global]         stop sharing from this project (or everywhere)
  *
  * The key comes from the website: the Agent button in a Clario space shows the whole
  * setup command. setup checks the key with the server, saves it in ~/.clario/agent.json
- * (one key per user that stays the same; it can only post agent activity), copies the hook to
- * ~/.clario/hook.mjs and registers it in this project's .claude/settings.local.json,
- * or in ~/.claude/settings.json with --global.
+ * (one key per user that stays the same; it can only post agent activity), copies the hook
+ * to ~/.clario/hook.mjs and registers it with each agent:
+ *   Claude Code  this project's .claude/settings.local.json, or ~/.claude/settings.json with --global
+ *   Codex        ~/.codex/hooks.json (or $CODEX_HOME/hooks.json)
+ *   Cursor       ~/.cursor/hooks.json
+ * Codex and Cursor use one file for every project, so the hook only reports from the
+ * projects setup was run in (`projects` in the config), or from all with --global.
  */
 
 import { execFileSync } from "node:child_process";
@@ -27,7 +33,6 @@ const HOOK_SOURCE = join(dirname(fileURLToPath(import.meta.url)), "clario-agent-
 const OLD_CONFIG_PATH = join(homedir(), ".viora", "agent.json");
 // The live Clario server; pass --api-url http://localhost:3001 for a local one.
 const DEFAULT_API_URL = "https://api.clario.games";
-const HOOK_EVENTS = ["PreToolUse", "PostToolUse", "Stop", "SessionEnd"];
 const WARN_DAYS = 14; // setup reminds you to get a new key when the saved one has less time left than this
 const GET_A_KEY = "Open your Clario space at https://www.clario.games, click Agent in the left menu, and run the setup command it shows.";
 
@@ -36,6 +41,39 @@ const fail = (message) => {
   throw new CliError(message);
 };
 
+/** A path for a hook command line, quoted for the shell. */
+const quote = (path) => `"${path.replace(/(["\\$`])/g, "\\$1")}"`;
+
+/** Where each agent reads its hooks, the events the hook listens to, and the file's layout. */
+const AGENT_TARGETS = {
+  claude: {
+    name: "Claude Code",
+    // Each agent makes its home folder the first time it runs: that's how setup finds it.
+    installed: () => existsSync(join(homedir(), ".claude")),
+    file: (global) => (global ? join(homedir(), ".claude", "settings.json") : join(process.cwd(), ".claude", "settings.local.json")),
+    events: ["PreToolUse", "PostToolUse", "Stop", "SessionEnd"],
+    command: () => `node ${quote(HOOK_PATH)}`,
+  },
+  codex: {
+    name: "Codex",
+    shared: true, // one file for every project
+    installed: () => existsSync(process.env.CODEX_HOME || join(homedir(), ".codex")),
+    file: () => join(process.env.CODEX_HOME || join(homedir(), ".codex"), "hooks.json"),
+    events: ["UserPromptSubmit", "PostToolUse", "Stop", "SessionEnd"],
+    // The full path to node: Codex and Cursor can start hooks without your shell's PATH.
+    command: () => `${quote(process.execPath)} ${quote(HOOK_PATH)} --agent codex`,
+  },
+  cursor: {
+    name: "Cursor",
+    shared: true,
+    flat: true, // { version: 1, hooks: { event: [{ command }] } }
+    installed: () => existsSync(join(homedir(), ".cursor")),
+    file: () => join(homedir(), ".cursor", "hooks.json"),
+    events: ["beforeSubmitPrompt", "afterFileEdit", "stop"],
+    command: () => `${quote(process.execPath)} ${quote(HOOK_PATH)} --agent cursor-agent`,
+  },
+};
+
 /** { value } for a JSON file, {} when it doesn't exist; fails on invalid JSON instead of overwriting it. */
 function readJson(file) {
   let text;
@@ -114,10 +152,7 @@ function savedKey(config, apiUrl) {
   fail(`No agent key yet. ${GET_A_KEY}`);
 }
 
-// ---- Claude Code settings -------------------------------------------------------
-
-const settingsFile = (global) =>
-  global ? join(homedir(), ".claude", "settings.json") : join(process.cwd(), ".claude", "settings.local.json");
+// ---- Hook files ---------------------------------------------------------------------
 
 /** Our hooks from any version (also from before the rename): this package's copy, or the repo script. */
 const isOurHook = (hook) =>
@@ -133,6 +168,7 @@ function withoutOurHooks(settings) {
       continue;
     }
     const kept = groups
+      .filter((group) => !isOurHook(group)) // Cursor lists commands directly
       .map((group) => (Array.isArray(group?.hooks) ? { ...group, hooks: group.hooks.filter((h) => !isOurHook(h)) } : group))
       .filter((group) => !Array.isArray(group?.hooks) || group.hooks.length > 0);
     if (kept.length) hooks[event] = kept;
@@ -142,17 +178,41 @@ function withoutOurHooks(settings) {
 }
 
 const countOurHooks = (settings) =>
-  Object.values(settings?.hooks ?? {}).flat().flatMap((group) => group?.hooks ?? []).filter(isOurHook).length;
+  Object.values(settings?.hooks ?? {})
+    .flat()
+    .flatMap((group) => (Array.isArray(group?.hooks) ? group.hooks : [group]))
+    .filter(isOurHook).length;
 
 /** Add the hook for every event, replacing older entries of ours so it never fires twice. */
-function registerHooks(file) {
+function registerHooks(target, global) {
+  const file = target.file(global);
   const { value = {} } = readJson(file);
   if (existsSync(file)) copyFileSync(file, `${file}.clario-backup`);
   const settings = withoutOurHooks(value);
   const hooks = { ...(settings.hooks ?? {}) };
-  const command = `node "${HOOK_PATH}"`;
-  for (const event of HOOK_EVENTS) hooks[event] = [...(hooks[event] ?? []), { hooks: [{ type: "command", command, timeout: 10 }] }];
-  writeJson(file, { ...settings, hooks });
+  const command = target.command();
+  const entry = target.flat ? { command, timeout: 10 } : { hooks: [{ type: "command", command, timeout: 10 }] };
+  for (const event of target.events) hooks[event] = [...(hooks[event] ?? []), entry];
+  writeJson(file, { ...(target.flat ? { version: 1 } : {}), ...settings, hooks });
+  return file;
+}
+
+/** Remove our hook from a file; true when there was one. */
+function unregisterHooks(file) {
+  const { value } = readJson(file);
+  if (!value || !countOurHooks(value)) return false;
+  copyFileSync(file, `${file}.clario-backup`);
+  writeJson(file, withoutOurHooks(value));
+  return true;
+}
+
+/** The project setup runs in: the git root around the current folder, or the folder itself. */
+function projectRoot() {
+  const here = realpathSync(process.cwd());
+  for (let dir = here; ; dir = dirname(dir)) {
+    if (existsSync(join(dir, ".git"))) return dir;
+    if (dirname(dir) === dir) return here;
+  }
 }
 
 function gitIgnored(file) {
@@ -164,6 +224,25 @@ function gitIgnored(file) {
   }
 }
 
+/**
+ * --agent claude|codex|cursor|all, repeatable or comma separated. Left out: every agent on
+ * this computer (Claude Code when none is found), so one command sets up all of them.
+ */
+function parseAgents(args) {
+  const values = args
+    .flatMap((arg, i) => (arg === "--agent" ? [args[i + 1] ?? ""] : arg.startsWith("--agent=") ? [arg.slice("--agent=".length)] : []))
+    .flatMap((value) => value.split(","))
+    .map((value) => value.trim().toLowerCase())
+    .filter(Boolean);
+  const aliases = { "claude-code": "claude", "cursor-agent": "cursor" };
+  const names = values.includes("all") ? Object.keys(AGENT_TARGETS) : values.map((value) => aliases[value] ?? value);
+  const unknown = names.find((name) => !(name in AGENT_TARGETS));
+  if (unknown !== undefined) fail(`Unknown agent "${unknown}". Use claude, codex, cursor or all.`);
+  if (names.length) return [...new Set(names)];
+  const found = Object.keys(AGENT_TARGETS).filter((name) => AGENT_TARGETS[name].installed());
+  return found.length ? found : ["claude"];
+}
+
 // ---- Commands -----------------------------------------------------------------------
 
 async function setup(opts) {
@@ -172,22 +251,36 @@ async function setup(opts) {
   const apiUrl = String(opts.apiUrl || (opts.key ? DEFAULT_API_URL : config.apiUrl) || DEFAULT_API_URL).replace(/\/+$/, "");
   const { key, days, reused } = opts.key ? await checkKey(opts.key, apiUrl) : savedKey(config, apiUrl);
 
-  // An old 7-day login token isn't needed any more; everything else (shareGit…) stays.
+  // An old 7-day login token isn't needed any more; everything else (shareGit, projects…) stays.
   const { token: _loginToken, ...rest } = config;
-  writeJson(CONFIG_PATH, { ...rest, apiUrl, agentKey: key }, { mode: 0o600 });
+  const next = { ...rest, apiUrl, agentKey: key };
+  const root = projectRoot();
+  if (opts.agents.some((agent) => AGENT_TARGETS[agent].shared)) {
+    if (opts.global) next.everyProject = true;
+    else next.projects = [...new Set([...(Array.isArray(rest.projects) ? rest.projects : []), root])];
+  }
+  writeJson(CONFIG_PATH, next, { mode: 0o600 });
   mkdirSync(DIR, { recursive: true, mode: 0o700 });
   copyFileSync(HOOK_SOURCE, HOOK_PATH);
 
-  const file = settingsFile(opts.global);
-  registerHooks(file);
-
   console.log(`${reused ? "Kept your agent key" : "Saved your agent key"} in ${CONFIG_PATH} (${expiryText(days)}).`);
   if (reused && days < WARN_DAYS) console.log(`It runs out in ${Math.ceil(days)} days. ${GET_A_KEY}`);
-  console.log(`Hook registered in ${file}${opts.global ? " for every project" : " for this project only"}.`);
-  if (!opts.global && gitIgnored(file) === false) {
-    console.log("Note: .claude/settings.local.json isn't git-ignored here. It holds no secrets, but you may want to ignore it.");
+  for (const agent of opts.agents) {
+    const target = AGENT_TARGETS[agent];
+    const file = registerHooks(target, opts.global);
+    const scope = opts.global ? "every project" : target.shared ? `${root} (and any other project you ran setup in)` : "this project only";
+    console.log(`${target.name}: hook registered in ${file}, sharing from ${scope}.`);
+    if (agent === "claude" && !opts.global && gitIgnored(file) === false) {
+      console.log("  Note: .claude/settings.local.json isn't git-ignored here. It holds no secrets, but you may want to ignore it.");
+    }
+    if (agent === "codex") console.log("  Codex asks before it runs a new hook: open Codex, run /hooks and trust the Clario hook.");
+    if (agent === "cursor") console.log("  If Cursor is open, restart it so it loads the hook.");
+  }
+  const missing = Object.keys(AGENT_TARGETS).filter((agent) => !opts.agents.includes(agent));
+  if (!opts.picked && missing.length) {
+    console.log(`Not found on this computer: ${missing.map((agent) => AGENT_TARGETS[agent].name).join(", ")}. Run setup again after installing one.`);
   }
-  console.log("Open your Clario space and give Claude a task: your avatar's card shows what it's doing.");
+  console.log("Open your Clario space and give your agent a task: your avatar's card shows what it's doing.");
 }
 
 function status() {
@@ -200,35 +293,54 @@ function status() {
       : "Key:     none (run setup)",
   );
   console.log(`Hook:    ${existsSync(HOOK_PATH) ? HOOK_PATH : "not installed (run setup)"}`);
-  for (const global of [false, true]) {
-    const file = settingsFile(global);
-    const n = countOurHooks(readJson(file).value);
-    console.log(`${global ? "All projects" : "This project"}: ${n ? `registered (${file})` : "not registered"}`);
-  }
+  const registered = (file) => (countOurHooks(readJson(file).value) ? `registered (${file})` : "not registered");
+  console.log(`Claude Code, this project: ${registered(AGENT_TARGETS.claude.file(false))}`);
+  console.log(`Claude Code, all projects: ${registered(AGENT_TARGETS.claude.file(true))}`);
+  console.log(`Codex:   ${registered(AGENT_TARGETS.codex.file())}`);
+  console.log(`Cursor:  ${registered(AGENT_TARGETS.cursor.file())}`);
+  const projects = Array.isArray(config.projects) ? config.projects : [];
+  console.log(`Codex and Cursor share from: ${config.everyProject ? "every project" : projects.length ? projects.join(", ") : "no project yet"}`);
 }
 
 function uninstall(opts) {
-  const file = settingsFile(opts.global);
-  const { value } = readJson(file);
-  if (!value || !countOurHooks(value)) {
-    console.log(`No Clario hook in ${file}.`);
+  const { value: config } = readJson(CONFIG_PATH);
+  if (opts.global) {
+    // Stop everywhere: every agent's hook, and the list of shared projects.
+    for (const target of Object.values(AGENT_TARGETS)) {
+      const file = target.file(true);
+      if (unregisterHooks(file)) console.log(`Removed the ${target.name} hook from ${file}.`);
+    }
+    if (config) {
+      const { projects: _projects, everyProject: _every, ...rest } = config;
+      writeJson(CONFIG_PATH, rest, { mode: 0o600 });
+    }
+    console.log(`Nothing is shared any more. Your key stays in ${CONFIG_PATH}; delete that file to remove it too.`);
     return;
   }
-  copyFileSync(file, `${file}.clario-backup`);
-  writeJson(file, withoutOurHooks(value));
-  console.log(`Removed the Clario hook from ${file}. Your key stays in ${CONFIG_PATH}; delete that file to remove it too.`);
+  // Stop in this project: its Claude Code hook, and Codex and Cursor reporting from it.
+  const file = AGENT_TARGETS.claude.file(false);
+  if (unregisterHooks(file)) console.log(`Removed the Claude Code hook from ${file}.`);
+  const root = projectRoot();
+  if (config && Array.isArray(config.projects) && config.projects.includes(root)) {
+    writeJson(CONFIG_PATH, { ...config, projects: config.projects.filter((p) => p !== root) }, { mode: 0o600 });
+    console.log(`Codex and Cursor no longer share from ${root}.`);
+  }
+  if (config?.everyProject) console.log("Codex and Cursor still share from every project (setup --global); run uninstall --global to stop that.");
+  console.log("This project isn't shared any more.");
 }
 
-const HELP = `clario-agent: show what your Claude Code agent is doing on your Clario avatar
+const HELP = `clario-agent: show what your coding agent is doing on your Clario avatar
 
-  clario-agent setup --key KEY [--api-url URL] [--global]   save your key and register the hook
-  clario-agent status                                        show what is set up
-  clario-agent uninstall [--global]                          remove the hook
+  clario-agent setup --key KEY [--agent claude|codex|cursor|all] [--global]
+                                    save your key and register the hook
+  clario-agent status               show what is set up
+  clario-agent uninstall [--global] stop sharing from this project (or everywhere)
 
 Get the setup command (with your key) from the Agent button in your Clario space.
-Without --global the hook is registered only for the project you run it in.
-Without --key, setup reuses the key you saved before. The server is ${DEFAULT_API_URL}
-unless you pass --api-url.`;
+Setup registers every agent it finds on this computer; --agent picks them yourself
+(comma separated or repeated).
+Without --global only the project you run it in is shared. Without --key, setup reuses
+the key you saved before. The server is ${DEFAULT_API_URL} unless you pass --api-url.`;
 
 export async function run(argv) {
   const [command = "help", ...rest] = argv;
@@ -236,8 +348,8 @@ export async function run(argv) {
     const i = rest.indexOf(flag);
     return i > -1 ? rest[i + 1] : undefined;
   };
-  const opts = { global: rest.includes("--global"), apiUrl: value("--api-url"), key: value("--key") };
   try {
+    const opts = { global: rest.includes("--global"), apiUrl: value("--api-url"), key: value("--key"), agents: parseAgents(rest), picked: rest.some((arg) => arg.startsWith("--agent")) };
     if (command === "setup") await setup(opts);
     else if (command === "status") status();
     else if (command === "uninstall") uninstall(opts);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "clario-agent",
-  "version": "0.2.0",
-  "description": "Show what your Claude Code agent is doing (project, branch, commit) on your Clario avatar.",
+  "version": "0.4.0",
+  "description": "Show what your Claude Code, Codex or Cursor agent is doing (project, branch, commit) on your Clario avatar.",
   "type": "module",
   "bin": {
     "clario-agent": "cli.mjs"
@@ -18,6 +18,8 @@
   "keywords": [
     "clario",
     "claude-code",
+    "codex",
+    "cursor",
     "hooks",
     "agent",
     "metaverse"