@primusclaw/connector 0.1.3 → 0.1.4

package/README.md

@@ -94,7 +94,8 @@ In Clawy (or any chat client built on Claw), send `/agents`. The agents of this
 A session started there runs on this machine, inside one of your `roots`, and each permission request comes back as a card in the chat.
 
 To disconnect: `claw-connector pause` (stay offline until `resume`), `claw-connector stop`, or `claw-connector logout` (also
-asks the identity service to revoke the device sign-in; a saved key is deleted from this machine, not revoked at Claw).
+revokes this machine's connector at Claw, so it can be sent nothing more, and asks the identity service to revoke the device
+sign-in; a saved key is deleted from this machine, not revoked at Claw).
 
 ## agents.toml
 
@@ -336,7 +337,7 @@ session stops the agent process; it never deletes the conversation.
 | `status [--json]` | Running or not, paused, signed in, agents, adapter processes, the last disconnect and its reason (`last down:`), a `problem:` line when a new sign-in is needed, and a `warning:` line for each agent whose sessions will be refused because Claude's own settings default to `bypassPermissions` (see [Running without per-step approval](#running-without-per-step-approval)). |
 | `pause` / `resume` | Stop every agent within a second and stay offline, or undo that. |
 | `stop` | Stop the running connector and every agent it started. |
-| `logout` | Stop, ask the identity service to revoke the sign-in, delete it from this machine. The stored connector id stays, so the next sign-in reuses the same connector. |
+| `logout` | Stop, revoke this machine's connector at Claw (with a key, `DELETE /v1/remote-agents/connectors/:cid`; with a device sign-in, the connector-side `POST .../connectors/:cid/revoke`), ask the identity service to revoke the sign-in, and delete it from this machine. The next sign-in registers a new connector. When Claw cannot be reached or refuses (a Claw from before the connector-side route refuses a device sign-in), the sign-in is still deleted, but `logout` says the connector was not revoked, prints the `curl` that revokes it with a Claw API key of yours, keeps its id (so a later sign-in reuses it), and exits 1. |
 
 **Kill switch.** Every adapter is started in its own process group and recorded (pid and start time) in
 `children.json`. `stop`, `pause`, a revocation and Ctrl-C signal exactly those groups: a process that is not recorded, or

package/dist/cli.js

@@ -406,6 +406,17 @@ var ClawClient = class {
     const d = await this.json("POST", `/v1/remote-agents/connectors/${cid}/events`, { batch_id: batchId, events });
     return { acked: isObject(d.acked) ? d.acked : {}, rejected: Array.isArray(d.rejected) ? d.rejected : [] };
   }
+  /**
+   * Revoke connector `cid` at Claw, for `logout`: Claw sends it nothing more and closes its sessions. A key is a user's
+   * credential and uses the user-side DELETE; a device sign-in's access token is refused there, and uses the
+   * connector-side route made for this. Throws {@link HttpError} 404 `not_found` when Claw has no live row by that id
+   * for this sign-in (already revoked, or another account's).
+   */
+  async revoke(cid, kind) {
+    const id = encodeURIComponent(cid);
+    if (kind === "key") await this.json("DELETE", `/v1/remote-agents/connectors/${id}`);
+    else await this.json("POST", `/v1/remote-agents/connectors/${id}/revoke`);
+  }
   /**
    * Hold the command stream. Yields every frame (a `ping` too, since it is
    * proof of life). Ends normally when the server closes it; throws
@@ -2600,16 +2611,16 @@ var Session = class {
    * delivers it again instead of losing it.
    */
   enqueuePrompt(text, cmdId, started = () => {
-  }) {
+  }, cmdSeq = null) {
     if (this.closed) {
-      this.rejectCommand("prompt", cmdId, "session_closed");
+      this.rejectCommand("prompt", cmdId, "session_closed", cmdSeq);
       return started();
     }
     if (this.queue.length >= MAX_QUEUED_PROMPTS) {
-      this.rejectCommand("prompt", cmdId, "too_many_queued_prompts");
+      this.rejectCommand("prompt", cmdId, "too_many_queued_prompts", cmdSeq);
       return started();
     }
-    this.queue.push({ text, cmdId, started });
+    this.queue.push({ text, cmdId, cmdSeq, started });
     if (!this.turnRunning) void this.pump();
   }
   /** Prompts that will now never run (the process is being stopped): they count as handled. */
