@super-one/cli 0.75.3 → 0.75.4

package/MANIFEST.json

@@ -1,7 +1,7 @@
 {
   "name": "@super-one/cli",
-  "version": "0.75.3",
+  "version": "0.75.4",
   "kind": "npm",
   "minNodeMajor": 20,
-  "builtAt": "2026-10-20T10:20:27.095Z"
+  "builtAt": "2026-10-21T04:02:10.353Z"
 }

package/lib/cli.mjs

@@ -137,8 +137,8 @@ import { fileURLToPath } from "node:url";
 function resolveCliReleaseVersion() {
   const fromEnv = process.env.SUPERONE_CLI_VERSION?.trim();
   if (fromEnv) return fromEnv;
-  if ("0.75.3".trim()) {
-    return "0.75.3".trim();
+  if ("0.75.4".trim()) {
+    return "0.75.4".trim();
   }
   const fromDist = readDistManifestVersion();
   if (fromDist) return fromDist;
@@ -12818,6 +12818,8 @@ var init_agent_types = __esm({
       ENVIRONMENT_LIST_DRAFTS: "environment:listDrafts",
       ENVIRONMENT_UPSERT_DRAFT: "environment:upsertDraft",
       ENVIRONMENT_DELETE_DRAFT: "environment:deleteDraft",
+      ENVIRONMENT_OPEN_DRAFT: "environment:openDraft",
+      ENVIRONMENT_CLOSE_DRAFT: "environment:closeDraft",
       ENVIRONMENT_DISCONNECT_DRAFT: "environment:disconnectDraft",
       ENVIRONMENT_PREPARE_DRAFT_OPEN: "environment:prepareDraftOpen",
       ENVIRONMENT_DRAFT_OPEN_READY: "environment:draftOpenReady",
@@ -12881,6 +12883,8 @@ var init_agent_types = __esm({
       ENVIRONMENT_INSTALL_PROGRESS: "environment:installProgress",
       /** Node-local AI provider credentials (masked). */
       ENVIRONMENT_PROVIDER_LIST_CREDENTIALS: "environment:providerListCredentials",
+      /** Claude subscription accounts on the node, not the controller. */
+      ENVIRONMENT_CLAUDE_LIST_ACCOUNTS: "environment:claudeListAccounts",
       ENVIRONMENT_PROVIDER_CREATE_CREDENTIAL: "environment:providerCreateCredential",
       ENVIRONMENT_PROVIDER_UPDATE_CREDENTIAL: "environment:providerUpdateCredential",
       ENVIRONMENT_PROVIDER_DELETE_CREDENTIAL: "environment:providerDeleteCredential",
@@ -34053,29 +34057,88 @@ var init_async_coalescer = __esm({
       ttlMs;
       cache = /* @__PURE__ */ new Map();
       inFlight = /* @__PURE__ */ new Map();
-      get(key, compute) {
-        if (this.ttlMs > 0) {
-          const hit = this.cache.get(key);
-          if (hit && Date.now() - hit.at < this.ttlMs) return Promise.resolve(hit.value);
+      generation = /* @__PURE__ */ new Map();
+      ttlFor(key) {
+        return typeof this.ttlMs === "function" ? this.ttlMs(key) : this.ttlMs;
+      }
+      generationOf(key) {
+        return this.generation.get(key) ?? 0;
+      }
+      bump(key) {
+        this.generation.set(key, this.generationOf(key) + 1);
+      }
+      readFresh(key) {
+        const ttl = this.ttlFor(key);
+        if (!(ttl > 0)) return null;
+        const hit = this.cache.get(key);
+        if (!hit) return null;
+        if (Number.isFinite(ttl) && Date.now() - hit.at >= ttl) return null;
+        return hit;
+      }
+      /** Cached value still inside its TTL, if any. */
+      peek(key) {
+        return this.readFresh(key)?.value;
+      }
+      /**
+       * Remember a value the caller already fetched. An older in-flight result
+       * will not overwrite it.
+       */
+      remember(key, value) {
+        if (this.ttlFor(key) > 0) this.cache.set(key, { at: Date.now(), value });
+        this.bump(key);
+        this.inFlight.delete(key);
+      }
+      /** True when a compute for the current generation is still running. */
+      isInFlight(key) {
+        const running = this.inFlight.get(key);
+        return !!running && running.generation === this.generationOf(key);
+      }
+      get(key, compute, options) {
+        const force = options?.force === true;
+        if (!force) {
+          const hit = this.readFresh(key);
+          if (hit) return Promise.resolve(hit.value);
+        } else {
+          this.cache.delete(key);
         }
+        const generation = this.generationOf(key);
         const running = this.inFlight.get(key);
-        if (running) return running;
+        if (running && running.generation === generation && (running.force || !force)) {
+          return running.promise;
+        }
+        let started = generation;
+        if (force && running && running.generation === generation && !running.force) {
+          this.bump(key);
+          started = this.generationOf(key);
+        }
+        const cacheIf = options?.cacheIf;
         const promise2 = compute().then((value) => {
-          if (this.ttlMs > 0) this.cache.set(key, { at: Date.now(), value });
+          if (this.generationOf(key) === started && this.ttlFor(key) > 0 && (!cacheIf || cacheIf(value))) {
+            this.cache.set(key, { at: Date.now(), value });
+          }
           return value;
         }).finally(() => {
-          if (this.inFlight.get(key) === promise2) this.inFlight.delete(key);
+          if (this.inFlight.get(key)?.promise === promise2) this.inFlight.delete(key);
         });
-        this.inFlight.set(key, promise2);
+        this.inFlight.set(key, { generation: started, promise: promise2, force });
         return promise2;
       }
-      /** Drop a cached result. In-flight work is left alone — it is already the newest read. */
+      /** Drop a cached result and detach the in-flight compute so the next get starts over. */
       invalidate(key) {
         this.cache.delete(key);
+        this.bump(key);
+        this.inFlight.delete(key);
+      }
+      /** Drop every cached key that matches. In-flight computes for those keys are detached too. */
+      invalidateMatching(match) {
+        const keys = /* @__PURE__ */ new Set([...this.cache.keys(), ...this.inFlight.keys(), ...this.generation.keys()]);
+        for (const key of keys) if (match(key)) this.invalidate(key);
       }
       /** Drop all cached results (tests / host disconnect). */
       clear() {
         this.cache.clear();
+        for (const key of this.inFlight.keys()) this.bump(key);
+        this.inFlight.clear();
       }
     };
   }
@@ -104467,7 +104530,7 @@ async function startNodeServer(opts) {
             return;
           }
           wire = createConnectionWire(ws2, accept.finish(msg));
-          send({ type: "channel_ready" });
+          send({ type: "channel_ready", inlineAuth: true });
           return;
         }
         if (!isBinary) throw new SecureChannelError("channel_protocol", "expected a sealed binary frame");
@@ -104587,7 +104650,10 @@ async function handleHttp(req, res, opts) {
       ok: !opts.identity.identityConflict,
       environmentId: opts.identity.environmentId,
       nodePublicKeyFingerprint: opts.identity.publicKeyFingerprint,
-      identityConflict: opts.identity.identityConflict === true
+      identityConflict: opts.identity.identityConflict === true,
+      // Same capability as channel_ready. Absent on nodes that only speak the
+      // separate-socket auth exchanges.
+      ...opts.secureChannel ? { inlineAuth: true } : {}
     });
     return;
   }
@@ -104664,7 +104730,9 @@ function handleAuthRequest(path, body, bearer, opts) {
         proofSignature,
         verifyDeviceProof: opts.verifyDeviceProof
       });
-      return { status: 200, body: result3 };
+      if (body.issueTicket !== true) return { status: 200, body: result3 };
+      const ticket = opts.auth.createWsTicket(result3.accessToken);
+      return { status: 200, body: { ...result3, ticket: ticket.ticket, ticketExpiresAt: ticket.expiresAt } };
     } catch (err) {
       return failure(err, "token refresh failed");
     }
@@ -108634,18 +108702,23 @@ function extendHistoryIndex(base, messages) {
 function handleSessionGet(payload, ctx) {
   const denied = requireScopes(ctx.client, OPERATION_SCOPES.readSession);
   if (denied) return denied;
-  const sessionId = String(asRecord(payload).sessionId ?? "");
+  const body = asRecord(payload);
+  const sessionId = String(body.sessionId ?? "");
   if (!ctx.sessions) return mapThrown(unsupportedMethodError("session.get"));
   const session = ctx.sessions.get(sessionId);
-  const config2 = session?.harnessId === "acp" ? ctx.sessionProviders?.get(session.providerId)?.config : void 0;
   if (!session) return { result: null };
-  const { transcript, ...metadata } = session;
+  const { transcript, acpAgentId: recordedAgentId, ...metadata } = session;
+  const configAgentId = session.harnessId === "acp" ? ctx.sessionProviders?.get(session.providerId)?.config?.agentId : void 0;
+  const acpAgentId = namedAgent(recordedAgentId) ?? namedAgent(configAgentId);
   return { result: {
     ...metadata,
-    ...asRecord(payload).includeTranscript === false ? {} : { transcript },
-    ...session.harnessId === "acp" ? { acpAgentId: config2?.agentId ?? null } : {}
+    ...body.includeTranscript === false ? {} : { transcript },
+    ...acpAgentId ? { acpAgentId } : {}
   } };
 }
+function namedAgent(value) {
+  return typeof value === "string" && value ? value : void 0;
+}
 async function handleSessionLoad(payload, ctx) {
   const denied = requireScopes(ctx.client, OPERATION_SCOPES.readSession);
   if (denied) return denied;
@@ -111100,6 +111173,7 @@ function mapSessionRow(s4) {
     providerResume,
     ...providerSessionId ? { providerSessionId } : {},
     ...s4.parentSessionId ? { parentSessionId: s4.parentSessionId } : {},
+    ...typeof s4.acpAgentId === "string" && s4.acpAgentId ? { acpAgentId: s4.acpAgentId } : {},
     tags: Array.isArray(s4.tags) ? s4.tags : []
   };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@super-one/cli",
-  "version": "0.75.3",
+  "version": "0.75.4",
   "description": "SuperOne headless node CLI — remote execution environment (RPC, workspaces, sessions).",
   "type": "module",
   "license": "BUSL-1.1",