@linghun/tui 0.1.0

package/dist/chunk-PGWW3DVE.js

@@ -0,0 +1,157 @@
+// src/shell/models/wheel-acceleration.ts
+var WINDOW_MS = 40;
+var MAX_HISTORY = 10;
+var TRACKPAD_AVG_THRESHOLD_MS = 10;
+var MAX_STEP_FALLBACK = 10;
+var TRACKPAD_BURST_GAP_MS = 5;
+var TRACKPAD_BURST_COUNT_THRESHOLD = 5;
+var WHEEL_BOUNCE_GAP_MAX_MS = 200;
+var WHEEL_MODE_IDLE_DISENGAGE_MS = 1500;
+var WHEEL_MODE_STEP = 15;
+var WHEEL_MODE_CAP = 15;
+var WHEEL_MODE_RAMP = 3;
+var WHEEL_DECAY_HALFLIFE_MS = 150;
+var WHEEL_DECAY_STEP = 5;
+var WHEEL_DECAY_GAP_MS = 80;
+var WHEEL_DECAY_CAP_SLOW = 3;
+var WHEEL_DECAY_CAP_FAST = 6;
+var WHEEL_DECAY_IDLE_MS = 500;
+var WHEEL_DECAY_KICK = 2;
+var WHEEL_ACCEL_STEP = 0.3;
+var WHEEL_ACCEL_MAX = 6;
+var WheelAccelerator = class {
+  timestamps = [];
+  base;
+  terminalType;
+  // Wheel mode state (native only, sticky after bounce confirmed)
+  wheelMode = false;
+  wheelModeMult = 1;
+  lastWheelModeTime = 0;
+  // Direction flip debounce (native only)
+  lastDir = 0;
+  pendingFlip = null;
+  // Trackpad burst detection
+  burstCount = 0;
+  // xterm.js exponential decay state
+  xtermMult = 1;
+  xtermFrac = 0;
+  // carried fractional scroll
+  lastXtermTime = 0;
+  constructor(options = {}) {
+    this.base = options.base ?? 1;
+    this.terminalType = options.terminalType ?? "native";
+  }
+  recordEvent(timestamp, direction, viewportHeight) {
+    const dir = direction === "up" ? 1 : -1;
+    if (this.terminalType === "xterm.js") {
+      return this.recordEventXtermJs(timestamp, dir);
+    }
+    return this.recordEventNative(timestamp, dir, viewportHeight);
+  }
+  reset() {
+    this.timestamps = [];
+    this.wheelMode = false;
+    this.wheelModeMult = 1;
+    this.lastWheelModeTime = 0;
+    this.lastDir = 0;
+    this.pendingFlip = null;
+    this.burstCount = 0;
+    this.xtermMult = 1;
+    this.xtermFrac = 0;
+    this.lastXtermTime = 0;
+  }
+  recordEventXtermJs(timestamp, dir) {
+    const gap = this.lastXtermTime > 0 ? timestamp - this.lastXtermTime : WHEEL_DECAY_IDLE_MS + 1;
+    this.lastXtermTime = timestamp;
+    if (gap > WHEEL_DECAY_IDLE_MS) {
+      this.xtermMult = WHEEL_DECAY_KICK;
+      this.xtermFrac = 0;
+    } else {
+      const momentum = Math.pow(0.5, gap / WHEEL_DECAY_HALFLIFE_MS);
+      const target = 1 + WHEEL_DECAY_STEP * momentum / (1 - momentum);
+      const cap = gap >= WHEEL_DECAY_GAP_MS ? WHEEL_DECAY_CAP_SLOW : WHEEL_DECAY_CAP_FAST;
+      this.xtermMult = Math.min(target, cap);
+    }
+    const exact = this.xtermMult + this.xtermFrac;
+    const step = Math.floor(exact);
+    this.xtermFrac = exact - step;
+    return step;
+  }
+  recordEventNative(timestamp, dir, viewportHeight) {
+    this.timestamps.push(timestamp);
+    if (this.timestamps.length > MAX_HISTORY) {
+      this.timestamps = this.timestamps.slice(-MAX_HISTORY);
+    }
+    if (this.wheelMode && timestamp - this.lastWheelModeTime > WHEEL_MODE_IDLE_DISENGAGE_MS) {
+      this.wheelMode = false;
+      this.wheelModeMult = this.base;
+      this.burstCount = 0;
+    }
+    if (this.pendingFlip) {
+      const flipGap = timestamp - this.pendingFlip.time;
+      if (dir === this.lastDir && flipGap <= WHEEL_BOUNCE_GAP_MAX_MS) {
+        this.wheelMode = true;
+        this.wheelModeMult = this.base;
+        this.lastWheelModeTime = timestamp;
+        this.burstCount = 0;
+        this.pendingFlip = null;
+      } else {
+        this.lastDir = this.pendingFlip.dir;
+        this.wheelModeMult = this.base;
+        this.burstCount = 0;
+        this.pendingFlip = null;
+        this.lastDir = dir;
+      }
+    }
+    if (this.lastDir !== 0 && dir !== this.lastDir && !this.pendingFlip) {
+      this.pendingFlip = { dir, time: timestamp };
+      return 0;
+    }
+    this.lastDir = dir;
+    const windowStart = timestamp - WINDOW_MS;
+    const recent = this.timestamps.filter((t) => t >= windowStart);
+    if (recent.length >= 2) {
+      const lastGap = recent[recent.length - 1] - recent[recent.length - 2];
+      if (lastGap < TRACKPAD_BURST_GAP_MS) {
+        this.burstCount++;
+      } else {
+        this.burstCount = 0;
+      }
+      if (this.burstCount >= TRACKPAD_BURST_COUNT_THRESHOLD) {
+        this.wheelMode = false;
+        this.wheelModeMult = this.base;
+        return this.base;
+      }
+    }
+    if (recent.length >= 2) {
+      const intervals = [];
+      for (let i = 1; i < recent.length; i++) {
+        intervals.push(recent[i] - recent[i - 1]);
+      }
+      const avgInterval = intervals.reduce((a, b) => a + b, 0) / intervals.length;
+      if (avgInterval < TRACKPAD_AVG_THRESHOLD_MS) {
+        return this.base;
+      }
+    }
+    if (this.wheelMode) {
+      const gap = timestamp - this.lastWheelModeTime;
+      this.lastWheelModeTime = timestamp;
+      const momentum = Math.pow(0.5, gap / WHEEL_DECAY_HALFLIFE_MS);
+      const target = this.base + WHEEL_MODE_STEP * momentum / (1 - momentum);
+      const cappedTarget = Math.min(target, WHEEL_MODE_CAP);
+      if (cappedTarget > this.wheelModeMult) {
+        this.wheelModeMult = Math.min(this.wheelModeMult + WHEEL_MODE_RAMP, cappedTarget);
+      } else {
+        this.wheelModeMult = cappedTarget;
+      }
+      return Math.round(this.wheelModeMult);
+    }
+    const maxStep = viewportHeight ? Math.max(1, Math.floor(viewportHeight / 2)) : MAX_STEP_FALLBACK;
+    const rampMult = this.base + Math.min(recent.length, maxStep / this.base) * WHEEL_ACCEL_STEP;
+    return Math.min(Math.round(rampMult), WHEEL_ACCEL_MAX);
+  }
+};
+
+export {
+  WheelAccelerator
+};

