@wenrwa/marketplace-cli 0.5.23 → 0.6.2

package/dist/bridge/localContextWriter.d.ts

@@ -26,6 +26,18 @@ export interface LocalContextWriteResult {
  */
 export declare function writeLocalContext(input: {
     projectRoot: string;
-    content: string;
+    /** Absent only for a pointers-only refresh (wmr-07). */
+    content?: string;
     workGraphAvailable?: boolean;
+    /** wmr-04 — two-lane parity with contextWriter.ts. Gated by the caller on
+     *  the local lane's own honest signal (did THIS bridge run register the
+     *  MCP server), not on a container env var that does not exist here. */
+    memoryAvailable?: boolean;
+    /** wmr-04 — this workspace's composed brief, or null when the fetch failed
+     *  or there is nothing yet. Never blocks the write (PRD D2). */
+    memoryBrief?: string | null;
+    /** wmr-07 — refresh only the standing pointers, keeping the pushed file
+     *  content. The local twin of contextWriter's flag; same reason (the
+     *  manifest frame only arrives when the pilot has files selected). */
+    pointersOnly?: boolean;
 }, deps: LocalContextWriterDeps): LocalContextWriteResult;

package/dist/bridge/localContextWriter.js

@@ -55,6 +55,16 @@ exports.writeLocalContext = writeLocalContext;
  */
 const path = __importStar(require("path"));
 const workGraphPointer_1 = require("./workGraphPointer");
+const memoryPointer_1 = require("./memoryPointer");
+const contextWriter_1 = require("./contextWriter");
+/** Split a bridge-owned context file into its pointer block and the rest. */
+function splitPointers(body) {
+    const start = body.indexOf(contextWriter_1.POINTERS_START_MARKER);
+    const end = body.indexOf(contextWriter_1.POINTERS_END_MARKER);
+    if (start === -1 || end === -1 || end < start)
+        return { rest: body.trim() };
+    return { rest: (body.slice(0, start) + body.slice(end + contextWriter_1.POINTERS_END_MARKER.length)).trim() };
+}
 exports.LOCAL_CONTEXT_DIR = '.hiveop';
 exports.LOCAL_CONTEXT_FILENAME = 'context.md';
 exports.LOCAL_CONTEXT_RELATIVE_PATH = `${exports.LOCAL_CONTEXT_DIR}/${exports.LOCAL_CONTEXT_FILENAME}`;
@@ -72,10 +82,27 @@ function writeLocalContext(input, deps) {
     // to pre-wgcp-01 behavior (never pointing at unregistered MCP tools); when
     // present, the pointer alone is reason enough to write the file, even with
     // no pushed manifest this turn.
-    const hasFileContent = input.content.trim().length > 0;
-    const content = input.workGraphAvailable
-        ? (hasFileContent ? `${workGraphPointer_1.WORK_GRAPH_POINTER}\n\n${input.content}` : workGraphPointer_1.WORK_GRAPH_POINTER)
-        : input.content;
+    //
+    // wmr-04 adds the memory section under the same rule, assembled as a list of
+    // present sections so the joining and empty-content logic is stated once —
+    // the same shape contextWriter.ts uses, because the two lanes diverging on
+    // this would be a two-lane bug nobody would notice until a local pilot
+    // reported missing memory.
+    const pointers = [];
+    if (input.workGraphAvailable)
+        pointers.push(workGraphPointer_1.WORK_GRAPH_POINTER);
+    if (input.memoryAvailable)
+        pointers.push((0, memoryPointer_1.memorySection)(input.memoryBrief));
+    // wmr-07 — the whole local file is bridge-owned, so "preserve the pushed
+    // content" means keeping what is already on disk below the pointer fence.
+    const existingBody = existed ? deps.readFile(contextPath) : '';
+    const fileContent = input.pointersOnly
+        ? splitPointers(existingBody).rest
+        : (input.content ?? '').trim();
+    const block = pointers.length > 0
+        ? `${contextWriter_1.POINTERS_START_MARKER}\n${pointers.join('\n\n')}\n${contextWriter_1.POINTERS_END_MARKER}`
+        : '';
+    const content = [block, fileContent].filter((part) => part.length > 0).join('\n\n');
     const isEmpty = content.trim().length === 0;
     if (isEmpty) {
         if (!existed)

package/dist/bridge/memoryBrief.d.ts

@@ -0,0 +1,41 @@
+/**
+ * wmr-02 — bridge-side fetcher for the workspace memory brief
+ * (`GET /workspaces/:id/memory/brief`, PRD decision D2 —
+ * docs/prd/workspace-memory-read-path.md). Mirrors storageQuotaFetch.ts's
+ * shape: injectable fetchImpl (defaults to the global fetch every Node
+ * >=18 the CLI already requires ships), ANY failure resolves null, never
+ * throws. This is deliberately a separate slice from anything that
+ * consumes the brief — proving the failure behaviour before depending on
+ * it is the whole point (see the PRD).
+ *
+ * Its entire contract: never throws, never hangs. On a non-200, network
+ * error, malformed/missing body, a missing/empty Connect Token, or a
+ * timeout, it resolves null so the caller writes the context region
+ * exactly as it would have anyway — memory can never become a single
+ * point of failure for opening a terminal.
+ */
+export type FetchLike = (url: string, init?: {
+    method?: string;
+    headers?: Record<string, string>;
+    signal?: AbortSignal;
+}) => Promise<{
+    ok: boolean;
+    status: number;
+    json: () => Promise<unknown>;
+}>;
+export interface FetchMemoryBriefOpts {
+    /** Injectable transport — tests stub this so nothing hits the network,
+     *  same discipline as apiClient.ts / storageQuotaFetch.ts. Defaults to
+     *  the global fetch. */
+    fetchImpl?: FetchLike;
+    /** Overrides the default bounded timeout, in ms. Tests use this to keep
+     *  the timeout case fast without waiting out the real default. */
+    timeoutMs?: number;
+}
+/**
+ * Fetch the workspace memory brief for `workspaceId`. See the module
+ * header for the full failure contract — every branch below returns null
+ * rather than propagating an error or letting a slow response block the
+ * caller.
+ */
+export declare function fetchMemoryBrief(workspaceId: string, opts?: FetchMemoryBriefOpts): Promise<string | null>;

package/dist/bridge/memoryBrief.js

@@ -0,0 +1,63 @@
+"use strict";
+/**
+ * wmr-02 — bridge-side fetcher for the workspace memory brief
+ * (`GET /workspaces/:id/memory/brief`, PRD decision D2 —
+ * docs/prd/workspace-memory-read-path.md). Mirrors storageQuotaFetch.ts's
+ * shape: injectable fetchImpl (defaults to the global fetch every Node
+ * >=18 the CLI already requires ships), ANY failure resolves null, never
+ * throws. This is deliberately a separate slice from anything that
+ * consumes the brief — proving the failure behaviour before depending on
+ * it is the whole point (see the PRD).
+ *
+ * Its entire contract: never throws, never hangs. On a non-200, network
+ * error, malformed/missing body, a missing/empty Connect Token, or a
+ * timeout, it resolves null so the caller writes the context region
+ * exactly as it would have anyway — memory can never become a single
+ * point of failure for opening a terminal.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchMemoryBrief = fetchMemoryBrief;
+const DEFAULT_API_URL = 'https://api.wenrwa.com/api/v1';
+/** Bounded so a hanging backend can never stall a terminal open. */
+const DEFAULT_TIMEOUT_MS = 4000;
+/**
+ * Fetch the workspace memory brief for `workspaceId`. See the module
+ * header for the full failure contract — every branch below returns null
+ * rather than propagating an error or letting a slow response block the
+ * caller.
+ */
+async function fetchMemoryBrief(workspaceId, opts = {}) {
+    const token = process.env.WENRWA_CONNECT_TOKEN;
+    if (!token)
+        return null; // missing/empty token — never even attempt the call
+    const fetchImpl = opts.fetchImpl ?? globalThis.fetch;
+    if (!fetchImpl)
+        return null;
+    const apiUrl = process.env.MARKETPLACE_API_URL || DEFAULT_API_URL;
+    const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    const url = `${apiUrl}/workspaces/${encodeURIComponent(workspaceId)}/memory/brief`;
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        const res = await fetchImpl(url, {
+            method: 'GET',
+            headers: { Authorization: `Bearer ${token}` },
+            signal: controller.signal,
+        });
+        if (!res.ok)
+            return null;
+        const body = (await res.json());
+        if (body?.success !== true || typeof body.brief !== 'string' || body.brief.length === 0) {
+            return null; // malformed/missing body — never a fabricated brief
+        }
+        return body.brief;
+    }
+    catch {
+        // network error, abort/timeout, or json() throwing on malformed JSON —
+        // all collapse to the same UNKNOWN outcome, never thrown to the caller.
+        return null;
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}

package/dist/bridge/memoryPointer.d.ts

@@ -0,0 +1,49 @@
+/**
+ * wmr-01 — the guidance that tells an agent workspace memory exists at all.
+ *
+ * Workspace Memory (ADR-0044) shipped complete — store, verdicts, curation UI,
+ * MCP tools — and held ZERO entries in production for a month. Two reasons, and
+ * only one of them was a bug: agents were structurally forbidden from writing
+ * (a Connect Token allowlist omission, fixed in cb5e725), and nothing ever told
+ * them the store existed. Fixing the first without the second just swaps a 403
+ * for an agent that never calls the tool.
+ *
+ * Delivered through the SAME managed-region mechanism as the work-graph pointer
+ * (wgcp-01, workGraphPointer.ts) — contextWriter.ts for the hosted lane,
+ * localContextWriter.ts for local. No new delivery channel, and no image
+ * rebuild: `--append-system-prompt` does not exist in this codebase, and the
+ * hosted lane launches `claude` from a script baked into the image, so argv is
+ * not reachable from here.
+ *
+ * Gated by the CALLER on `WENRWA_CONNECT_TOKEN`, exactly as the work-graph
+ * pointer is: absent means the MCP tools this text names are not registered in
+ * this process, and pointing an agent at a tool it does not have is worse than
+ * silence.
+ *
+ * WHAT THIS TEXT HAS TO EARN. It rides in every agent's context on every
+ * attach, so it states a floor as well as a prompt: without one, the cheapest
+ * thing for a model to record is whatever it just read, which is exactly what
+ * the code already says and what nobody needs repeated. It also never tells an
+ * agent that memory is settled truth — entries carry verdicts, the brief
+ * renders its own `⚠ re-verify before relying:` flags, and the predecessor
+ * this epic replaced (lib/agent-memory.ts) failed precisely by prompting
+ * "confirmed facts — do not re-verify".
+ */
+export declare const MEMORY_POINTER: string;
+/**
+ * wmr-03 — the memory section as it appears in the managed region: the
+ * standing instruction, followed by this workspace's brief when there is one.
+ *
+ * THE BRIEF IS CARRIED VERBATIM. It arrives already composed and already
+ * capped by the backend (brief.service.ts: 2048 bytes, tiered pinned →
+ * STILL_VALID/ASSERTED → DRIFTED → UNVERIFIED, each rendered with its own flag
+ * text). Re-ranking, re-wrapping or re-capping it here would give the agent a
+ * different view of the same workspace than the Memory panel gives the human,
+ * and the two would drift apart with no test able to see it. The one judgement
+ * this function makes is whether there is anything to show at all.
+ *
+ * `null` — the fetch failed, or the workspace has no memory yet — renders the
+ * instruction alone rather than an empty heading. An empty heading reads as
+ * "this workspace knows nothing", which is a different and wrong claim.
+ */
+export declare function memorySection(brief: string | null | undefined): string;

package/dist/bridge/memoryPointer.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MEMORY_POINTER = void 0;
+exports.memorySection = memorySection;
+/**
+ * wmr-01 — the guidance that tells an agent workspace memory exists at all.
+ *
+ * Workspace Memory (ADR-0044) shipped complete — store, verdicts, curation UI,
+ * MCP tools — and held ZERO entries in production for a month. Two reasons, and
+ * only one of them was a bug: agents were structurally forbidden from writing
+ * (a Connect Token allowlist omission, fixed in cb5e725), and nothing ever told
+ * them the store existed. Fixing the first without the second just swaps a 403
+ * for an agent that never calls the tool.
+ *
+ * Delivered through the SAME managed-region mechanism as the work-graph pointer
+ * (wgcp-01, workGraphPointer.ts) — contextWriter.ts for the hosted lane,
+ * localContextWriter.ts for local. No new delivery channel, and no image
+ * rebuild: `--append-system-prompt` does not exist in this codebase, and the
+ * hosted lane launches `claude` from a script baked into the image, so argv is
+ * not reachable from here.
+ *
+ * Gated by the CALLER on `WENRWA_CONNECT_TOKEN`, exactly as the work-graph
+ * pointer is: absent means the MCP tools this text names are not registered in
+ * this process, and pointing an agent at a tool it does not have is worse than
+ * silence.
+ *
+ * WHAT THIS TEXT HAS TO EARN. It rides in every agent's context on every
+ * attach, so it states a floor as well as a prompt: without one, the cheapest
+ * thing for a model to record is whatever it just read, which is exactly what
+ * the code already says and what nobody needs repeated. It also never tells an
+ * agent that memory is settled truth — entries carry verdicts, the brief
+ * renders its own `⚠ re-verify before relying:` flags, and the predecessor
+ * this epic replaced (lib/agent-memory.ts) failed precisely by prompting
+ * "confirmed facts — do not re-verify".
+ */
+exports.MEMORY_POINTER = [
+    '## Workspace memory',
+    'This workspace has a shared memory other agents read: `memory_write` to record something, `memory_recall` to search it.',
+    'Worth recording: a correction you were given, a decision and the reason behind it, a non-obvious fact and the file you learned it from.',
+    'Not worth recording: anything the code already states, or anything you merely read this session.',
+].join('\n');
+/**
+ * wmr-03 — the memory section as it appears in the managed region: the
+ * standing instruction, followed by this workspace's brief when there is one.
+ *
+ * THE BRIEF IS CARRIED VERBATIM. It arrives already composed and already
+ * capped by the backend (brief.service.ts: 2048 bytes, tiered pinned →
+ * STILL_VALID/ASSERTED → DRIFTED → UNVERIFIED, each rendered with its own flag
+ * text). Re-ranking, re-wrapping or re-capping it here would give the agent a
+ * different view of the same workspace than the Memory panel gives the human,
+ * and the two would drift apart with no test able to see it. The one judgement
+ * this function makes is whether there is anything to show at all.
+ *
+ * `null` — the fetch failed, or the workspace has no memory yet — renders the
+ * instruction alone rather than an empty heading. An empty heading reads as
+ * "this workspace knows nothing", which is a different and wrong claim.
+ */
+function memorySection(brief) {
+    if (!brief || brief.trim().length === 0)
+        return exports.MEMORY_POINTER;
+    return `${exports.MEMORY_POINTER}\n\n${brief.trim()}`;
+}

package/dist/bridge/pairing.js

@@ -18,7 +18,13 @@ async function runPairingPoll(deps) {
         const result = await deps.poll();
         if (deps.isCancelled())
             return { outcome: 'cancelled' };
-        if (result.status === 'approved') {
+        // wha-08: PairingPollResponse's 'approved' status now also covers
+        // cli_login (auth/login.ts), which carries an apiKey instead of a
+        // connectToken/deviceId — `purpose !== 'cli_login'` is a type-only
+        // narrowing, never a behavior change: a bridge pollToken never yields a
+        // cli_login-shaped response, so this condition is always true for any
+        // real bridge poll.
+        if (result.status === 'approved' && result.purpose !== 'cli_login') {
             return { outcome: 'approved', connectToken: result.connectToken, deviceId: result.deviceId };
         }
         if (result.status === 'expired') {

package/dist/bridge/relayClient.d.ts

@@ -221,13 +221,32 @@ export interface RelayClientOpts {
      * error (legacy / local bridge has no workspace checkouts). This opens NO PTY
      * and does NOT feed Claude Code via keystrokes — the context arrives as a FILE.
      */
+    /**
+     * wmr-07 — refresh this workspace's standing pointers (work graph, memory
+     * brief) without touching its pushed file content. Called when a session
+     * opens, because the context-manifest frame only arrives when the pilot has
+     * files selected. Absent → nothing happens, exactly as before.
+     */
+    refreshContextPointers?: (args: {
+        workspaceId: string;
+    }) => void | Promise<void>;
     writeContext?: (manifest: {
         workspaceId: string;
         content: string;
     }) => {
         action: string;
         claudeMdPath: string | null;
-    } | void;
+    } | void
+    /**
+     * wmr-03 — may be async: the hosted implementation fetches this
+     * workspace's memory brief before writing the region. The frame handler
+     * below resolves it rather than becoming async itself, so no other frame
+     * type's ordering changes.
+     */
+     | Promise<{
+        action: string;
+        claudeMdPath: string | null;
+    } | void>;
     /**
      * cve-06 (ADR-0047 / ADR-0032): read ONE file out of the container's
      * workspace checkout — the hosted-lane counterpart of the local bridge's

package/dist/bridge/relayClient.js

@@ -1009,6 +1009,31 @@ function startRelayClient(opts) {
                             relayOwned.set(sessionId, { workspaceId });
                             // tchp-21 — best-effort, fire-and-forget: never blocks `opened`.
                             maybeCreateSessionAnchor(sessionId, cwd);
+                            /*
+                              wmr-07 — refresh the standing pointers (work graph, workspace
+                              memory + its brief) for this workspace now that a session
+                              exists.
+              
+                              This is the trigger the whole delivery was missing. wmr-01..04
+                              rode the context-manifest frame on the assumption it fires when
+                              a terminal attaches; it does not — arena only pushes one when
+                              the pilot has FILES SELECTED, so for an ordinary workspace the
+                              region was never written and neither the memory brief nor the
+                              work-graph pointer (shipped months earlier) ever arrived.
+                              Confirmed on a live container: CLAUDE.md untouched for 20 hours
+                              with neither present.
+              
+                              Doing it here needs no browser, no selection, and no arena at
+                              all — only a session opening, which is exactly when an agent is
+                              about to read the file. Pointers-only, so the pilot's pushed
+                              file content is preserved. Fire-and-forget: this must never
+                              delay or fail an `opened`.
+                            */
+                            if (workspaceId && opts.refreshContextPointers) {
+                                void Promise.resolve(opts.refreshContextPointers({ workspaceId })).catch((err) => {
+                                    console.error('[bridge] context pointer refresh failed (non-fatal):', err);
+                                });
+                            }
                             attachTo(sessionId)
                                 .then(() => {
                                 send(socket, {
@@ -1274,12 +1299,26 @@ function startRelayClient(opts) {
                             send(socket, { t: 'error', message: 'context-manifest unsupported (no workspace checkouts)' });
                             break;
                         }
-                        const result = opts.writeContext({ workspaceId: frame.workspaceId, content: frame.content ?? '' });
-                        send(socket, {
-                            t: 'context-written',
-                            workspaceId: frame.workspaceId,
-                            ...(frame.sessionId ? { sessionId: frame.sessionId } : {}),
-                            ...(result && typeof result === 'object' ? { action: result.action } : {}),
+                        // wmr-03: the implementation may be async (it fetches the memory
+                        // brief). Resolved here so the outer message handler stays sync —
+                        // making IT async would change ordering for every frame type. A
+                        // rejection can only come from a bug in the writer, never from the
+                        // brief fetch (which resolves null on any failure, PRD D2), so it
+                        // is answered rather than thrown into an unhandled rejection.
+                        Promise.resolve(opts.writeContext({ workspaceId: frame.workspaceId, content: frame.content ?? '' }))
+                            .then((result) => {
+                            send(socket, {
+                                t: 'context-written',
+                                workspaceId: frame.workspaceId,
+                                ...(frame.sessionId ? { sessionId: frame.sessionId } : {}),
+                                ...(result && typeof result === 'object' ? { action: result.action } : {}),
+                            });
+                        })
+                            .catch((err) => {
+                            send(socket, {
+                                t: 'error',
+                                message: `context-manifest failed: ${err instanceof Error ? err.message : String(err)}`,
+                            });
                         });
                         break;
                     }

package/dist/bridge/server.d.ts

@@ -197,10 +197,19 @@ export interface BridgeServerOpts {
      * this is a FILE write, not PTY input (ADR-0028), mirroring the hosted
      * lane's contextWriter.ts/relayClient.ts contract.
      */
+    /** wmr-04 — may be async: the implementation fetches this workspace's memory
+     *  brief before writing. The frame handler resolves it rather than becoming
+     *  async itself, so no other frame type's ordering changes. */
+    /** wmr-07 — the local twin of the hosted refreshContextPointers: write this
+     *  workspace's standing pointers when a session opens, without waiting for a
+     *  context-manifest that only arrives when files are selected. */
+    refreshLocalContextPointers?: (args: {
+        workspaceId: string;
+    }) => void | Promise<void>;
     writeLocalContext?: (params: {
         workspaceId: string;
         content: string;
-    }) => LocalContextWriteResult | null;
+    }) => LocalContextWriteResult | null | Promise<LocalContextWriteResult | null>;
     /**
      * fcct-24 — path to the local HiveOp activity JSONL file the activity
      * hooks (registered via a directly-spawned agent's `--settings`, see

package/dist/bridge/server.js

@@ -766,6 +766,14 @@ function startBridgeServer(opts) {
                                 send(ws, { t: 'error', message });
                                 break;
                             }
+                            // wmr-07 — same trigger as the hosted lane: the pointers are
+                            // refreshed when a session opens, not when a manifest happens to
+                            // be pushed. Fire-and-forget; never delays or fails `opened`.
+                            if (frame.workspaceId && opts.refreshLocalContextPointers) {
+                                void Promise.resolve(opts.refreshLocalContextPointers({ workspaceId: frame.workspaceId })).catch((err) => {
+                                    console.error('[bridge] local context pointer refresh failed (non-fatal):', err);
+                                });
+                            }
                             attachTo(sessionId).then(() => {
                                 send(ws, {
                                     t: 'opened',
@@ -874,16 +882,27 @@ function startBridgeServer(opts) {
                             send(ws, { t: 'error', message: 'context-manifest unsupported (no local writer wired)' });
                             break;
                         }
-                        const result = opts.writeLocalContext({ workspaceId: frame.workspaceId, content: frame.content });
-                        if (!result) {
-                            send(ws, { t: 'error', message: 'unknown local workspace' });
-                            break;
-                        }
-                        send(ws, {
-                            t: 'context-written',
-                            workspaceId: frame.workspaceId,
-                            ...(frame.sessionId ? { sessionId: frame.sessionId } : {}),
-                            action: result.action,
+                        // wmr-04: mirrors the hosted lane — resolved here so the outer
+                        // handler stays sync. A rejection can only be a bug in the writer;
+                        // the brief fetch resolves null on any failure (PRD D2).
+                        Promise.resolve(opts.writeLocalContext({ workspaceId: frame.workspaceId, content: frame.content }))
+                            .then((result) => {
+                            if (!result) {
+                                send(ws, { t: 'error', message: 'unknown local workspace' });
+                                return;
+                            }
+                            send(ws, {
+                                t: 'context-written',
+                                workspaceId: frame.workspaceId,
+                                ...(frame.sessionId ? { sessionId: frame.sessionId } : {}),
+                                action: result.action,
+                            });
+                        })
+                            .catch((err) => {
+                            send(ws, {
+                                t: 'error',
+                                message: `context-manifest failed: ${err instanceof Error ? err.message : String(err)}`,
+                            });
                         });
                         break;
                     }

package/dist/commands/auth.d.ts

@@ -1,2 +1,19 @@
+/**
+ * wha-08 (docs/prd/retire-wallet-header-auth.md, docs/CONTEXT-identity.md) —
+ * `wen-market auth login` / `auth logout` / `auth whoami`.
+ *
+ * `login` runs the device-code flow (lws-14's mechanism, purpose=cli_login —
+ * see auth/login.ts): a code is minted and printed with the approval URL
+ * (https://marketplace.wenrwa.com/settings/cli-login?code=<CODE>), the
+ * browser is opened as best-effort convenience, and the CLI polls until a
+ * human approves or denies it there. `--api-key` skips all of that for CI:
+ * an existing key is verified with one authenticated call and saved
+ * directly. Either way the CLI authenticates as an API key (X-API-Key) —
+ * never the retired X-Wallet-Pubkey header (see utils/client.ts).
+ *
+ * `logout` revokes the stored key server-side (DELETE /keys/:id — see
+ * ApiKeyController#revoke's wha-08 self-revoke-only guard) before deleting
+ * it locally, so a copied config file stops working too.
+ */
 import { Command } from 'commander';
 export declare const authCommand: Command;