@@ -2624,21 +2635,22 @@ var Session = class {
     try {
       while (this.queue.length && !this.closed) {
         const next = this.queue.shift();
-        await this.runTurn(next.text, next.started, next.cmdId);
+        await this.runTurn(next.text, next.started, next.cmdId, next.cmdSeq);
       }
     } finally {
       this.turnRunning = false;
       this.touch();
     }
   }
-  async runTurn(text, started, cmdId) {
+  /** Every `turn_end` of the turn names its prompt: `cmd_id`, and `cmd_seq` (a number, which no credential scrub ever masks). */
+  async runTurn(text, started, cmdId, cmdSeq) {
     if (this.agent.attach) {
       const refused = await this.preflight();
       if (refused) {
         started();
         this.audit("prompt_refused", { reason: refused.reason, detail: refused.detail.slice(0, 300) });
-        this.rejectCommand("prompt", cmdId, refused.reason);
-        this.emit("turn_end", { stopReason: "error", error: refused.reason });
+        this.rejectCommand("prompt", cmdId, refused.reason, cmdSeq);
+        this.emit("turn_end", { stopReason: "error", error: refused.reason, cmd_id: cmdId, cmd_seq: cmdSeq });
         return;
       }
     }
@@ -2646,7 +2658,7 @@ var Session = class {
       await this.ensureAdapter();
     } catch (e) {
       started();
-      this.emit("turn_end", { stopReason: "error", error: e instanceof SessionRefusal ? e.reason : "adapter_unavailable" });
+      this.emit("turn_end", { stopReason: "error", error: e instanceof SessionRefusal ? e.reason : "adapter_unavailable", cmd_id: cmdId, cmd_seq: cmdSeq });
       return this.refuse(e);
     }
     const a = this.adapter;
@@ -2658,10 +2670,10 @@ var Session = class {
       started();
       const res = await reply;
       const usage = isObject(res.usage) ? res.usage : void 0;
-      this.emit("turn_end", { stopReason: typeof res.stopReason === "string" ? res.stopReason : "end_turn", ...usage ? { usage } : {} });
+      this.emit("turn_end", { stopReason: typeof res.stopReason === "string" ? res.stopReason : "end_turn", ...usage ? { usage } : {}, cmd_id: cmdId, cmd_seq: cmdSeq });
     } catch (e) {
       this.audit("turn_failed", { error: errMessage(e) });
-      this.emit("turn_end", { stopReason: "error", error: errMessage(e).slice(0, 300) });
+      this.emit("turn_end", { stopReason: "error", error: errMessage(e).slice(0, 300), cmd_id: cmdId, cmd_seq: cmdSeq });
     } finally {
       this.markTranscript();
       if (watch) {
@@ -2730,15 +2742,20 @@ var Session = class {
     this.emit("session_resumed", { acp_session_id: this.acpId, modes: this.shownModes(), currentMode: this.currentMode, unattended: this.unattended });
     this.touch();
   }
-  /** `cancel`: stop the turn, drop what was queued, answer every waiting permission request `cancelled`. */
+  /**
+   * `cancel`: stop the turn, drop what was queued, answer every waiting permission request `cancelled`. Each prompt dropped
+   * unrun is refused by name (`command_rejected`, reason `cancelled`, with its `cmd_id` and `cmd_seq`): it never gets a `turn_end`.
+   */
   async cancel() {
-    const queued = this.queue.length;
+    const dropped = this.queue.map((q) => [q.cmdId, q.cmdSeq]);
+    const queued = dropped.length;
     this.dropQueued();
+    for (const [cmdId, cmdSeq] of dropped) this.rejectCommand("prompt", cmdId, "cancelled", cmdSeq);
     const wasRunning = this.turnRunning;
     if (wasRunning && this.adapter && this.acpId) await this.adapter.notify("session/cancel", { sessionId: this.acpId }).catch(() => void 0);
     for (const actionId of this.book.cancelAll()) this.emit("permission_resolved", { actionId, optionId: null, outcome: "cancelled", by: "cancel" });
     this.audit("cancelled", { turn_running: wasRunning, queued_dropped: queued });
-    if (!wasRunning) this.emit("turn_end", { stopReason: "cancelled" });
+    if (!wasRunning) this.emit("turn_end", { stopReason: "cancelled", cmd_id: null, cmd_seq: null });
   }
   // --- ending ----------------------------------------------------------------------------
   /** The adapter's process goes away; the session stays and resumes on demand. */
@@ -2773,9 +2790,10 @@ var Session = class {
     this.audit("session_refused", { reason: r.reason, message: r.message.slice(0, 300) });
     await this.close(r.reason);
   }
-  rejectCommand(type, cmdId, reason) {
+  /** A command refused; a prompt's refusal names it by `cmd_seq` too, as its turn_end would. */
+  rejectCommand(type, cmdId, reason, cmdSeq = null) {
     this.audit("command_rejected", { type, cmd_id: cmdId, reason });
-    this.emit("command_rejected", { type, cmd_id: cmdId, reason });
+    this.emit("command_rejected", { type, cmd_id: cmdId, reason, ...cmdSeq !== null ? { cmd_seq: cmdSeq } : {} });
   }
 };
 function mapAdapterError(e) {
@@ -2801,6 +2819,7 @@ function limitStrings(value, max) {
 
 // src/manager.ts
 var MAX_ACTIVE_SESSIONS = 10;
+var cmdSeqOf = (cmd) => Number.isSafeInteger(cmd.cmd_seq) ? cmd.cmd_seq : null;
 var SessionManager = class {
   constructor(env) {
     this.env = env;
@@ -2869,10 +2888,10 @@ var SessionManager = class {
     switch (type) {
       case "prompt":
         if (typeof cmd.text !== "string" || cmd.text === "") {
-          s.rejectCommand("prompt", cmdId, "text_required");
+          s.rejectCommand("prompt", cmdId, "text_required", cmdSeqOf(cmd));
           return false;
         }
-        s.enqueuePrompt(cmd.text, cmdId, handled);
+        s.enqueuePrompt(cmd.text, cmdId, handled, cmdSeqOf(cmd));
         return true;
       case "cancel":
         await s.cancel();
@@ -3640,7 +3659,7 @@ var Connector = class {
       this.d.audit.record("command_dropped", { reason: "malformed_frame", id: f.id });
       return;
     }
-    const cmd = data;
+    const cmd = { ...data, cmd_seq: seq };
     if (this.ledger.seen(seq, cmd.cmd_id)) return;
     this.ledger.begin(seq, cmd.cmd_id);
     void this.manager.handle(cmd, () => {
@@ -4181,7 +4200,7 @@ function status(ctx, d, h, json) {
 }
 
 // src/version.ts
-var VERSION = "0.1.3";
+var VERSION = "0.1.4";
 
 // src/commands.ts
 var EXIT = { ok: 0, failure: 1, usage: 2, needsPerson: 78, revoked: 78 };
@@ -4210,7 +4229,7 @@ Usage: claw-connector <command> [options]
   pause                    stop every agent now and stay offline until "resume"
   resume                   undo "pause"
   stop                     stop the running connector and every agent it started
-  logout                   stop, revoke the sign-in and delete it
+  logout                   stop, revoke this connector at Claw and the sign-in, and delete the sign-in
   --version, --help
 
 Files: ${"$"}XDG_CONFIG_HOME/claw-connector (agents.toml, credentials.json) and ${"$"}XDG_STATE_HOME/claw-connector
@@ -4607,21 +4626,74 @@ async function cmdStop(ctx, quiet = false) {
   if (!quiet) ctx.out(pid === null ? `no connector running${left.killed.length ? `; stopped ${left.killed.length} leftover agent process group(s)` : ""}` : `stopped the connector${left.killed.length ? ` and ${left.killed.length} leftover agent process group(s)` : ""}`);
   return EXIT.ok;
 }
+function storedConnector(ctx) {
+  try {
+    const raw = JSON.parse(fs16.readFileSync(identityFile(ctx.dirs), "utf8"));
+    if (isObject(raw) && typeof raw.server === "string" && typeof raw.connector_id === "string") {
+      return { server: raw.server, connector_id: raw.connector_id, revoked: raw.revoked === true };
+    }
+  } catch {
+  }
+  return null;
+}
+var revokeByHand = (server, cid) => `curl -fsS -X DELETE -H "Authorization: Bearer <your Claw API key>" ${server}/v1/remote-agents/connectors/${encodeURIComponent(cid)}`;
 async function cmdLogout(ctx) {
   await cmdStop(ctx, true);
   const file = credentialsFile(ctx.dirs);
   let creds = null;
+  let credsProblem = null;
   try {
     creds = loadCredentials(file);
-  } catch {
+  } catch (e) {
+    credsProblem = errMessage(e);
+  }
+  const row = storedConnector(ctx);
+  let latest = creds;
+  let notRevoked = null;
+  let rowGone = false;
+  if (row && !row.revoked) {
+    if (!creds) {
+      notRevoked = credsProblem ? `the sign-in on this machine is unreadable (${credsProblem})` : "this machine is not signed in";
+    } else {
+      let server = null;
+      try {
+        let cfg = null;
+        try {
+          cfg = loadCfg(ctx);
+        } catch (e) {
+          if (!(e instanceof ConfigError)) throw e;
+        }
+        server = serverUrl(ctx, void 0, cfg, creds);
+      } catch {
+      }
+      if (server !== row.server) {
+        notRevoked = `it was registered at ${row.server}, but this sign-in is for ${server ?? "no usable server"}, so nothing was sent to either`;
+      } else try {
+        const tokens = providerFor(creds, (c) => {
+          latest = c;
+          saveCredentials(file, c);
+        }, { fetch: ctx.fetch });
+        const client2 = new ClawClient({ server: row.server, tokens, fetch: ctx.fetch, requestTimeoutMs: 15e3 });
+        await client2.revoke(row.connector_id, creds.kind);
+        rowGone = true;
+        ctx.out(`revoked connector ${row.connector_id} at ${row.server}: Claw sends it nothing more`);
+      } catch (e) {
+        if (e instanceof RevokedError || e instanceof HttpError && e.status === 404 && e.code === "not_found") {
+          rowGone = true;
+          ctx.out(`Claw has no live connector ${row.connector_id} for this sign-in (already revoked, or registered by another account)`);
+        } else {
+          notRevoked = errMessage(e);
+        }
+      }
+    }
   }
-  if (creds?.kind === "device" && creds.identity_url && creds.refresh_token) {
+  if (latest?.kind === "device" && latest.identity_url && latest.refresh_token) {
     try {
       const f = ctx.fetch ?? fetch;
-      await f(`${creds.identity_url}/oauth/revoke`, {
+      await f(`${latest.identity_url}/oauth/revoke`, {
         method: "POST",
         headers: { "content-type": "application/x-www-form-urlencoded" },
-        body: new URLSearchParams({ token: creds.refresh_token, token_type_hint: "refresh_token", client_id: creds.client_id ?? DEFAULT_CLIENT_ID }),
+        body: new URLSearchParams({ token: latest.refresh_token, token_type_hint: "refresh_token", client_id: latest.client_id ?? DEFAULT_CLIENT_ID }),
         signal: AbortSignal.timeout(1e4)
       });
     } catch (e) {
@@ -4629,7 +4701,15 @@ async function cmdLogout(ctx) {
     }
   }
   fs16.rmSync(file, { force: true });
-  forgetRevokedIdentity(ctx);
+  if (rowGone) fs16.rmSync(identityFile(ctx.dirs), { force: true });
+  else forgetRevokedIdentity(ctx);
+  if (row && notRevoked !== null) {
+    ctx.err(`signed out on this machine, but connector ${row.connector_id} was NOT revoked at Claw (${notRevoked}).`);
+    ctx.err("It is still your connector there, and instructions sent to it wait for the next sign-in on this machine. Revoke it with:");
+    ctx.err(`  ${revokeByHand(row.server, row.connector_id)}`);
+    ctx.err("or sign in again and run logout once Claw is reachable.");
+    return EXIT.failure;
+  }
   ctx.out("signed out");
   return EXIT.ok;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@primusclaw/connector",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "description": "Connects the coding agents on your own machine to Claw, over outbound HTTPS only.",
   "license": "MIT",
   "repository": {