@chorded/cursor-cloud-acp 0.1.0 → 0.2.0

package/README.md

@@ -5,21 +5,25 @@ v1 agent on stdin and stdout, written on Cursor's TypeScript SDK,
 `@cursor/sdk`. [chord](https://github.com/IKatsuba/chord) starts it as its
 `cursor-cloud` agent.
 
-Requires Node 22.13 or newer. Version 0.1.0 is not published yet; the
-commands below require that release.
+Requires Node 22.13 or newer. The commands below require 0.2.0
+to be published; the owner publishes it before chord's next release.
 
 ## Signing in
 
 ```sh
-npx -y @chorded/cursor-cloud-acp@0.1.0 login    # Cursor's browser login, the key kept in the OS keychain
-npx -y @chorded/cursor-cloud-acp@0.1.0 status   # whether the keychain holds a login
-npx -y @chorded/cursor-cloud-acp@0.1.0 logout   # the key removed from the keychain
+npx -y @chorded/cursor-cloud-acp@0.2.0 login    # Cursor's browser login, the key kept in the OS keychain
+npx -y @chorded/cursor-cloud-acp@0.2.0 status   # whether the keychain holds a login
+npx -y @chorded/cursor-cloud-acp@0.2.0 logout   # the key removed from the keychain
 ```
 
 `CURSOR_API_KEY`, when set, is used instead of the keychain's key. Where no
 keychain is there (Linux without a Secret Service), `login` refuses and
 points to `CURSOR_API_KEY`; no key is written to a file. The SDK's own
 login file is not used. Keychain calls time out after 10 seconds.
+ACP `auth/status` reports the account's name and email when given, with
+the key's source and keychain expiry when known; chord shows them in
+`/status`. Changes push at the next status request, session start, list,
+resume or load, without polling.
 
 What each prints, on stdout (the SDK's own lines, the login URL among
 them, go to stderr):
@@ -37,7 +41,7 @@ them, go to stderr):
 ```sh
 chord cursor-cloud
 # Or serve ACP v1 to another client in the current directory:
-npx -y @chorded/cursor-cloud-acp@0.1.0
+npx -y @chorded/cursor-cloud-acp@0.2.0
 ```
 
 Start in a git work tree on a pushed branch with a push remote. The check
@@ -50,7 +54,11 @@ nothing is downloaded.
 
 Creating a session is refused while the Cursor account's prepaid balance
 is empty: top up or enable auto top-up. `usage_limit_exceeded` appears as
-one plain line with Cursor's message.
+one plain line with Cursor's message. After each run, ACP `usage_update`
+reports the whole agent's undiscounted token cost in USD when available.
+Cost may lag until a later run. chord's `/cost` counts it per session, so
+resuming does not count earlier runs again. No context meter is shown:
+the SDK gives no context window.
 
 Agent and Plan modes apply from the next prompt. Models have one entry
 each, with separate parameter options; choosing a model starts outside
@@ -65,6 +73,9 @@ In chord, `/resume` lists chord's records;
 The adapter replays the history Cursor provides. A run still going is
 reported, not followed live; prompts are refused until it ends.
 ACP `session/list` lists the account's cloud agents for the repository.
+Cursor's agent name becomes the title only when it changes after a run,
+never on new, resume or load. `/rename` changes chord's title alone; a later
+change to Cursor's name replaces it.
 MCP servers are not forwarded: chord holds them back by default; servers
 sent by another client are named unreachable in the first message.
 

package/dist/main.js

@@ -157,6 +157,7 @@ function agent(real, from) {
     },
     [Symbol.asyncDispose]: () => guarded(() => real[Symbol.asyncDispose](), from),
     listArtifacts: () => guarded(() => real.listArtifacts(), from),
+    getUsage: (options) => guarded(() => real.getUsage(options), from),
     send: async (...args) => run(await guarded(() => real.send(...args), from), from)
   };
 }
