pi-provider-cursor-ask 0.1.0

package/src/extension/commands.ts

@@ -0,0 +1,163 @@
+/**
+ * Command registrations for the standalone Cursor Ask provider.
+ */
+
+import type { ExtensionAPI, ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
+import { getLastDiagnostics } from "../diagnostics/diagnostics.js";
+import { formatDriftSummary, getDriftSignals, hasStrandingDrift } from "../stream/drift.js";
+import { readCachedCatalog } from "../stream/model-cache.js";
+import { getCacheDir } from "../utils/cache-dir.js";
+import { getCursorAgentUrl, getCursorClientVersion } from "../stream/config.js";
+import { resolveSystemCredentialPolicy } from "../auth/consent.js";
+import { getLifecycleLogPath } from "../stream/debug-log.js";
+import { redactSecrets } from "../utils/security.js";
+import { formatCursorUsage, getCursorUsageSummary } from "../usage.js";
+import { CURSOR_ASK_COMMAND, CURSOR_ASK_IDENTITY } from "../identity.js";
+import { ProviderConstant, type CredentialSource } from "../types/enums.js";
+import type { ProcessedModel } from "../models/processing.js";
+import { showCursorReport } from "./report-dashboard.js";
+
+export interface CursorCommandOptions {
+  getAccessToken: (options?: { forceRefresh?: boolean }) => Promise<string>;
+  getLastRegisteredModels: () => ProcessedModel[];
+  getCurrentTokenSource: () => CredentialSource;
+}
+
+type NotifyLevel = "info" | "warning" | "error";
+
+type CommandCompletion = { value: string; label: string; description?: string };
+
+const SUBCOMMANDS: CommandCompletion[] = [
+  { value: "usage", label: "usage", description: "Show Cursor plan quota" },
+  { value: "doctor", label: "doctor", description: "Show sanitized diagnostics" },
+];
+
+export function formatCursorCommandHelp(): string {
+  return `Usage: ${CURSOR_ASK_COMMAND} <usage|doctor>`;
+}
+
+export function emitCursorCommandOutput(
+  ctx: Pick<ExtensionCommandContext, "hasUI" | "ui">,
+  text: string,
+  level: NotifyLevel = "info",
+): void {
+  if (ctx.hasUI) {
+    ctx.ui.notify(text, level);
+    return;
+  }
+  if (level === "error") console.error(text);
+  else console.log(text);
+}
+
+export function getCursorCommandCompletions(prefix: string): CommandCompletion[] | null {
+  const needle = prefix.trim().toLowerCase();
+  const items = SUBCOMMANDS.filter((item) => item.value.startsWith(needle));
+  return items.length > 0 ? items : null;
+}
+
+export function registerCursorCommands(pi: ExtensionAPI, options: CursorCommandOptions): void {
+  pi.registerCommand(CURSOR_ASK_IDENTITY.commandName, {
+    description: "Cursor usage and diagnostics",
+    getArgumentCompletions: getCursorCommandCompletions,
+    handler: async (args, ctx) => {
+      const tokens = args.trim().split(/\s+/).filter(Boolean);
+      const subcommand = (tokens[0] ?? "").toLowerCase();
+
+      if (!subcommand || subcommand === "help" || subcommand === "?") {
+        emitCursorCommandOutput(ctx, formatCursorCommandHelp());
+        return;
+      }
+
+      if (subcommand === "usage") {
+        try {
+          await showCursorReport(
+            ctx,
+            "Cursor usage",
+            formatCursorUsage(await getCursorUsageSummary(options.getAccessToken)),
+          );
+        } catch (error) {
+          emitCursorCommandOutput(
+            ctx,
+            `Cursor usage unavailable: ${redactSecrets(
+              error instanceof Error ? error.message : String(error),
+            )}`,
+            "error",
+          );
+        }
+        return;
+      }
+
+      if (subcommand === "doctor") {
+        await showCursorReport(ctx, "Cursor doctor", formatCursorDoctorReport(options));
+        return;
+      }
+
+      emitCursorCommandOutput(
+        ctx,
+        `Unknown ${CURSOR_ASK_COMMAND} subcommand. ${formatCursorCommandHelp()}`,
+        "warning",
+      );
+    },
+  });
+}
+
+function formatCursorDoctorReport(options: CursorCommandOptions): string {
+  const d = getLastDiagnostics();
+  const driftSignals = getDriftSignals();
+  const cachedCatalog = readCachedCatalog();
+  const registered = options.getLastRegisteredModels();
+  const currentTokenSource = options.getCurrentTokenSource();
+
+  const lines = [
+    "Cursor doctor",
+    `provider=${ProviderConstant.ProviderId}`,
+    `agentUrl=${getCursorAgentUrl()}`,
+    `clientVersion=${d.clientVersion || getCursorClientVersion()}`,
+    `tokenSource=${d.tokenSource || currentTokenSource || "none"}`,
+    `systemCredentials=${d.systemCredentials || resolveSystemCredentialPolicy()}`,
+    `lastResolvedRuntimeModel=${d.resolvedRuntimeModel || "none"}`,
+    `availableModels=${d.availableModels || registered.length || "none"}`,
+    `catalogCache=${
+      cachedCatalog
+        ? `${cachedCatalog.rawModels.length}+${cachedCatalog.parameterizedModels.length} models, age ${Math.round(
+            (Date.now() - cachedCatalog.savedAt) / 1000,
+          )}s`
+        : "none(using bundled fallback)"
+    }`,
+    `catalogCacheDir=${getCacheDir() || "unavailable"}`,
+    `matchedModel=${d.matchedModelDebug || "none"}`,
+    `lastEndpoint=${d.endpoint || "none"}`,
+    `lastStatus=${d.status ?? "none"}`,
+    `lastRpc=${d.lastRpc || "none"}`,
+    `lastRecoverySkipReason=${d.lastRecoverySkipReason || "none"}`,
+    `lastStreamEvent=${d.lastStreamEvent || "none"}`,
+    `lastRequestSize=${d.lastRequestSize || "none"}`,
+    `lastDriftSignal=${d.lastDriftSignal || "none"}`,
+    `wireDrift=${formatDriftSummary() || "none"}`,
+    `wireDriftStranding=${hasStrandingDrift() ? "yes" : "no"}`,
+    `lastIdleTimeoutAt=${d.lastIdleTimeoutAt || "none"}`,
+    `lastIdleTimeoutMs=${d.lastIdleTimeoutMs ?? "none"}`,
+    `lastIdleAttempt=${d.lastIdleAttempt ?? "none"}`,
+    `streamIdleTimeoutMs=${process.env.PI_CURSOR_STREAM_IDLE_TIMEOUT_MS || "0(disabled)"}`,
+    `resumeIdleTimeoutMs=${process.env.PI_CURSOR_RESUME_IDLE_TIMEOUT_MS || "0(disabled)"}`,
+    `streamIdleMaxRetries=${process.env.PI_CURSOR_STREAM_IDLE_MAX_RETRIES || "0(disabled)"}`,
+    `h2IdleTimeoutMs=${process.env.PI_CURSOR_H2_IDLE_TIMEOUT_MS || "0(disabled)"}`,
+    `lifecycleLog=${getLifecycleLogPath()}`,
+    `lastError=${d.error ? redactSecrets(d.error) : "none"}`,
+    "transport=native-streamSimple",
+    "unaryTransport=in-process-h2",
+    "runtimeCli=not-used",
+    "proxyPath=removed",
+    `commands=${CURSOR_ASK_COMMAND} usage|doctor`,
+    "hint=On stalls check lifecycle log + lastStreamEvent; InteractionQuery hangs fixed in 1.2.2; re-login or PI_CURSOR_CLIENT_VERSION on wire errors",
+  ];
+  if (driftSignals.length > 0) {
+    lines.push("--- wire drift detail ---");
+    for (const s of driftSignals) {
+      lines.push(`  ${s.kind}: ${s.detail} (x${s.count}, first ${s.firstSeenIso})`);
+    }
+    lines.push("  Cursor's agent schema may have moved. See proto/README.md to regenerate,");
+    lines.push("  or pin PI_CURSOR_CLIENT_VERSION to a build that matches.");
+  }
+  return lines.join("\n");
+}

package/src/extension/compaction-guard.ts

@@ -0,0 +1,86 @@
+/** Correct Pi's successful-response silent-overflow heuristic for cumulative Cursor receipts. */
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import type { AssistantMessage } from "@earendil-works/pi-ai";
+import { positiveContextTokens, type CursorAssistantMessage } from "../stream/context-usage.js";
+import { lifecycleLog } from "../stream/debug-log.js";
+import { ProviderConstant } from "../types/enums.js";
+
+export function shouldSuppressCursorOverflow(input: {
+  reason?: string;
+  willRetry?: boolean;
+  model?: { provider: string; id: string; contextWindow: number };
+  lastAssistant?: AssistantMessage;
+  reserveTokens: number;
+  currentContextTokens?: number | null;
+}): boolean {
+  const { model, lastAssistant: message } = input;
+  if (input.reason !== "overflow" || input.willRetry !== false) return false;
+  if (!model || model.provider !== "cursor" || !message) return false;
+  if (
+    message.provider !== model.provider ||
+    message.model !== model.id ||
+    message.api !== ProviderConstant.NativeApi
+  )
+    return false;
+  if (message.stopReason !== "stop" || message.errorMessage) return false;
+  const metadata = (message as CursorAssistantMessage).cursorUsage;
+  const observed = positiveContextTokens(metadata?.context?.tokens);
+  const current = positiveContextTokens(input.currentContextTokens);
+  const window = positiveContextTokens(model.contextWindow);
+  if (
+    metadata?.version !== 1 ||
+    metadata.context?.source !== "checkpoint" ||
+    observed === undefined ||
+    current === undefined ||
+    window === undefined
+  )
+    return false;
+  if (
+    message.usage.totalTokens !== observed ||
+    !Number.isFinite(input.reserveTokens) ||
+    input.reserveTokens < 0
+  )
+    return false;
+  const promptBill = message.usage.input + message.usage.cacheRead;
+  const threshold = window - input.reserveTokens;
+  // Leave actual/near overflow, unknown evidence, manual requests and error recovery to Pi.
+  // Also check current context so a later large tool/user message cannot be hidden by an old snapshot.
+  return (
+    Number.isFinite(promptBill) &&
+    promptBill > window &&
+    observed < threshold &&
+    current < threshold
+  );
+}
+
+export function registerCursorCompactionGuard(pi: ExtensionAPI): void {
+  pi.on("session_before_compact", (event, ctx) => {
+    let lastAssistant: AssistantMessage | undefined;
+    for (let i = event.branchEntries.length - 1; i >= 0; i--) {
+      const entry = event.branchEntries[i]!;
+      if (entry.type === "compaction") break;
+      if (entry.type === "message" && entry.message.role === "assistant") {
+        lastAssistant = entry.message;
+        break;
+      }
+    }
+    if (
+      !shouldSuppressCursorOverflow({
+        reason: event.reason,
+        willRetry: event.willRetry,
+        model: ctx.model,
+        lastAssistant,
+        reserveTokens: event.preparation.settings.reserveTokens,
+        currentContextTokens: ctx.getContextUsage()?.tokens,
+      })
+    )
+      return;
+    lifecycleLog("compaction_overflow_suppressed", {
+      modelId: ctx.model?.id,
+      contextTokens: lastAssistant!.usage.totalTokens,
+      promptBill: lastAssistant!.usage.input + lastAssistant!.usage.cacheRead,
+      contextWindow: ctx.model?.contextWindow,
+    });
+    return { cancel: true };
+  });
+}

package/src/extension/debug-hooks.ts

@@ -0,0 +1,359 @@
+/**
+ * Extension debug logging hooks and image payload extraction.
+ */
+
+import { appendFile } from "node:fs";
+import { createHash } from "node:crypto";
+import { join as pathJoin } from "node:path";
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { getCacheDir } from "../utils/cache-dir.js";
+import { cleanupSessionState } from "../stream/session-state.js";
+import { setCursorNotifySink } from "../stream/debug-log.js";
+
+let extensionDebugLogFilePath: string | undefined;
+
+export function isExtensionDebugEnabled(): boolean {
+  const raw = process.env.PI_CURSOR_PROVIDER_DEBUG?.trim().toLowerCase();
+  return Boolean(raw && raw !== "0" && raw !== "false" && raw !== "off");
+}
+
+export function getExtensionDebugLogFilePath(): string {
+  if (extensionDebugLogFilePath) return extensionDebugLogFilePath;
+  const configured = process.env.PI_CURSOR_PROVIDER_EXTENSION_DEBUG_FILE?.trim();
+  if (configured) {
+    extensionDebugLogFilePath = configured;
+    return extensionDebugLogFilePath;
+  }
+  const stamp = new Date().toISOString().replace(/[:.]/g, "-");
+  extensionDebugLogFilePath = pathJoin(
+    getCacheDir() ?? process.cwd(),
+    `pi-cursor-provider-extension-debug-${stamp}-${process.pid}.log`,
+  );
+  return extensionDebugLogFilePath;
+}
+
+export function truncateDebugValue(value: string, max = 240): string {
+  return value.length > max
+    ? `${value.slice(0, max)}…<truncated ${value.length - max} chars>`
+    : value;
+}
+
+export function summarizeBase64ImageData(data: string): {
+  base64Length: number;
+  byteLength?: number;
+  sha256?: string;
+} {
+  const summary: { base64Length: number; byteLength?: number; sha256?: string } = {
+    base64Length: data.length,
+  };
+  try {
+    const bytes = Buffer.from(data.replace(/\s/g, ""), "base64");
+    if (bytes.length > 0) {
+      summary.byteLength = bytes.length;
+      summary.sha256 = createHash("sha256").update(bytes).digest("hex").slice(0, 16);
+    }
+  } catch {
+    // Invalid base64 — keep length-only summary.
+  }
+  return summary;
+}
+
+export function summarizeImageBlock(type: unknown, mimeType: unknown, data: unknown): unknown {
+  return {
+    type,
+    mimeType,
+    ...(typeof data === "string"
+      ? summarizeBase64ImageData(data)
+      : { data: `<redacted base64 ${String(data ?? "").length} chars>` }),
+  };
+}
+
+export function summarizeDataImageUrl(url: string): unknown {
+  const match = url.trim().match(/^data:([^;,]+)(?:;[^,]*)?;base64,(.*)$/is);
+  if (!match) {
+    return {
+      url: url.startsWith("data:image/")
+        ? `<redacted data image ${url.length} chars>`
+        : truncateDebugValue(url),
+    };
+  }
+  return {
+    mimeType: match[1]?.toLowerCase(),
+    ...summarizeBase64ImageData(match[2] ?? ""),
+  };
+}
+
+export function summarizeContent(content: unknown): unknown {
+  if (typeof content === "string") return truncateDebugValue(content);
+  if (!Array.isArray(content)) return content;
+  return content.map((block) => {
+    if (!block || typeof block !== "object") return block;
+    const typed = block as Record<string, unknown>;
+    switch (typed.type) {
+      case "text":
+        return { type: "text", text: truncateDebugValue(String(typed.text ?? "")) };
+      case "thinking":
+        return { type: "thinking", thinking: truncateDebugValue(String(typed.thinking ?? "")) };
+      case "toolCall":
+        return {
+          type: "toolCall",
+          id: typed.id,
+          name: typed.name,
+          arguments: typed.arguments,
+        };
+      case "image":
+        return summarizeImageBlock("image", typed.mimeType, typed.data);
+      case "image_url": {
+        const url = (typed.image_url as Record<string, unknown> | undefined)?.url;
+        const text = typeof url === "string" ? url : "";
+        return { type: "image_url", image_url: summarizeDataImageUrl(text) };
+      }
+      default:
+        return typed;
+    }
+  });
+}
+
+export function summarizeMessage(message: unknown): unknown {
+  if (!message || typeof message !== "object") return message;
+  const typed = message as Record<string, unknown>;
+  return {
+    role: typed.role,
+    stopReason: typed.stopReason,
+    toolCallId: typed.toolCallId,
+    toolName: typed.toolName,
+    isError: typed.isError,
+    errorMessage: typed.errorMessage,
+    content: summarizeContent(typed.content),
+  };
+}
+
+export function summarizeBranchTail(
+  ctx: {
+    sessionManager?: {
+      getBranch?: () => unknown[];
+      getLeafId?: () => string | null;
+      getSessionId?: () => string;
+    };
+  },
+  limit = 6,
+): unknown {
+  try {
+    const branch = ctx.sessionManager?.getBranch?.();
+    if (!Array.isArray(branch)) return undefined;
+    return {
+      sessionId: ctx.sessionManager?.getSessionId?.(),
+      leafId: ctx.sessionManager?.getLeafId?.(),
+      size: branch.length,
+      tail: branch.slice(-limit).map((entry) => {
+        if (!entry || typeof entry !== "object") return entry;
+        const typed = entry as Record<string, unknown>;
+        return {
+          type: typed.type,
+          id: typed.id,
+          parentId: typed.parentId,
+          customType: typed.customType,
+          message: summarizeMessage(typed.message),
+        };
+      }),
+    };
+  } catch (error) {
+    return { error: error instanceof Error ? error.message : String(error) };
+  }
+}
+
+export interface CursorToolResultImagePayload {
+  toolCallId: string;
+  images: Array<{ data: string; mimeType: string }>;
+}
+
+function payloadToolCallIds(payload: Record<string, unknown>): Set<string> {
+  const ids = new Set<string>();
+  const messages = Array.isArray(payload.messages) ? payload.messages : [];
+  for (const message of messages) {
+    if (!message || typeof message !== "object") continue;
+    const typed = message as Record<string, unknown>;
+    if (typed.role === "tool" && typeof typed.tool_call_id === "string" && typed.tool_call_id) {
+      ids.add(typed.tool_call_id);
+    }
+  }
+  return ids;
+}
+
+export function extractToolResultImagePayloads(
+  ctx: { sessionManager?: { getBranch?: () => unknown[] } },
+  payload: Record<string, unknown>,
+): CursorToolResultImagePayload[] {
+  const idsInPayload = payloadToolCallIds(payload);
+  if (idsInPayload.size === 0) return [];
+  const branch = ctx.sessionManager?.getBranch?.();
+  if (!Array.isArray(branch)) return [];
+
+  const byToolCallId = new Map<string, CursorToolResultImagePayload>();
+  for (const entry of branch) {
+    if (!entry || typeof entry !== "object") continue;
+    const message = (entry as Record<string, unknown>).message;
+    if (!message || typeof message !== "object") continue;
+    const typed = message as Record<string, unknown>;
+    const toolCallId = typeof typed.toolCallId === "string" ? typed.toolCallId : "";
+    if (typed.role !== "toolResult" || !toolCallId || !idsInPayload.has(toolCallId)) continue;
+    const content = Array.isArray(typed.content) ? typed.content : [];
+    const images = content.flatMap((block) => {
+      if (!block || typeof block !== "object") return [];
+      const image = block as Record<string, unknown>;
+      if (
+        image.type !== "image" ||
+        typeof image.data !== "string" ||
+        typeof image.mimeType !== "string"
+      ) {
+        return [];
+      }
+      return [{ data: image.data, mimeType: image.mimeType }];
+    });
+    if (images.length === 0) continue;
+    const existing = byToolCallId.get(toolCallId);
+    if (existing) {
+      existing.images.push(...images);
+    } else {
+      byToolCallId.set(toolCallId, { toolCallId, images });
+    }
+  }
+  return [...byToolCallId.values()];
+}
+
+export function debugExtensionLog(event: string, data?: Record<string, unknown>): void {
+  if (!isExtensionDebugEnabled()) return;
+  try {
+    const payload = JSON.stringify({
+      ts: new Date().toISOString(),
+      pid: process.pid,
+      scope: "extension",
+      event,
+      ...data,
+    });
+    appendFile(
+      getExtensionDebugLogFilePath(),
+      `${payload}\n`,
+      { encoding: "utf8", mode: 0o600 },
+      () => {},
+    );
+  } catch {
+    // Debug logging must never break extension hooks.
+  }
+}
+
+export function registerCursorNotifySink(pi: ExtensionAPI): void {
+  const capture = (_event: unknown, ctx: ExtensionContext) => {
+    if (!ctx.hasUI) {
+      setCursorNotifySink(undefined);
+      return;
+    }
+    setCursorNotifySink((message, level) => {
+      ctx.ui.notify(message, level);
+    });
+  };
+
+  pi.on("session_start", capture);
+  pi.on("before_agent_start", capture);
+}
+
+export function registerSessionLifecycleCleanup(pi: ExtensionAPI): void {
+  const cleanupCurrentSession = (_event: unknown, ctx: ExtensionContext) => {
+    debugExtensionLog("session.cleanup_hook", {
+      sessionId: ctx.sessionManager.getSessionId(),
+      leafId: ctx.sessionManager.getLeafId?.(),
+    });
+    cleanupSessionState(ctx.sessionManager.getSessionId());
+  };
+
+  pi.on("session_before_switch", cleanupCurrentSession);
+  pi.on("session_before_fork", cleanupCurrentSession);
+  pi.on("session_before_tree", cleanupCurrentSession);
+  pi.on("session_shutdown", cleanupCurrentSession);
+}
+
+export function registerExtensionDebugHooks(pi: ExtensionAPI): void {
+  if (!isExtensionDebugEnabled()) return;
+
+  pi.on("message_start", (event, ctx) => {
+    if (ctx.model?.provider !== "cursor") return;
+    debugExtensionLog("message.start", {
+      sessionId: ctx.sessionManager.getSessionId(),
+      leafId: ctx.sessionManager.getLeafId?.(),
+      model: ctx.model?.id,
+      message: summarizeMessage((event as { message?: unknown }).message),
+    });
+  });
+
+  pi.on("message_update", (event, ctx) => {
+    if (ctx.model?.provider !== "cursor") return;
+    const typedEvent = event as {
+      message?: unknown;
+      assistantMessageEvent?: Record<string, unknown>;
+    };
+    debugExtensionLog("message.update", {
+      sessionId: ctx.sessionManager.getSessionId(),
+      leafId: ctx.sessionManager.getLeafId?.(),
+      model: ctx.model?.id,
+      assistantMessageEvent: typedEvent.assistantMessageEvent
+        ? {
+            type: typedEvent.assistantMessageEvent.type,
+            delta: truncateDebugValue(
+              String(
+                (typedEvent.assistantMessageEvent as Record<string, unknown>).delta ??
+                  (typedEvent.assistantMessageEvent as Record<string, unknown>).content ??
+                  "",
+              ),
+            ),
+          }
+        : undefined,
+      message: summarizeMessage(typedEvent.message),
+    });
+  });
+
+  pi.on("message_end", (event, ctx) => {
+    if (ctx.model?.provider !== "cursor") return;
+    debugExtensionLog("message.end", {
+      sessionId: ctx.sessionManager.getSessionId(),
+      leafId: ctx.sessionManager.getLeafId?.(),
+      model: ctx.model?.id,
+      message: summarizeMessage((event as { message?: unknown }).message),
+      branch: summarizeBranchTail(ctx),
+    });
+  });
+
+  pi.on("context", (event, ctx) => {
+    if (ctx.model?.provider !== "cursor") return;
+    const typedEvent = event as { messages?: unknown[] };
+    debugExtensionLog("context", {
+      sessionId: ctx.sessionManager.getSessionId(),
+      leafId: ctx.sessionManager.getLeafId?.(),
+      model: ctx.model?.id,
+      messageCount: Array.isArray(typedEvent.messages) ? typedEvent.messages.length : undefined,
+      messages: Array.isArray(typedEvent.messages)
+        ? typedEvent.messages.slice(-8).map((message) => summarizeMessage(message))
+        : undefined,
+      branch: summarizeBranchTail(ctx),
+    });
+  });
+
+  pi.on("turn_end", (event, ctx) => {
+    if (ctx.model?.provider !== "cursor") return;
+    const typedEvent = event as { turnIndex?: number; message?: unknown; toolResults?: unknown[] };
+    debugExtensionLog("turn.end", {
+      sessionId: ctx.sessionManager.getSessionId(),
+      leafId: ctx.sessionManager.getLeafId?.(),
+      model: ctx.model?.id,
+      turnIndex: typedEvent.turnIndex,
+      message: summarizeMessage(typedEvent.message),
+      toolResults: Array.isArray(typedEvent.toolResults)
+        ? typedEvent.toolResults.map((message) => summarizeMessage(message))
+        : undefined,
+      branch: summarizeBranchTail(ctx),
+    });
+  });
+
+  debugExtensionLog("extension.debug_hooks_registered", {
+    logFile: getExtensionDebugLogFilePath(),
+  });
+}

package/src/extension/index.ts

@@ -0,0 +1,8 @@
+/**
+ * Extension layer entry point and exports.
+ */
+
+export * from "./auth.js";
+export * from "./commands.js";
+export * from "./debug-hooks.js";
+export * from "./provider.js";