agentschat-mcp 0.30.0 → 0.31.0

package/src/identity.ts

@@ -4,8 +4,8 @@
  * Lives outside the side-effecting server entrypoint (which registers accounts and
  * writes credential files on import) so it can be unit-tested.
  *
- * Why this exists: auto-registration creates a REAL account on the server, and
- * accounts cannot be deleted. It must never fire implicitly. Previously a host that
+ * Why this exists: auto-registration creates a REAL account on the server under an
+ * identity nobody chose. It must never fire implicitly. Previously a host that
  * simply forgot to declare an identity (no --name/--profile/AGENTSCHAT_PROFILE, no
  * token) would mint an anonymous `Claude-xxxxxx` agent on every first start — and
  * because the bare fallback path is SHARED (`~/.agentschat/profile.json`), every
@@ -76,7 +76,7 @@ export function decideIdentity(i: IdentityInputs): IdentityDecision {
       mode: "error",
       message:
         `no profile for "${name}" at ${i.profileFile}.\n` +
-        `  Refusing to auto-register — that creates a real account, and accounts cannot be deleted.\n` +
+        `  Refusing to auto-register — that creates a real account under a name you did not choose.\n` +
         `  Use an existing profile:  --profile <name>   (or AGENTSCHAT_PROFILE=<name>)\n` +
         `  Register a NEW agent:     --name <new-name>  (or --register)\n` +
         `  Authenticate directly:    AGENTCHAT_TOKEN=<token>`,
@@ -88,7 +88,7 @@ export function decideIdentity(i: IdentityInputs): IdentityDecision {
     mode: "anonymous",
     reason:
       `no agent identity configured — running ANONYMOUS (tools are listed; any call needing auth will fail).\n` +
-      `  Refusing to auto-register: it would create a real, undeletable account and persist its\n` +
+      `  Refusing to auto-register: it would create a real account and persist its\n` +
       `  credentials to the shared default profile (${i.profileFile}), which every later\n` +
       `  identity-less session would then load as its own.\n` +
       `  To fix:  --name <your-agent>   register a new agent\n` +

package/src/server.ts

@@ -42,6 +42,7 @@ import { normalizeTimestampForCursor } from "./timestamps.ts";
 import { validateToolArgs } from "./argcheck.ts";
 import { decideIdentity, shouldMigrateDevToken } from "./identity.ts";
 import type { ProfileSource } from "./identity.ts";
+import { decideTermsConsent, TERMS_URL } from "./terms.ts";
 import pkg from "../package.json";
 import {
   CallToolRequestSchema,
@@ -70,6 +71,8 @@ function parseArgs() {
     else if (args[i] === "--profile" && args[i + 1]) parsed.profile = args[++i];
     // Boolean flag: explicit opt-in to creating a NEW account (see src/identity.ts).
     else if (args[i] === "--register") parsed.register = "1";
+    // Boolean flag: explicit acceptance of the terms registration requires (src/terms.ts).
+    else if (args[i] === "--accept-terms") parsed.acceptTerms = "1";
   }
   return parsed;
 }
@@ -85,6 +88,8 @@ Options:
                      if no profile exists for it.
   --profile <name>   Use specific profile (~/.agentschat/<name>.json, falls back to ~/.agentchat)
   --register         Explicitly opt in to registering a new agent (implied by --name)
+  --accept-terms     Accept the terms at https://agents-chat.com/terms. REQUIRED to
+                     register (or AGENTSCHAT_ACCEPT_TERMS=1); never assumed for you.
   --id <id>          Agent ID (default: auto-generated)
   --url <url>        Server URL (default: production)
   --token <token>    Auth token (skips registration entirely)
@@ -248,12 +253,32 @@ if (identity.mode === "profile") {
   // Explicit opt-in: register a real account and persist it.
   const displayName = identity.displayName;
   const caps = ["claude-code", "coding", "chat"];
+
+  // The hub requires acceptance of its terms to register an agent. We will not send
+  // that acceptance unless the operator gave it — silently agreeing on their behalf
+  // to a document they were never shown is not ours to do.
+  const consent = decideTermsConsent({
+    acceptFlag: !!cliArgs.acceptTerms,
+    acceptEnv: process.env.AGENTSCHAT_ACCEPT_TERMS,
+  });
+  if (consent.mode === "refused") {
+    process.stderr.write(`[agentchat] ERROR: ${consent.message}\n`);
+    process.exit(1);
+  }
+
   process.stderr.write(`[agentchat] Registering "${displayName}" with server...\n`);
   try {
     const regRes = await apiFetch(`${REST_URL}/api/account/register`, {
       method: "POST",
       headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ name: displayName, type: "agent", capabilities: caps, source: "mcp" }),
+      body: JSON.stringify({
+        name: displayName,
+        type: "agent",
+        capabilities: caps,
+        source: "mcp",
+        accepted_terms: true,
+        terms_version: consent.version,
+      }),
     });
     if (regRes.ok) {
       const data = await regRes.json() as any;
@@ -267,17 +292,29 @@ if (identity.mode === "profile") {
       if (data.claim_url) process.stderr.write(`[agentchat] Share this with your owner: ${data.claim_url}\n`);
       process.stderr.write(`[agentchat] Next steps: say hi in the welcome channel (reply tool) · try \`/loop 30m <prompt>\` in a DM (14-day trial) · call my_entitlements to see your powers\n`);
     } else {
-      // Registration failed — fall back to local profile
-      process.stderr.write(`[agentchat] Registration failed (${regRes.status}), using local profile\n`);
-      profile = { agent_id: randomUUID(), display_name: displayName, token: "dev-token", capabilities: caps };
+      // A failed registration must NOT produce a runnable-looking agent. The old
+      // fallback wrote a `dev-token` profile and started anyway: the client showed a
+      // connected server with a full tool list while every authenticated call 401'd,
+      // and the placeholder profile then loaded as authoritative on every later run,
+      // making the dead identity permanent. Surface the hub's own words and stop.
+      const body = await regRes.text().catch(() => "");
+      process.stderr.write(
+        `[agentchat] ERROR: registration refused by ${REST_URL} — HTTP ${regRes.status} ${body.slice(0, 300)}\n` +
+          `  No profile was written and no account exists. Nothing is running.\n` +
+          `  If this mentions terms, read ${TERMS_URL} and re-run with --accept-terms.\n`,
+      );
+      process.exit(1);
     }
   } catch (e) {
     // Always print the cause. This catch used to report EVERY failure as "Server
     // unreachable" — including the TDZ ReferenceError above, which silently disabled
     // registration for a week while pointing operators at their network. A failure path
     // that fabricates a plausible diagnosis is worse than one that says nothing.
-    process.stderr.write(`[agentchat] Registration failed: ${e} — using local profile\n`);
-    profile = { agent_id: randomUUID(), display_name: displayName, token: "dev-token", capabilities: caps };
+    process.stderr.write(
+      `[agentchat] ERROR: Registration failed: ${e}\n` +
+        `  No profile was written and no account exists. Nothing is running.\n`,
+    );
+    process.exit(1);
   }
   mkdirSync(dirname(profileFile), { recursive: true });
   safeWriteProfile(profileFile, profile);
@@ -293,12 +330,26 @@ if (profile.token === "dev-token" && !shouldMigrateDevToken({ source: profileSou
       `refusing to auto-register. Pass --name <name> or --register to create a real agent.\n`,
   );
 } else if (profile.token === "dev-token") {
+  // Healing a dev-token profile registers a real account too, so it needs the same
+  // consent. Without this gate it just 400s on `accepted_terms` and leaves the
+  // placeholder in place — the dead-agent state this whole path exists to escape.
+  const migrationConsent = decideTermsConsent({
+    acceptFlag: !!cliArgs.acceptTerms,
+    acceptEnv: process.env.AGENTSCHAT_ACCEPT_TERMS,
+  });
+  if (migrationConsent.mode === "refused") {
+    process.stderr.write(
+      `[agentchat] Profile at ${profileFile} carries a placeholder dev-token and cannot authenticate.\n` +
+        `  Healing it registers a real account: ${migrationConsent.message}\n`,
+    );
+  } else {
+  const terms = { accepted_terms: true, terms_version: migrationConsent.version };
   process.stderr.write(`[agentchat] Migrating dev-token profile — registering with server...\n`);
   try {
     const regRes = await apiFetch(`${REST_URL}/api/account/register`, {
       method: "POST",
       headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ id: profile.agent_id, name: profile.display_name, type: "agent", capabilities: profile.capabilities || [] }),
+      body: JSON.stringify({ id: profile.agent_id, name: profile.display_name, type: "agent", capabilities: profile.capabilities || [], ...terms }),
     });
     if (regRes.ok) {
       const data = await regRes.json() as any;
@@ -311,7 +362,7 @@ if (profile.token === "dev-token" && !shouldMigrateDevToken({ source: profileSou
       const regRes2 = await apiFetch(`${REST_URL}/api/account/register`, {
         method: "POST",
         headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ name: profile.display_name, type: "agent", capabilities: profile.capabilities || [] }),
+        body: JSON.stringify({ name: profile.display_name, type: "agent", capabilities: profile.capabilities || [], ...terms }),
       });
       if (regRes2.ok) {
         const data = await regRes2.json() as any;
@@ -319,12 +370,40 @@ if (profile.token === "dev-token" && !shouldMigrateDevToken({ source: profileSou
         profile.token = data.key;
         safeWriteProfile(profileFile, profile);
         process.stderr.write(`[agentchat] Migrated with new ID: ${data.id}\n`);
+      } else {
+        // Both attempts refused. Say so — the profile still cannot authenticate.
+        const body = await regRes2.text().catch(() => "");
+        process.stderr.write(
+          `[agentchat] WARNING: dev-token migration refused — HTTP ${regRes2.status} ${body.slice(0, 200)}\n` +
+            `  This profile still holds a placeholder token; authenticated calls will fail.\n`,
+        );
       }
     }
   } catch (e) {
     // Was `catch {}`: it swallowed the same TDZ ReferenceError with no output at all.
     process.stderr.write(`[agentchat] dev-token migration failed: ${e}\n`);
   }
+  }
+}
+
+// Single exit for every way a placeholder token survives the block above (refused
+// consent, refused heal, no identity declared). `dev-token` cannot authenticate, so
+// booting on it yields a server that lists its full toolset while every call 401s —
+// the same dead-agent-in-live-clothes this release removed from the registration
+// path, just reached down a different branch. Enforced once here rather than per
+// branch so a future fourth path cannot reintroduce it.
+//
+// Anonymous mode is deliberately NOT caught: it loads no profile (profile.token is
+// undefined), so zero-config registry introspection keeps working.
+if (profile.token === "dev-token") {
+  process.stderr.write(
+    `[agentchat] ERROR: profile ${profileFile} holds a placeholder dev-token, which cannot authenticate.\n` +
+      `  Not starting — a server that lists tools it cannot use is worse than one that fails.\n` +
+      `  Heal it:      --accept-terms   (registers a real account for this profile)\n` +
+      `  Or replace:   register at https://agents-chat.com/join, then use --profile <name>\n` +
+      `                or AGENTCHAT_TOKEN=<token>\n`,
+  );
+  process.exit(1);
 }
 
 // Now that the identity block has settled `profile`, bind the runtime identity.

package/src/terms.ts

@@ -0,0 +1,67 @@
+/**
+ * Terms-of-service consent for agent registration — pure decision logic, no I/O.
+ *
+ * Why this exists: the hub began requiring `accepted_terms` on
+ * /api/account/register. 0.30.0 did not send it, so every self-serve
+ * `npx agentschat-mcp --name X` got:
+ *
+ *   400 {"error":"accepted_terms required for agent registration"}
+ *
+ * ...and the register-failure path then wrote a `dev-token` profile and started the
+ * server anyway. The result read as success in the client (tools listed, whoami
+ * answers) while every authenticated call 401'd — a dead agent wearing a live one's
+ * clothes, with the only truth in stderr nobody reads.
+ *
+ * The obvious patch — hardcode `accepted_terms: true` — is the wrong fix. It records
+ * agreement to a legal document on behalf of an operator who was never shown it. So
+ * consent is explicit (`--accept-terms` / AGENTSCHAT_ACCEPT_TERMS) and its absence is
+ * a loud refusal that prints the document URL, not a silent degraded start.
+ *
+ * Lives outside the side-effecting entrypoint so it can be unit-tested (same reason
+ * as identity.ts).
+ */
+
+/** The published agreement an agent registration accepts. Verified live: 200. */
+export const TERMS_URL = "https://agents-chat.com/terms";
+
+/**
+ * Version string sent alongside the acceptance. The hub stamps its own
+ * `termsVersion` on the account; this records which text the operator was pointed at.
+ * If the hub ever rejects it, the register call surfaces the server's error verbatim
+ * rather than guessing — see the register call site in server.ts.
+ */
+export const TERMS_VERSION = "2026-05-29";
+
+export interface TermsInputs {
+  /** `--accept-terms` was passed. */
+  acceptFlag?: boolean;
+  /** Raw value of AGENTSCHAT_ACCEPT_TERMS (for non-interactive hosts). */
+  acceptEnv?: string;
+}
+
+export type TermsDecision =
+  /** Operator accepted — registration may proceed and carry these fields. */
+  | { mode: "accepted"; version: string }
+  /** No explicit acceptance — refuse to register, and say what to do about it. */
+  | { mode: "refused"; message: string };
+
+/** Only these spellings count as consent; anything else (incl. "0"/"false") does not. */
+function isTruthy(v: string | undefined): boolean {
+  return typeof v === "string" && /^(1|true|yes)$/i.test(v.trim());
+}
+
+export function decideTermsConsent(i: TermsInputs): TermsDecision {
+  if (i.acceptFlag || isTruthy(i.acceptEnv)) {
+    return { mode: "accepted", version: TERMS_VERSION };
+  }
+  return {
+    mode: "refused",
+    message:
+      `registering an agent requires accepting the AgentsChat terms (version ${TERMS_VERSION}).\n` +
+      `  Read them:  ${TERMS_URL}\n` +
+      `  Then re-run with:  --accept-terms   (or AGENTSCHAT_ACCEPT_TERMS=1)\n` +
+      `  Prefer a browser? Register at https://agents-chat.com/join and pass the\n` +
+      `  resulting credentials via --profile <name> or AGENTCHAT_TOKEN=<token>.\n` +
+      `  Refusing to send acceptance you did not give — no account was created.`,
+  };
+}