package/dist/chunk-QB4VWH7W.js

@@ -0,0 +1,515 @@
+import {
+  ensureSession,
+  showCommandPanel
+} from "./chunk-JO5ANTMR.js";
+import {
+  decidePermission
+} from "./chunk-DDXS2RDZ.js";
+import {
+  appendSystemEvent,
+  budgetToolResultTranscriptContent,
+  createEvidenceRecord,
+  rememberEvidence
+} from "./chunk-64MJP6FK.js";
+import {
+  sanitizeDiagnosticText,
+  truncateDisplay,
+  writeLine
+} from "./chunk-OMZYPQVA.js";
+
+// src/capability-runtime.ts
+import { randomUUID } from "crypto";
+import { basename } from "path";
+var TRANSPORT_PRIORITY = [
+  "desktop_bridge",
+  "websocket",
+  "http",
+  "mcp",
+  "plugin",
+  "mock"
+];
+var registry = /* @__PURE__ */ new Map();
+var providers = /* @__PURE__ */ new Map();
+var externalConnectionResolver;
+function registerCapability(definition, options = {}) {
+  const entries = registry.get(definition.id) ?? [];
+  const next = entries.filter((entry) => entry.projectPath !== options.projectPath);
+  next.push({ definition, projectPath: options.projectPath });
+  registry.set(definition.id, next);
+}
+function unregisterCapabilitiesByApp(appId, options = {}) {
+  for (const [id, entries] of registry.entries()) {
+    const next = entries.filter((entry) => {
+      if (entry.definition.appId !== appId) return true;
+      return options.projectPath !== void 0 && entry.projectPath !== options.projectPath;
+    });
+    if (next.length === 0) {
+      registry.delete(id);
+    } else {
+      registry.set(id, next);
+    }
+  }
+}
+function listCapabilities(context) {
+  return [...registry.values()].map((entries) => selectCapabilityEntry(entries, context)).filter((entry) => Boolean(entry)).map((entry) => entry.definition).sort((a, b) => a.id.localeCompare(b.id));
+}
+function findCapability(id, context) {
+  const entries = registry.get(id);
+  const entry = entries ? selectCapabilityEntry(entries, context) : void 0;
+  if (!entry) return void 0;
+  return entry.definition;
+}
+function resolveCapabilityConnection(definition, context) {
+  const external = externalConnectionResolver?.(definition, context);
+  if (external) return external;
+  const transport = TRANSPORT_PRIORITY.includes(definition.transport) ? definition.transport : definition.transport;
+  if (transport === "mock") {
+    return {
+      capabilityId: definition.id,
+      transport,
+      status: "connected",
+      summary: "mock provider ready"
+    };
+  }
+  const needsAuth = definition.auth !== "none";
+  return {
+    capabilityId: definition.id,
+    transport,
+    status: needsAuth ? "needs_configuration" : "not_connected",
+    summary: needsAuth ? "connector reserved; auth is not configured in this MVP" : "connector reserved; no live connection in this MVP"
+  };
+}
+async function executeCapability(request, context) {
+  const definition = findCapability(request.capabilityId, context);
+  if (!definition) {
+    return {
+      ok: false,
+      capabilityId: request.capabilityId,
+      summary: "Capability not found.",
+      metadata: {
+        transport: "mock",
+        auth: "none",
+        permission: "read",
+        riskLevel: "low",
+        connectionStatus: "unsupported"
+      }
+    };
+  }
+  const schemaError = validateCapabilityInput(definition, request.input);
+  if (schemaError) {
+    return buildFailedCapabilityResult(definition, schemaError, "unsupported");
+  }
+  const connection = resolveCapabilityConnection(definition, context);
+  if (connection.status !== "connected") {
+    return buildFailedCapabilityResult(definition, connection.summary, connection.status);
+  }
+  const permission = await checkCapabilityPermission(definition, request, context);
+  if (permission.decision !== "allow") {
+    return buildFailedCapabilityResult(
+      definition,
+      permission.decision === "deny" ? `Permission denied: ${permission.reason}` : `Permission required: ${permission.reason}`,
+      connection.status
+    );
+  }
+  const provider = providers.get(definition.transport);
+  if (!provider) {
+    return buildFailedCapabilityResult(
+      definition,
+      "Capability provider unavailable.",
+      "unsupported"
+    );
+  }
+  const result = await provider.execute(definition, request, context);
+  const sessionId = await ensureSession(context);
+  const outcome = result.ok ? "succeeded" : "failed";
+  const evidence = createEvidenceRecord(
+    "command_output",
+    `capability ${outcome} ${definition.id}: ${truncateDisplay(result.summary, 120)}`,
+    `capability:${definition.id}`,
+    [
+      "capability_execution",
+      definition.id,
+      definition.permission,
+      definition.transport,
+      "not_verification_pass",
+      result.ok ? "capability_success" : "capability_failure"
+    ]
+  );
+  if (result.artifactRef) {
+    evidence.fullOutputPath = result.artifactRef;
+    evidence.outputPath = result.artifactRef;
+  }
+  rememberEvidence(context, evidence);
+  await context.store.appendEvent(sessionId, {
+    type: "evidence_record",
+    ...evidence
+  });
+  await appendSystemEvent(
+    context,
+    sessionId,
+    [
+      `capability ${outcome} id=${definition.id}`,
+      `transport=${definition.transport}`,
+      `permission=${definition.permission}`,
+      `risk=${definition.riskLevel}`,
+      `evidence=${evidence.id}`,
+      result.artifactRef ? `artifact=${basename(result.artifactRef)}` : "artifact=none",
+      "verification=not_pass"
+    ].join(" "),
+    result.ok ? "info" : "warning"
+  );
+  return {
+    ...result,
+    evidenceId: evidence.id,
+    metadata: {
+      ...result.metadata,
+      connectionStatus: connection.status
+    }
+  };
+}
+function capabilityEntryVisible(entry, context) {
+  if (!entry.projectPath) return true;
+  return context?.projectPath === entry.projectPath;
+}
+function selectCapabilityEntry(entries, context) {
+  const projectEntry = context ? entries.find((entry) => entry.projectPath === context.projectPath) : void 0;
+  if (projectEntry) return projectEntry;
+  return entries.find((entry) => capabilityEntryVisible(entry, context));
+}
+function formatCapabilityDoctor(language = "zh-CN", context) {
+  const isEn = language === "en-US";
+  const lines = [
+    isEn ? "Capability doctor" : "Capability doctor",
+    isEn ? "- Runtime: Capability Runtime with mock provider and project-scoped Local HTTP connectors." : "- \u8FD0\u884C\u65F6\uFF1ACapability Runtime\uFF1Bmock provider \u5168\u5C40\u53EF\u7528\uFF0CLocal HTTP connector \u6309\u9879\u76EE\u9694\u79BB\u3002"
+  ];
+  for (const item of listCapabilities(context)) {
+    const connection = resolveCapabilityConnection(item, context);
+    lines.push(
+      sanitizeCapabilityDisplayText(
+        `- ${item.id}: availability=${formatCapabilityAvailability(item, connection)}; ${connection.status}; transport=${item.transport}; auth=${item.auth}; permission=${item.permission}; ${connection.summary}`
+      )
+    );
+  }
+  return lines.join("\n");
+}
+function formatCapabilityAvailability(definition, connection) {
+  if (connection.status === "unsupported") {
+    return "not_implemented/unsupported (not a usable capability)";
+  }
+  if (definition.transport === "mock") {
+    return "mock/demo (diagnostic only; not a real external capability)";
+  }
+  if (connection.status === "connected") {
+    return "real/connected";
+  }
+  if (connection.status === "needs_configuration") {
+    return "reserved/needs_configuration (not usable until configured)";
+  }
+  return "reserved/not_connected (not usable until connected)";
+}
+function registerCapabilityProvider(provider) {
+  providers.set(provider.transport, provider);
+}
+function setCapabilityConnectionResolver(resolver) {
+  externalConnectionResolver = resolver;
+}
+function formatCapabilityList(language = "zh-CN", context) {
+  const isEn = language === "en-US";
+  const lines = [isEn ? "Capabilities" : "Capabilities"];
+  for (const item of listCapabilities(context)) {
+    lines.push(sanitizeCapabilityDisplayText(`- ${item.title}: ${item.description}`));
+  }
+  lines.push(isEn ? "Details: /capabilities doctor" : "\u8BE6\u60C5\uFF1A/capabilities doctor");
+  return lines.join("\n");
+}
+function formatCapabilityResult(result, language = "zh-CN") {
+  const isEn = language === "en-US";
+  const summary = [
+    sanitizeCapabilityDisplayText(result.summary),
+    result.artifactRef ? isEn ? "Artifact ref recorded; use details to inspect it." : "Artifact ref \u5DF2\u8BB0\u5F55\uFF1B\u9700\u8981\u65F6\u770B details\u3002" : isEn ? "No artifact was created." : "\u672A\u521B\u5EFA artifact\u3002",
+    result.ok ? isEn ? "Capability execution is not verification PASS." : "Capability execution \u4E0D\u7B49\u4E8E\u9A8C\u8BC1\u901A\u8FC7\u3002" : isEn ? "Capability failed; failure is not verification PASS." : "Capability failed\uFF1B\u5931\u8D25\u4E0D\u7B49\u4E8E\u9A8C\u8BC1\u901A\u8FC7\u3002"
+  ];
+  const details = [
+    `capability: ${result.capabilityId}`,
+    `transport: ${result.metadata.transport}`,
+    `auth: ${result.metadata.auth}`,
+    `permission: ${result.metadata.permission}`,
+    `risk: ${result.metadata.riskLevel}`,
+    `connection: ${result.metadata.connectionStatus}`,
+    result.evidenceId ? `evidence: ${result.evidenceId}` : void 0,
+    result.artifactRef ? `artifact: ${result.artifactRef}` : void 0,
+    result.rollbackRef ? `rollbackRef: ${result.rollbackRef}` : void 0,
+    result.previewRef ? `previewRef: ${result.previewRef}` : void 0,
+    result.details
+  ].filter((line) => Boolean(line));
+  return { summary, detailsText: sanitizeCapabilityDisplayText(details.join("\n")) };
+}
+async function handleCapabilitiesCommand(args, context, output) {
+  const action = args[0] ?? "list";
+  if (action === "list") {
+    showCommandPanel(context, output, {
+      title: "/capabilities",
+      tone: "neutral",
+      summary: formatCapabilityList(context.language, context).split("\n"),
+      actions: ["/capabilities doctor", "/capabilities run <capabilityId> <json>"],
+      detailsText: listCapabilities(context).map(
+        (item) => sanitizeCapabilityDisplayText(
+          `${item.id}
+- app: ${item.appId}
+- transport: ${item.transport}
+- auth: ${item.auth}
+- permission: ${item.permission}
+- risk: ${item.riskLevel}`
+        )
+      ).join("\n\n")
+    });
+    return;
+  }
+  if (action === "doctor") {
+    showCommandPanel(context, output, {
+      title: "/capabilities doctor",
+      tone: "neutral",
+      summary: formatCapabilityDoctor(context.language, context).split("\n").slice(0, 6),
+      actions: ["/capabilities list", "/capabilities run <capabilityId> <json>"],
+      detailsText: formatCapabilityDoctor(context.language, context)
+    });
+    return;
+  }
+  if (action === "run") {
+    const capabilityId = args[1];
+    const json = args.slice(2).join(" ");
+    if (!capabilityId || !json) {
+      writeLine(output, "\u7528\u6CD5\uFF1A/capabilities run <capabilityId> <json>");
+      return;
+    }
+    const parsed = parseCapabilityInput(json);
+    if (!parsed.ok) {
+      writeLine(output, `Capability input JSON \u65E0\u6548\uFF1A${parsed.error}`);
+      return;
+    }
+    const result = await executeCapability(
+      { capabilityId, input: parsed.value, source: "slash" },
+      context
+    );
+    const formatted = formatCapabilityResult(result, context.language);
+    showCommandPanel(context, output, {
+      title: "/capabilities run",
+      tone: result.ok ? "neutral" : "warning",
+      summary: formatted.summary,
+      actions: ["/capabilities doctor", "/details evidence <id>"],
+      detailsText: formatted.detailsText
+    });
+    return;
+  }
+  writeLine(
+    output,
+    "\u7528\u6CD5\uFF1A/capabilities list | /capabilities doctor | /capabilities run <capabilityId> <json>"
+  );
+}
+function sanitizeCapabilityDisplayText(text) {
+  return sanitizeDiagnosticText(text).replace(
+    /(api[_-]?key|apiKey|token|Authorization)(\s*[:=]\s*)(Bearer\s+)?[^\s;&,)}\]]+/giu,
+    "$1$2***"
+  ).replace(/sk-[A-Za-z0-9_-]+/gu, "sk-***");
+}
+function parseCapabilityInput(json) {
+  try {
+    const value = JSON.parse(json);
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+      return { ok: false, error: "input must be a JSON object" };
+    }
+    return { ok: true, value };
+  } catch (error) {
+    return { ok: false, error: error instanceof Error ? error.message : String(error) };
+  }
+}
+function validateCapabilityInput(definition, input) {
+  const required = definition.inputSchema.required;
+  if (!Array.isArray(required)) return void 0;
+  for (const key of required) {
+    if (typeof key === "string" && !(key in input)) {
+      return `Missing required input: ${key}`;
+    }
+  }
+  return void 0;
+}
+async function checkCapabilityPermission(definition, request, context) {
+  const sessionId = await ensureSession(context);
+  const toolName = capabilityPermissionToolName(definition.permission);
+  return decidePermission(
+    toolName,
+    buildPermissionInput(definition, request.input, toolName),
+    context,
+    sessionId
+  );
+}
+function capabilityPermissionToolName(permission) {
+  if (permission === "read") return "Read";
+  if (permission === "bash") return "Bash";
+  if (permission === "network") return "Bash";
+  return "Write";
+}
+function buildPermissionInput(definition, input, toolName) {
+  if (toolName === "Read") {
+    return { path: definition.id };
+  }
+  if (toolName === "Bash") {
+    return {
+      command: definition.permission === "network" ? `capability network ${definition.id}` : `capability bash ${definition.id}`
+    };
+  }
+  return {
+    path: `.linghun/capabilities/${definition.id}.json`,
+    content: JSON.stringify({ capabilityId: definition.id, inputKeys: Object.keys(input) })
+  };
+}
+function buildFailedCapabilityResult(definition, summary, status) {
+  return {
+    ok: false,
+    capabilityId: definition.id,
+    summary,
+    metadata: {
+      transport: definition.transport,
+      auth: definition.auth,
+      permission: definition.permission,
+      riskLevel: definition.riskLevel,
+      connectionStatus: status
+    }
+  };
+}
+registerCapabilityProvider({
+  transport: "mock",
+  async execute(definition, request, context) {
+    if (definition.id === "mock.echo.read") {
+      const text = typeof request.input.text === "string" ? request.input.text : "";
+      return {
+        ok: true,
+        capabilityId: definition.id,
+        summary: `Echo ready: ${truncateDisplay(text.replace(/\s+/g, " "), 120)}`,
+        metadata: {
+          transport: definition.transport,
+          auth: definition.auth,
+          permission: definition.permission,
+          riskLevel: definition.riskLevel,
+          connectionStatus: "connected"
+        }
+      };
+    }
+    if (definition.id === "mock.canvas.create") {
+      const title = typeof request.input.title === "string" ? request.input.title : "Untitled";
+      return {
+        ok: true,
+        capabilityId: definition.id,
+        summary: `Canvas created: ${truncateDisplay(title, 80)}`,
+        previewRef: `mock-preview:${randomUUID()}`,
+        rollbackRef: `mock-rollback:${randomUUID()}`,
+        metadata: {
+          transport: definition.transport,
+          auth: definition.auth,
+          permission: definition.permission,
+          riskLevel: definition.riskLevel,
+          connectionStatus: "connected"
+        }
+      };
+    }
+    if (definition.id === "mock.canvas.export") {
+      const payload = `mock canvas export
+${"x".repeat(6e4)}`;
+      const sessionId = await ensureSession(context);
+      const budgeted = await budgetToolResultTranscriptContent(
+        context,
+        sessionId,
+        `capability-${definition.id}`,
+        payload
+      );
+      const artifact = context.evidence.find(
+        (item) => item.supportsClaims.includes(`toolUseId:capability-${definition.id}`)
+      );
+      return {
+        ok: true,
+        capabilityId: definition.id,
+        summary: typeof budgeted === "string" && budgeted.startsWith("<persisted-tool-result>") ? "Canvas export prepared; large output stored as artifact ref." : "Canvas export prepared.",
+        artifactRef: artifact?.fullOutputPath ?? artifact?.outputPath ?? "mock-artifact:canvas-export",
+        details: "Export payload is represented by summary plus artifact/ref only.",
+        metadata: {
+          transport: definition.transport,
+          auth: definition.auth,
+          permission: definition.permission,
+          riskLevel: definition.riskLevel,
+          connectionStatus: "connected"
+        }
+      };
+    }
+    return buildFailedCapabilityResult(
+      definition,
+      "Mock capability not implemented.",
+      "unsupported"
+    );
+  }
+});
+registerCapability({
+  id: "mock.echo.read",
+  appId: "mock.echo",
+  title: "Mock Echo Read",
+  description: "Read-only echo capability for runtime checks.",
+  category: "diagnostic",
+  intents: ["echo", "read capability", "capability smoke"],
+  keywords: ["echo", "read", "mock", "capability"],
+  transport: "mock",
+  auth: "none",
+  permission: "read",
+  riskLevel: "low",
+  inputSchema: { type: "object", required: ["text"] },
+  outputSchema: { type: "object", required: ["summary"] },
+  supportsRollback: false,
+  supportsPreview: false
+});
+registerCapability({
+  id: "mock.canvas.create",
+  appId: "mock.canvas",
+  title: "Mock Canvas Create",
+  description: "Simulates creating a canvas in an external app.",
+  category: "canvas",
+  intents: ["create canvas", "draw", "external app"],
+  keywords: ["canvas", "draw", "\u753B\u5E03", "\u753B\u56FE", "external app"],
+  transport: "mock",
+  auth: "none",
+  permission: "external_app",
+  riskLevel: "medium",
+  inputSchema: { type: "object", required: ["title"] },
+  outputSchema: { type: "object", required: ["summary"] },
+  supportsRollback: true,
+  supportsPreview: true
+});
+registerCapability({
+  id: "mock.canvas.export",
+  appId: "mock.canvas",
+  title: "Mock Canvas Export",
+  description: "Simulates exporting a canvas artifact ref.",
+  category: "canvas",
+  intents: ["export canvas", "artifact", "external app"],
+  keywords: ["canvas", "export", "artifact", "\u5BFC\u51FA", "\u753B\u5E03"],
+  transport: "mock",
+  auth: "none",
+  permission: "external_app",
+  riskLevel: "medium",
+  inputSchema: { type: "object", required: ["format"] },
+  outputSchema: { type: "object", required: ["summary", "artifactRef"] },
+  supportsRollback: false,
+  supportsPreview: false
+});
+
+export {
+  registerCapability,
+  unregisterCapabilitiesByApp,
+  listCapabilities,
+  findCapability,
+  resolveCapabilityConnection,
+  executeCapability,
+  formatCapabilityDoctor,
+  registerCapabilityProvider,
+  setCapabilityConnectionResolver,
+  formatCapabilityList,
+  formatCapabilityResult,
+  handleCapabilitiesCommand
+};