@@ -383,6 +384,14 @@ var MODE = "mode";
 var MODEL = "model";
 var CURSORS_DEFAULT = "cursor-default";
 var PARAMETER = "parameter:";
+var MARKED = {
+  reasoning_effort: { category: "thought_level" },
+  context: {
+    category: "model_config",
+    _meta: { "chord/parameter": "context" }
+  },
+  fast: { category: "model_config", _meta: { "chord/parameter": "fast" } }
+};
 function sdkMode(choice) {
   return choice.mode === "plan" ? "plan" : "agent";
 }
@@ -461,6 +470,7 @@ function configOptions(choice, models, defaultOffered) {
     options.push({
       id: `${PARAMETER}${parameter.id}`,
       name: parameter.displayName ?? parameter.id,
+      ...Object.hasOwn(MARKED, parameter.id) ? MARKED[parameter.id] : {},
       type: "select",
       currentValue: value,
       options: parameter.values.filter((each) => allowed.has(each.value)).map((each) => ({
@@ -504,17 +514,42 @@ function choose(choice, models, defaultOffered, id, value) {
   };
 }
 
+// packages/cursor-cloud-acp/src/auth_status.ts
+var UNAUTHENTICATED = { state: "unauthenticated" };
+var UNKNOWN = { state: "unknown" };
+function description(found) {
+  if (found.source === "env") {
+    return "CURSOR_API_KEY";
+  }
+  return found.expiresAtMs === undefined ? "keychain" : `keychain, expires ${new Date(found.expiresAtMs).toISOString().slice(0, 10)}`;
+}
+function authenticated(found, user) {
+  const name = [user.userFirstName, user.userLastName].filter((part) => part !== undefined && part !== "").join(" ");
+  const account = {
+    label: "Cursor",
+    description: description(found),
+    active: true,
+    ...name === "" ? {} : { name },
+    ...user.userEmail === undefined || user.userEmail === "" ? {} : { email: user.userEmail }
+  };
+  return { state: "authenticated", accounts: [account] };
+}
+
 // packages/cursor-cloud-acp/src/credentials.ts
-async function apiKey(source) {
+async function findKey(source) {
   const fromEnv = source.env.CURSOR_API_KEY;
   if (fromEnv !== undefined && fromEnv !== "") {
-    return fromEnv;
+    return { apiKey: fromEnv, source: "env" };
   }
   const stored = await source.store.load();
   if (stored === undefined || stored.apiKeyExpiresAtMs !== undefined && stored.apiKeyExpiresAtMs <= source.now()) {
     return;
   }
-  return stored.apiKey;
+  return {
+    apiKey: stored.apiKey,
+    source: "keychain",
+    ...stored.apiKeyExpiresAtMs === undefined ? {} : { expiresAtMs: stored.apiKeyExpiresAtMs }
+  };
 }
 
 // packages/cursor-cloud-acp/src/turn.ts
@@ -911,14 +946,19 @@ class Turn {
     if (result.status === "error") {
       throw new RequestError2(INTERNAL_ERROR, result.error?.message ?? "The run failed.", result.error?.code === undefined ? undefined : { code: result.error.code });
     }
-    const artifacts = await Promise.race([
-      this.#context.artifacts(),
+    const asked = await Promise.race([
+      Promise.all([
+        this.#context.artifacts(),
+        this.#context.ended?.() ?? Promise.resolve([])
+      ]),
       this.#cancelling
     ]);
-    if (artifacts === "cancelled" || this.#cancelled) {
+    if (asked === "cancelled" || this.#cancelled) {
       return { stopReason: "cancelled", ...tokens };
     }
+    const [artifacts, ended] = asked;
     await this.#draw(runEnd(result, artifacts).map((text) => line(text)));
+    await this.#draw(ended);
     return this.#cancelled ? { stopReason: "cancelled", ...tokens } : { stopReason: "end_turn", ...tokens };
   }
   async#unconfirmed() {
@@ -972,6 +1012,7 @@ function initialize(version) {
       }
     ],
     agentCapabilities: {
+      auth: { status: {} },
       loadSession: true,
       promptCapabilities: { image: true, embeddedContext: false },
       mcpCapabilities: { http: false, sse: false },
@@ -1009,13 +1050,44 @@ function serve(stream, context) {
     }
     return open;
   };
-  const key = async () => {
-    const found = await apiKey(context.credentials());
+  const resolve = async () => {
+    let found;
+    try {
+      found = await findKey(context.credentials());
+    } catch (error) {
+      return { status: UNKNOWN, error };
+    }
     if (found === undefined) {
-      throw signedOut();
+      return { status: UNAUTHENTICATED, error: signedOut() };
+    }
+    try {
+      const user = await port.me({ apiKey: found.apiKey });
+      return { status: authenticated(found, user), key: found.apiKey };
+    } catch (error) {
+      return {
+        status: error instanceof CursorError && error.kind === "auth" ? UNAUTHENTICATED : UNKNOWN,
+        error
+      };
+    }
+  };
+  let kept;
+  const report = async (client, status) => {
+    const next = JSON.stringify(status);
+    if (kept === undefined || kept === next) {
+      return;
+    }
+    kept = next;
+    await client.notify("auth/status_update", status).catch(() => {
+      return;
+    });
+  };
+  const key = async (client) => {
+    const resolved = await resolve();
+    await report(client, resolved.status);
+    if ("error" in resolved) {
+      throw resolved.error;
     }
-    await port.me({ apiKey: found });
-    return found;
+    return resolved.key;
   };
   const models = (key) => port.models({ apiKey: key }).catch(() => []);
   const options = (open) => configOptions(open.choice, open.models, open.agent.model === undefined);
@@ -1067,9 +1139,9 @@ function serve(stream, context) {
     } while (cursor !== undefined);
     return runs;
   };
-  const reopen = async (id, mcpServers) => {
+  const reopen = async (id, mcpServers, client) => {
     const generation = begin(id);
-    const found = await key();
+    const found = await key(client);
     const reopened = await port.resume(id, { apiKey: found });
     return opening(reopened, async () => {
       const [latest] = (await port.listRuns(id, { runtime: "cloud", apiKey: found })).items;
@@ -1085,7 +1157,8 @@ function serve(stream, context) {
           ...reopened.model === undefined ? {} : { model: chosen(reopened.model) }
         },
         models: await models(found),
-        turn: undefined
+        turn: undefined,
+        name: info.name.trim() === "" ? undefined : info.name.trim()
       };
       await hold(open, generation);
       return {
@@ -1095,6 +1168,32 @@ function serve(stream, context) {
       };
     });
   };
+  const renamed = async (open) => {
+    const info = await port.get(open.agent.agentId, { apiKey: open.apiKey }).catch(() => {
+      return;
+    });
+    const name = info?.name.trim();
+    return info === undefined || name === undefined || name === "" || name === open.name ? [] : [
+      {
+        sessionUpdate: "session_info_update",
+        title: name,
+        updatedAt: new Date(info.lastModified).toISOString()
+      }
+    ];
+  };
+  const cost = async (open) => {
+    const usage = await open.agent.getUsage().catch(() => {
+      return;
+    });
+    return usage?.cost === undefined ? [] : [
+      {
+        sessionUpdate: "usage_update",
+        used: 0,
+        size: 0,
+        cost: { amount: usage.cost.rawCostCents / 100, currency: "USD" }
+      }
+    ];
+  };
   let shutting;
   const shutdown = async () => {
     ended = true;
@@ -1106,12 +1205,20 @@ function serve(stream, context) {
       new Promise((resolve) => setTimeout(resolve, RELEASE_MS).unref())
     ]);
   };
-  const connection = agent2({ name: NAME }).onRequest("initialize", () => initialize(context.version)).onRequest("authenticate", () => {
+  const connection = agent2({ name: NAME }).onRequest("initialize", () => initialize(context.version)).onRequest("auth/status", async ({ client }) => {
+    const { status } = await resolve();
+    if (kept === undefined) {
+      kept = JSON.stringify(status);
+    } else {
+      await report(client, status);
+    }
+    return status;
+  }).onRequest("authenticate", () => {
     throw new RequestError3(INVALID_PARAMS, `Sign in with \`${loginCommand(context.version)}\` in a terminal, or set CURSOR_API_KEY.`);
   }).onRequest("session/new", async ({ params, client }) => {
     try {
       const repo = await repository(params.cwd, context.git);
-      const found = await key();
+      const found = await key(client);
       const created = await port.create({
         apiKey: found,
         mode: "agent",
@@ -1129,7 +1236,8 @@ function serve(stream, context) {
           mcpServers: serverNames(params.mcpServers),
           choice: { mode: "default" },
           models: await models(found),
-          turn: undefined
+          turn: undefined,
+          name: undefined
         };
         await hold(opened, generation);
         return opened;
@@ -1165,15 +1273,24 @@ function serve(stream, context) {
         });
       },
       artifacts: () => open.agent.listArtifacts().catch(() => []),
+      ended: async () => (await Promise.all([renamed(open), cost(open)])).flat(),
       ran: (model) => {
         if (current() && open.choice === sentWith) {
           open.choice = { ...open.choice, model: chosen(model) };
         }
       },
-      emit: (update) => current() ? client.notify("session/update", {
-        sessionId: params.sessionId,
-        update
-      }) : Promise.resolve()
+      emit: (update) => {
+        if (!current()) {
+          return Promise.resolve();
+        }
+        if (update.sessionUpdate === "session_info_update") {
+          open.name = update.title ?? open.name;
+        }
+        return client.notify("session/update", {
+          sessionId: params.sessionId,
+          update
+        });
+      }
     });
     if (open.turn === undefined) {
       open.turn = turn;
@@ -1209,9 +1326,9 @@ function serve(stream, context) {
     }
     open.choice = next;
     return { configOptions: options(open) };
-  }).onRequest("session/list", async ({ params }) => {
+  }).onRequest("session/list", async ({ params, client }) => {
     try {
-      const found = await key();
+      const found = await key(client);
       const url = params.cwd === undefined || params.cwd === null ? undefined : (await repository(params.cwd, context.git, { pushed: false })).url;
       const listed = await port.list({
         runtime: "cloud",
@@ -1232,7 +1349,7 @@ function serve(stream, context) {
     }
   }).onRequest("session/resume", async ({ params, client }) => {
     try {
-      const { open, last, url } = await reopen(params.sessionId, params.mcpServers);
+      const { open, last, url } = await reopen(params.sessionId, params.mcpServers, client);
       await notifyWhile(open, client, params.sessionId, line(resumedMessage({
         url,
         agentId: params.sessionId,
@@ -1245,7 +1362,7 @@ function serve(stream, context) {
     }
   }).onRequest("session/load", async ({ params, client }) => {
     try {
-      const { open, last, url } = await reopen(params.sessionId, params.mcpServers);
+      const { open, last, url } = await reopen(params.sessionId, params.mcpServers, client);
       const notify = (update) => notifyWhile(open, client, params.sessionId, update);
       const runs = await allRuns(params.sessionId, open.apiKey);
       for (const run of oldestFirst(runs)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chorded/cursor-cloud-acp",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Cursor's cloud agents as an ACP v1 agent on stdin and stdout",
   "license": "MIT",
   "type": "module",
@@ -28,7 +28,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@agentclientprotocol/sdk": "^2.2.0",
+    "@agentclientprotocol/sdk": "^2.6.0",
     "@cursor/sdk": "1.3.1",
     "@napi-rs/keyring": "^2.1.2",
     "hosted-git-info": "^9.0.3",