@linghun/tui 0.1.0

package/dist/chunk-JDWXC2OQ.js

@@ -0,0 +1,800 @@
+import {
+  executeCapability,
+  registerCapability,
+  registerCapabilityProvider,
+  setCapabilityConnectionResolver,
+  unregisterCapabilitiesByApp
+} from "./chunk-QB4VWH7W.js";
+import {
+  ensureSession,
+  showCommandPanel
+} from "./chunk-JO5ANTMR.js";
+import {
+  budgetToolResultTranscriptContent
+} from "./chunk-64MJP6FK.js";
+import {
+  truncateDisplay,
+  writeLine
+} from "./chunk-OMZYPQVA.js";
+
+// src/connector-runtime.ts
+import { randomUUID } from "crypto";
+import { readFile } from "fs/promises";
+import { basename, relative, resolve } from "path";
+var HTTP_TIMEOUT_MS = 5e3;
+var runtimeByProject = /* @__PURE__ */ new Map();
+function getRuntimeState(context) {
+  let state = runtimeByProject.get(context.projectPath);
+  if (!state) {
+    state = { apps: /* @__PURE__ */ new Map(), authConfigs: /* @__PURE__ */ new Map() };
+    runtimeByProject.set(context.projectPath, state);
+  }
+  return state;
+}
+function listAppConnectors(context) {
+  return [...getRuntimeState(context).apps.values()].sort((a, b) => a.appId.localeCompare(b.appId));
+}
+async function validateAppConnectorManifest(manifestPath, context) {
+  const localManifestPath = resolveProjectLocalManifestPath(manifestPath, context);
+  if (!localManifestPath.ok) return localManifestPath;
+  const manifest = await readConnectorManifest(localManifestPath.value);
+  if (!manifest.ok) return manifest;
+  const warnings = [];
+  if (manifest.value.transport !== "http") {
+    return {
+      ok: false,
+      error: `transport ${manifest.value.transport} is reserved; current App Bridge validate only supports Local HTTP.`
+    };
+  }
+  if (!manifest.value.baseUrl) {
+    return { ok: false, error: "HTTP connector requires baseUrl." };
+  }
+  const url = buildConnectorUrl(manifest.value.baseUrl, "");
+  if (!url.ok) return { ok: false, error: url.error };
+  const duplicateIds = findDuplicateCapabilityIds(manifest.value.capabilities);
+  if (duplicateIds.length > 0) {
+    return { ok: false, error: `duplicate capability id: ${duplicateIds.join(", ")}` };
+  }
+  const auth = resolveConnectorAuth(manifest.value.auth, context);
+  if (auth.type !== "none" && !auth.value) {
+    warnings.push(`auth ${auth.type} is not resolved yet; source=${auth.source}`);
+  }
+  return {
+    ok: true,
+    manifestPath: localManifestPath.value,
+    appId: manifest.value.appId,
+    name: manifest.value.name,
+    version: manifest.value.version,
+    transport: manifest.value.transport,
+    baseUrl: manifest.value.baseUrl,
+    capabilityCount: manifest.value.capabilities.length,
+    capabilityIds: manifest.value.capabilities.map((item) => item.id),
+    warnings
+  };
+}
+async function connectAppConnector(manifestPath, context) {
+  const localManifestPath = resolveProjectLocalManifestPath(manifestPath, context);
+  if (!localManifestPath.ok) return localManifestPath;
+  const manifest = await readConnectorManifest(localManifestPath.value);
+  if (!manifest.ok) return manifest;
+  const auth = resolveConnectorAuth(manifest.value.auth, context);
+  if (auth.type !== "none" && !auth.value) {
+    return { ok: false, error: `auth ${auth.type} is missing; source=${auth.source}` };
+  }
+  if (manifest.value.transport !== "http") {
+    return {
+      ok: false,
+      error: `transport ${manifest.value.transport} is reserved; Phase 7.15 only connects Local HTTP.`
+    };
+  }
+  if (!manifest.value.baseUrl) {
+    return { ok: false, error: "HTTP connector requires baseUrl." };
+  }
+  const remote = await fetchConnectorJson(
+    manifest.value.baseUrl,
+    "/linghun/capabilities",
+    "GET",
+    auth
+  );
+  if (!remote.ok) return { ok: false, error: remote.error };
+  const remoteCapabilities = parseRemoteCapabilities(remote.value, manifest.value);
+  if (!remoteCapabilities.ok) return { ok: false, error: remoteCapabilities.error };
+  const merged = mergeCapabilities(manifest.value.capabilities, remoteCapabilities.value);
+  const state = {
+    appId: manifest.value.appId,
+    name: manifest.value.name,
+    version: manifest.value.version,
+    manifestPath: localManifestPath.value,
+    transport: manifest.value.transport,
+    baseUrl: manifest.value.baseUrl,
+    auth: { type: auth.type, source: auth.source },
+    status: "connected",
+    capabilityIds: merged.map((item) => item.id),
+    connectedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  disconnectAppConnector(manifest.value.appId, context);
+  for (const capability of merged) {
+    registerCapability(
+      {
+        ...capability,
+        appId: manifest.value.appId,
+        transport: "http",
+        auth: manifest.value.auth.type
+      },
+      { projectPath: context.projectPath }
+    );
+  }
+  const runtime = getRuntimeState(context);
+  runtime.apps.set(manifest.value.appId, state);
+  runtime.authConfigs.set(manifest.value.appId, manifest.value.auth);
+  return { ok: true, state, capabilityCount: state.capabilityIds.length };
+}
+function disconnectAppConnector(appId, context) {
+  const state = getRuntimeState(context);
+  const existed = state.apps.delete(appId);
+  state.authConfigs.delete(appId);
+  unregisterCapabilitiesByApp(appId, { projectPath: context.projectPath });
+  return existed;
+}
+function formatAppConnectorList(context) {
+  const apps = listAppConnectors(context);
+  if (apps.length === 0) return "Apps\n- \u5C1A\u672A\u8FDE\u63A5 app\u3002";
+  return ["Apps", ...apps.map((app) => formatAppSummary(app))].join("\n");
+}
+function formatAppConnectorDoctor(context, language = "zh-CN") {
+  const apps = listAppConnectors(context);
+  const isEn = language === "en-US";
+  if (apps.length === 0) {
+    return isEn ? "Apps doctor\n- No app connected." : "Apps doctor\n- \u5C1A\u672A\u8FDE\u63A5 app\u3002";
+  }
+  return [
+    "Apps doctor",
+    ...apps.map(
+      (app) => `- ${sanitizeConnectorText(app.name)}: ${app.status}; transport=${app.transport}; auth=${app.auth.type}; authSource=${app.auth.source}; capabilities=${app.capabilityIds.length}`
+    ),
+    "",
+    "Details",
+    ...apps.map(
+      (app) => `- appId=${sanitizeConnectorText(app.appId)}; baseUrl=${redactBaseUrl(app.baseUrl)}; capabilities=${sanitizeConnectorText(app.capabilityIds.join(", "))}`
+    )
+  ].join("\n");
+}
+async function handleAppsCommand(args, context, output) {
+  const action = args[0] ?? "list";
+  if (action === "list") {
+    showCommandPanel(context, output, {
+      title: "/apps",
+      tone: "neutral",
+      summary: formatAppConnectorList(context).split("\n"),
+      actions: [
+        "/apps validate <manifestPath>",
+        "/apps connect <manifestPath>",
+        "/apps test-run <manifestPath> <capabilityId> <json>",
+        "/apps doctor",
+        "/apps disconnect <appId>"
+      ],
+      detailsText: formatAppConnectorList(context)
+    });
+    return;
+  }
+  if (action === "doctor") {
+    const body = formatAppConnectorDoctor(context, context.language);
+    showCommandPanel(context, output, {
+      title: "/apps doctor",
+      tone: "neutral",
+      summary: body.split("\n").filter((line) => line && line !== "Details" && !line.startsWith("- appId=")),
+      actions: [
+        "/apps list",
+        "/apps validate <manifestPath>",
+        "/apps test-run <manifestPath> <capabilityId> <json>",
+        "/apps disconnect <appId>"
+      ],
+      detailsText: body
+    });
+    return;
+  }
+  if (action === "validate") {
+    const manifestPath = args.slice(1).join(" ");
+    if (!manifestPath) {
+      writeLine(output, usageText("validate", context.language));
+      return;
+    }
+    const result = await validateAppConnectorManifest(manifestPath, context);
+    const formatted = formatAppConnectorValidation(result, context.language);
+    showCommandPanel(context, output, {
+      title: "/apps validate",
+      tone: result.ok ? "neutral" : "warning",
+      summary: formatted.summary,
+      actions: [
+        "/apps connect <manifestPath>",
+        "/apps test-run <manifestPath> <capabilityId> <json>"
+      ],
+      detailsText: formatted.detailsText
+    });
+    return;
+  }
+  if (action === "connect") {
+    const manifestPath = args.slice(1).join(" ");
+    if (!manifestPath) {
+      writeLine(output, "\u7528\u6CD5\uFF1A/apps connect <manifestPath>");
+      return;
+    }
+    const result = await connectAppConnector(manifestPath, context);
+    if (!result.ok) {
+      writeLine(output, `App connect \u5931\u8D25\uFF1A${sanitizeConnectorText(result.error)}`);
+      return;
+    }
+    writeLine(
+      output,
+      `\u5DF2\u8FDE\u63A5 ${sanitizeConnectorText(result.state.name)}\uFF1B\u6CE8\u518C capability ${result.capabilityCount} \u4E2A\uFF1B\u5199\u5165/\u5916\u90E8 app \u64CD\u4F5C\u4F1A\u8D70\u6743\u9650\u786E\u8BA4\u3002`
+    );
+    return;
+  }
+  if (action === "test-run") {
+    const manifestPath = args[1];
+    const capabilityId = args[2];
+    const json = args.slice(3).join(" ");
+    if (!manifestPath || !capabilityId || !json) {
+      writeLine(output, usageText("test-run", context.language));
+      return;
+    }
+    const parsed = parseJsonInput(json);
+    if (!parsed.ok) {
+      writeLine(
+        output,
+        localizedLine(
+          context.language,
+          "App test-run input JSON invalid",
+          "App test-run input JSON \u65E0\u6548",
+          parsed.error
+        )
+      );
+      return;
+    }
+    const connection = await connectAppConnector(manifestPath, context);
+    if (!connection.ok) {
+      writeLine(
+        output,
+        localizedLine(
+          context.language,
+          "App test-run connect failed",
+          "App test-run \u8FDE\u63A5\u5931\u8D25",
+          sanitizeConnectorText(connection.error)
+        )
+      );
+      return;
+    }
+    const definition = connection.state.capabilityIds.includes(capabilityId);
+    if (!definition) {
+      writeLine(
+        output,
+        localizedLine(
+          context.language,
+          "App test-run capability not found",
+          "App test-run \u672A\u627E\u5230 capability",
+          sanitizeConnectorText(capabilityId)
+        )
+      );
+      return;
+    }
+    const result = await executeCapability(
+      { capabilityId, input: parsed.value, source: "slash" },
+      context
+    );
+    const lines = context.language === "en-US" ? [
+      `Connected ${sanitizeConnectorText(connection.state.name)} and executed ${sanitizeConnectorText(capabilityId)}.`,
+      `Result: ${result.ok ? "ok" : "failed"}.`,
+      `Summary: ${sanitizeConnectorText(result.summary)}`,
+      "The app remains connected for follow-up /capabilities run or /apps disconnect."
+    ] : [
+      `\u5DF2\u8FDE\u63A5 ${sanitizeConnectorText(connection.state.name)} \u5E76\u6267\u884C ${sanitizeConnectorText(capabilityId)}\u3002`,
+      `\u7ED3\u679C\uFF1A${result.ok ? "ok" : "failed"}\u3002`,
+      `\u6458\u8981\uFF1A${sanitizeConnectorText(result.summary)}`,
+      "app \u4FDD\u6301 connected\uFF0C\u53EF\u7EE7\u7EED /capabilities run \u6216 /apps disconnect\u3002"
+    ];
+    showCommandPanel(context, output, {
+      title: "/apps test-run",
+      tone: result.ok ? "neutral" : "warning",
+      summary: lines,
+      actions: ["/capabilities run <capabilityId> <json>", "/apps disconnect <appId>"],
+      detailsText: [
+        ...lines,
+        "",
+        `details: ${sanitizeConnectorText(result.details ?? "none")}`,
+        result.artifactRef ? `artifactRef: ${sanitizeConnectorText(result.artifactRef)}` : void 0,
+        result.previewRef ? `previewRef: ${sanitizeConnectorText(result.previewRef)}` : void 0,
+        result.rollbackRef ? `rollbackRef: ${sanitizeConnectorText(result.rollbackRef)}` : void 0
+      ].filter((line) => Boolean(line)).join("\n")
+    });
+    return;
+  }
+  if (action === "disconnect") {
+    const appId = args[1];
+    if (!appId) {
+      writeLine(output, "\u7528\u6CD5\uFF1A/apps disconnect <appId>");
+      return;
+    }
+    const removed = disconnectAppConnector(appId, context);
+    writeLine(output, removed ? `\u5DF2\u65AD\u5F00 ${appId}\u3002` : `\u672A\u627E\u5230\u5DF2\u8FDE\u63A5 app\uFF1A${appId}`);
+    return;
+  }
+  writeLine(
+    output,
+    context.language === "en-US" ? "Usage: /apps list | /apps validate <manifestPath> | /apps connect <manifestPath> | /apps test-run <manifestPath> <capabilityId> <json> | /apps doctor | /apps disconnect <appId>" : "\u7528\u6CD5\uFF1A/apps list | /apps validate <manifestPath> | /apps connect <manifestPath> | /apps test-run <manifestPath> <capabilityId> <json> | /apps doctor | /apps disconnect <appId>"
+  );
+}
+function formatAppConnectorValidation(result, language) {
+  if (!result.ok) {
+    const line = language === "en-US" ? `Manifest validation failed: ${sanitizeConnectorText(result.error)}` : `Manifest \u6821\u9A8C\u5931\u8D25\uFF1A${sanitizeConnectorText(result.error)}`;
+    return { summary: [line], detailsText: line };
+  }
+  const warningLines = result.warnings.map(
+    (warning) => language === "en-US" ? `warning: ${sanitizeConnectorText(warning)}` : `\u8B66\u544A\uFF1A${sanitizeConnectorText(warning)}`
+  );
+  const summary = language === "en-US" ? [
+    `Manifest valid: ${sanitizeConnectorText(result.name)} (${sanitizeConnectorText(result.appId)}).`,
+    `transport=${result.transport}; capabilities=${result.capabilityCount}`,
+    ...warningLines
+  ] : [
+    `Manifest \u6709\u6548\uFF1A${sanitizeConnectorText(result.name)}\uFF08${sanitizeConnectorText(result.appId)}\uFF09\u3002`,
+    `transport=${result.transport}\uFF1Bcapabilities=${result.capabilityCount}`,
+    ...warningLines
+  ];
+  const details = [
+    ...summary,
+    "",
+    `manifestPath=${sanitizeConnectorText(result.manifestPath)}`,
+    `version=${sanitizeConnectorText(result.version)}`,
+    `baseUrl=${redactBaseUrl(result.baseUrl)}`,
+    `capabilityIds=${sanitizeConnectorText(result.capabilityIds.join(", "))}`
+  ];
+  return { summary, detailsText: details.join("\n") };
+}
+function usageText(action, language) {
+  if (action === "validate") {
+    return language === "en-US" ? "Usage: /apps validate <manifestPath>" : "\u7528\u6CD5\uFF1A/apps validate <manifestPath>";
+  }
+  return language === "en-US" ? "Usage: /apps test-run <manifestPath> <capabilityId> <json>" : "\u7528\u6CD5\uFF1A/apps test-run <manifestPath> <capabilityId> <json>";
+}
+function parseJsonInput(json) {
+  try {
+    const parsed = JSON.parse(json);
+    if (!isRecord(parsed)) return { ok: false, error: "input must be a JSON object." };
+    return { ok: true, value: parsed };
+  } catch (error) {
+    return { ok: false, error: formatUnknownError(error) };
+  }
+}
+function localizedLine(language, enPrefix, zhPrefix, detail) {
+  return language === "en-US" ? `${enPrefix}: ${sanitizeConnectorText(detail)}` : `${zhPrefix}\uFF1A${sanitizeConnectorText(detail)}`;
+}
+function resolveProjectLocalManifestPath(manifestPath, context) {
+  const projectRoot = resolve(context.projectPath);
+  const resolved = resolve(projectRoot, manifestPath);
+  const rel = relative(projectRoot, resolved);
+  if (rel === "" || rel.startsWith("..") || resolve(rel) === rel) {
+    return { ok: false, error: "connector manifest must be inside the current project." };
+  }
+  return { ok: true, value: resolved };
+}
+async function readConnectorManifest(manifestPath) {
+  let raw = "";
+  try {
+    raw = await readFile(manifestPath, "utf8");
+  } catch (error) {
+    return { ok: false, error: `cannot read manifest: ${formatUnknownError(error)}` };
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (error) {
+    return { ok: false, error: `manifest JSON invalid: ${formatUnknownError(error)}` };
+  }
+  return parseConnectorManifest(parsed);
+}
+function parseConnectorManifest(input) {
+  if (!isRecord(input)) return { ok: false, error: "manifest must be an object." };
+  const appId = readNonEmptyString(input, "appId");
+  const name = readNonEmptyString(input, "name");
+  const version = readNonEmptyString(input, "version");
+  const transport = readNonEmptyString(input, "transport");
+  const auth = parseAuthConfig(input.auth);
+  if (!appId.ok) return appId;
+  if (!name.ok) return name;
+  if (!version.ok) return version;
+  if (!transport.ok) return transport;
+  if (!isCapabilityTransport(transport.value)) return { ok: false, error: "transport is invalid." };
+  if (!auth.ok) return auth;
+  const baseUrl = input.baseUrl === void 0 ? void 0 : readNonEmptyString(input, "baseUrl");
+  if (baseUrl && !baseUrl.ok) return baseUrl;
+  if (!Array.isArray(input.capabilities)) {
+    return { ok: false, error: "capabilities must be an array." };
+  }
+  const capabilities = [];
+  for (const item of input.capabilities) {
+    const parsed = parseCapabilityDefinition(item, appId.value, transport.value, auth.value.type);
+    if (!parsed.ok) return parsed;
+    capabilities.push(parsed.value);
+  }
+  if (capabilities.length === 0) {
+    return { ok: false, error: "capabilities must contain at least one capability." };
+  }
+  return {
+    ok: true,
+    value: {
+      appId: appId.value,
+      name: name.value,
+      version: version.value,
+      transport: transport.value,
+      baseUrl: baseUrl?.value,
+      auth: auth.value,
+      capabilities
+    }
+  };
+}
+function parseAuthConfig(input) {
+  if (!isRecord(input)) return { ok: false, error: "auth must be an object." };
+  const type = input.type;
+  if (type === "none") return { ok: true, value: { type } };
+  if (type !== "api_key" && type !== "local_token") {
+    return { ok: false, error: "auth.type is invalid." };
+  }
+  const config = { type };
+  for (const key of ["env", "projectConfigRef", "userConfigRef", "valueRef"]) {
+    const value = input[key];
+    if (value === void 0) continue;
+    if (typeof value !== "string" || value.trim().length === 0) {
+      return { ok: false, error: `auth.${key} must be a non-empty string.` };
+    }
+    config[key] = value.trim();
+  }
+  if (looksLikeRawSecret(input.value)) {
+    return {
+      ok: false,
+      error: "auth.value is not allowed; use env/projectConfigRef/userConfigRef."
+    };
+  }
+  return { ok: true, value: config };
+}
+function parseCapabilityDefinition(input, appId, transport, auth) {
+  if (!isRecord(input)) return { ok: false, error: "capability must be an object." };
+  const id = readNonEmptyString(input, "id");
+  const title = readNonEmptyString(input, "title");
+  const description = readNonEmptyString(input, "description");
+  const category = readNonEmptyString(input, "category");
+  const permission = input.permission;
+  const riskLevel = input.riskLevel;
+  if (!id.ok) return id;
+  if (!title.ok) return title;
+  if (!description.ok) return description;
+  if (!category.ok) return category;
+  if (!isCapabilityPermission(permission))
+    return { ok: false, error: "capability.permission is invalid." };
+  if (riskLevel !== "low" && riskLevel !== "medium" && riskLevel !== "high") {
+    return { ok: false, error: "capability.riskLevel is invalid." };
+  }
+  return {
+    ok: true,
+    value: {
+      id: id.value,
+      appId,
+      title: title.value,
+      description: description.value,
+      category: category.value,
+      intents: readStringArray(input.intents),
+      keywords: readStringArray(input.keywords),
+      transport,
+      auth,
+      permission,
+      riskLevel,
+      inputSchema: isRecord(input.inputSchema) ? input.inputSchema : { type: "object" },
+      outputSchema: isRecord(input.outputSchema) ? input.outputSchema : { type: "object" },
+      supportsRollback: input.supportsRollback === true,
+      supportsPreview: input.supportsPreview === true
+    }
+  };
+}
+function resolveConnectorAuth(auth, context) {
+  if (auth.type === "none") return { type: "none", source: "none" };
+  if (auth.env) {
+    const value = process.env[auth.env];
+    if (value) return { type: auth.type, source: "shell-env", value };
+  }
+  if (auth.projectConfigRef) {
+    const value = readConfigRef(context.config, auth.projectConfigRef);
+    if (value) return { type: auth.type, source: "project-config-ref", value };
+  }
+  if (auth.userConfigRef) {
+    const value = readConfigRef(context.config, auth.userConfigRef);
+    if (value) return { type: auth.type, source: "user-config-ref", value };
+  }
+  if (auth.valueRef) {
+    const value = readValueRef(auth.valueRef, context);
+    if (value) return { type: auth.type, source: "manifest-ref", value };
+  }
+  return { type: auth.type, source: "missing" };
+}
+function readValueRef(ref, context) {
+  if (ref.startsWith("env:")) {
+    return process.env[ref.slice("env:".length)];
+  }
+  if (ref.startsWith("settings.")) {
+    return readConfigRef(context.config, ref);
+  }
+  return void 0;
+}
+function readConfigRef(config, ref) {
+  if (!ref.startsWith("settings.")) return void 0;
+  let cursor = config;
+  for (const part of ref.slice("settings.".length).split(".")) {
+    if (!isRecord(cursor)) return void 0;
+    cursor = cursor[part];
+  }
+  return typeof cursor === "string" && cursor ? cursor : void 0;
+}
+async function fetchConnectorJson(baseUrl, path, method, auth, body) {
+  const url = buildConnectorUrl(baseUrl, path);
+  if (!url.ok) return url;
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), HTTP_TIMEOUT_MS);
+  try {
+    const headers = { accept: "application/json" };
+    if (method === "POST") headers["content-type"] = "application/json";
+    if (auth.value) headers.authorization = `Bearer ${auth.value}`;
+    const response = await fetch(url.value, {
+      method,
+      headers,
+      body: body === void 0 ? void 0 : JSON.stringify(body),
+      signal: controller.signal
+    });
+    const text = await response.text();
+    if (!response.ok) {
+      return {
+        ok: false,
+        error: `HTTP ${response.status} from connector ${safeUrlLabel(url.value)}`
+      };
+    }
+    try {
+      return { ok: true, value: text ? JSON.parse(text) : {} };
+    } catch {
+      return { ok: false, error: "connector response is not valid JSON." };
+    }
+  } catch (error) {
+    return { ok: false, error: `connector unreachable: ${formatUnknownError(error)}` };
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+function buildConnectorUrl(baseUrl, path) {
+  let url;
+  try {
+    url = new URL(baseUrl);
+  } catch {
+    return { ok: false, error: "baseUrl is invalid." };
+  }
+  if (url.protocol !== "http:") {
+    return { ok: false, error: "Phase 7.15 Local HTTP connector only supports http:// baseUrl." };
+  }
+  if (url.username || url.password) {
+    return { ok: false, error: "baseUrl must not contain username/password." };
+  }
+  if (!isLocalHost(url.hostname)) {
+    return { ok: false, error: "Local HTTP connector requires localhost/127.0.0.1/[::1]." };
+  }
+  url.pathname = `${url.pathname.replace(/\/$/, "")}${path}`;
+  url.search = "";
+  url.hash = "";
+  return { ok: true, value: url.toString() };
+}
+function parseRemoteCapabilities(input, manifest) {
+  const raw = isRecord(input) && Array.isArray(input.capabilities) ? input.capabilities : input;
+  if (!Array.isArray(raw)) return { ok: false, error: "remote capabilities response is invalid." };
+  const capabilities = [];
+  for (const item of raw) {
+    const parsed = parseCapabilityDefinition(item, manifest.appId, "http", manifest.auth.type);
+    if (!parsed.ok) return parsed;
+    capabilities.push(parsed.value);
+  }
+  return { ok: true, value: capabilities };
+}
+function mergeCapabilities(manifestCapabilities, remoteCapabilities) {
+  const byId = /* @__PURE__ */ new Map();
+  for (const capability of manifestCapabilities) byId.set(capability.id, capability);
+  for (const capability of remoteCapabilities) {
+    byId.set(capability.id, { ...byId.get(capability.id), ...capability });
+  }
+  return [...byId.values()].sort((a, b) => a.id.localeCompare(b.id));
+}
+function findDuplicateCapabilityIds(capabilities) {
+  const seen = /* @__PURE__ */ new Set();
+  const duplicate = /* @__PURE__ */ new Set();
+  for (const capability of capabilities) {
+    if (seen.has(capability.id)) {
+      duplicate.add(capability.id);
+      continue;
+    }
+    seen.add(capability.id);
+  }
+  return [...duplicate].sort((a, b) => a.localeCompare(b));
+}
+async function executeHttpCapability(definition, request, context) {
+  const app = getRuntimeState(context).apps.get(definition.appId);
+  if (!app || app.status !== "connected" || !app.baseUrl) {
+    return buildConnectorExecutionResult(definition, "Connector is not connected.", false);
+  }
+  const auth = resolveConnectorAuthForState(app, context);
+  if (auth.type !== "none" && !auth.value) {
+    return buildConnectorExecutionResult(
+      definition,
+      `Connector auth missing; source=${auth.source}.`,
+      false
+    );
+  }
+  const response = await fetchConnectorJson(app.baseUrl, "/linghun/execute", "POST", auth, {
+    capabilityId: definition.id,
+    input: request.input,
+    metadata: {
+      requestId: randomUUID(),
+      source: request.source,
+      appId: definition.appId
+    }
+  });
+  if (!response.ok) return buildConnectorExecutionResult(definition, response.error, false);
+  return normalizeHttpExecutionResult(definition, response.value, context);
+}
+function resolveConnectorAuthForState(app, context) {
+  if (app.auth.type === "none") return { type: "none", source: "none" };
+  const manifestAuth = getRuntimeState(context).authConfigs.get(app.appId);
+  return resolveConnectorAuth(manifestAuth ?? { type: app.auth.type }, context);
+}
+async function normalizeHttpExecutionResult(definition, input, context) {
+  if (!isRecord(input)) {
+    return buildConnectorExecutionResult(
+      definition,
+      "Connector execute response is invalid.",
+      false
+    );
+  }
+  const ok = input.ok !== false;
+  const summary = typeof input.summary === "string" && input.summary.trim() ? truncateDisplay(sanitizeConnectorText(input.summary), 240) : ok ? "HTTP capability succeeded." : "HTTP capability failed.";
+  const sessionId = await ensureSession(context);
+  const artifactRef = await resolveConnectorArtifactRef(definition, input, context, sessionId);
+  return {
+    ok,
+    capabilityId: definition.id,
+    summary,
+    details: typeof input.details === "string" ? truncateDisplay(sanitizeConnectorText(input.details), 1e3) : "Connector response normalized; raw response omitted.",
+    artifactRef,
+    rollbackRef: typeof input.rollbackRef === "string" ? input.rollbackRef : void 0,
+    previewRef: typeof input.previewRef === "string" ? input.previewRef : void 0,
+    metadata: {
+      transport: definition.transport,
+      auth: definition.auth,
+      permission: definition.permission,
+      riskLevel: definition.riskLevel,
+      connectionStatus: "connected"
+    }
+  };
+}
+async function resolveConnectorArtifactRef(definition, response, context, sessionId) {
+  if (typeof response.artifactRef === "string" && response.artifactRef.trim()) {
+    return response.artifactRef;
+  }
+  const rawOutput = response.output ?? response.result ?? response.data;
+  if (rawOutput === void 0) return void 0;
+  const text = stringifyForBudget(rawOutput);
+  if (!text) return void 0;
+  const budgeted = await budgetToolResultTranscriptContent(
+    context,
+    sessionId,
+    `connector-${definition.id}`,
+    text
+  );
+  if (typeof budgeted !== "string" || !budgeted.startsWith("<persisted-tool-result>")) {
+    return void 0;
+  }
+  const artifact = context.evidence.find(
+    (item) => item.supportsClaims.includes(`toolUseId:connector-${definition.id}`)
+  );
+  return artifact?.fullOutputPath ?? artifact?.outputPath;
+}
+function buildConnectorExecutionResult(definition, summary, ok) {
+  return {
+    ok,
+    capabilityId: definition.id,
+    summary: sanitizeConnectorText(summary),
+    metadata: {
+      transport: definition.transport,
+      auth: definition.auth,
+      permission: definition.permission,
+      riskLevel: definition.riskLevel,
+      connectionStatus: ok ? "connected" : "not_connected"
+    }
+  };
+}
+function formatAppSummary(app) {
+  return `- ${sanitizeConnectorText(app.name)}: ${app.status}; transport=${app.transport}; capabilities=${app.capabilityIds.length}`;
+}
+function isRecord(input) {
+  return Boolean(input && typeof input === "object" && !Array.isArray(input));
+}
+function readNonEmptyString(input, key) {
+  const value = input[key];
+  if (typeof value !== "string" || value.trim().length === 0) {
+    return { ok: false, error: `${key} must be a non-empty string.` };
+  }
+  return { ok: true, value: value.trim() };
+}
+function readStringArray(input) {
+  if (!Array.isArray(input)) return [];
+  return input.filter((item) => typeof item === "string" && item.trim().length > 0);
+}
+function isCapabilityTransport(input) {
+  return input === "mock" || input === "mcp" || input === "plugin" || input === "desktop_bridge" || input === "http" || input === "websocket";
+}
+function isCapabilityPermission(input) {
+  return input === "read" || input === "write" || input === "bash" || input === "network" || input === "external_app";
+}
+function isLocalHost(hostname) {
+  return hostname === "localhost" || hostname === "127.0.0.1" || hostname === "::1" || hostname === "[::1]";
+}
+function looksLikeRawSecret(input) {
+  return typeof input === "string" && input.trim().length > 0;
+}
+function stringifyForBudget(input) {
+  if (typeof input === "string") return input;
+  try {
+    return JSON.stringify(input);
+  } catch {
+    return void 0;
+  }
+}
+function sanitizeConnectorText(input) {
+  return input.replace(
+    /(api[_-]?key|apiKey|token|Authorization)(\s*[:=]\s*)(Bearer\s+)?[^\s;&,)}\]]+/giu,
+    "$1$2***"
+  ).replace(/Bearer\s+[A-Za-z0-9._~-]+/giu, "Bearer ***").replace(/sk-[A-Za-z0-9_-]+/gu, "sk-***");
+}
+function redactBaseUrl(baseUrl) {
+  if (!baseUrl) return "none";
+  const parsed = buildConnectorUrl(baseUrl, "");
+  if (!parsed.ok) return "invalid";
+  const url = new URL(parsed.value);
+  return `${url.protocol}//${url.hostname}${url.port ? `:${url.port}` : ""}/...`;
+}
+function safeUrlLabel(url) {
+  try {
+    const parsed = new URL(url);
+    return `${parsed.protocol}//${parsed.hostname}${parsed.port ? `:${parsed.port}` : ""}/${basename(parsed.pathname)}`;
+  } catch {
+    return "invalid-url";
+  }
+}
+function formatUnknownError(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+registerCapabilityProvider({
+  transport: "http",
+  execute: executeHttpCapability
+});
+setCapabilityConnectionResolver((definition, context) => {
+  if (definition.transport !== "http" || !context) return void 0;
+  const app = getRuntimeState(context).apps.get(definition.appId);
+  if (!app) return void 0;
+  return {
+    capabilityId: definition.id,
+    transport: "http",
+    status: app.status === "connected" ? "connected" : "not_connected",
+    summary: app.status === "connected" ? `connected app ${app.name}` : "connector disconnected"
+  };
+});
+
+export {
+  listAppConnectors,
+  validateAppConnectorManifest,
+  connectAppConnector,
+  disconnectAppConnector,
+  formatAppConnectorList,
+  formatAppConnectorDoctor,
+  handleAppsCommand
+};