@zyycn/claudex 1.0.3-fork.0cb3e59

package/dist/chunk-5j35ewt6.js

@@ -0,0 +1,277 @@
+// @bun
+import {
+  normalizeControlMessageKeys
+} from "./chunk-nt837qt9.js";
+import {
+  EMPTY_USAGE,
+  init_emptyUsage
+} from "./chunk-czvztj44.js";
+import {
+  init_analytics,
+  logEvent
+} from "./chunk-h0rbjg6x.js";
+import {
+  init_displayTags,
+  stripDisplayTagsAllowEmpty
+} from "./chunk-yysj6sxt.js";
+import {
+  errorMessage,
+  init_debug,
+  init_errors,
+  init_slowOperations,
+  jsonParse,
+  logForDebugging
+} from "./chunk-sbbj6ta3.js";
+
+// src/bridge/bridgeMessaging.ts
+init_analytics();
+init_emptyUsage();
+import { randomUUID } from "crypto";
+init_debug();
+init_displayTags();
+init_errors();
+init_slowOperations();
+function isSDKMessage(value) {
+  return value !== null && typeof value === "object" && "type" in value && typeof value.type === "string";
+}
+function isSDKControlResponse(value) {
+  return value !== null && typeof value === "object" && "type" in value && value.type === "control_response" && "response" in value;
+}
+function isSDKControlRequest(value) {
+  return value !== null && typeof value === "object" && "type" in value && value.type === "control_request" && "request_id" in value && "request" in value;
+}
+function isEligibleBridgeMessage(m) {
+  if ((m.type === "user" || m.type === "assistant") && m.isVirtual) {
+    return false;
+  }
+  return m.type === "user" || m.type === "assistant" || m.type === "system" && m.subtype === "local_command";
+}
+function extractTitleText(m) {
+  if (m.type !== "user" || m.isMeta || m.toolUseResult || m.isCompactSummary)
+    return;
+  if (m.origin && m.origin.kind !== "human")
+    return;
+  const content = m.message.content;
+  let raw;
+  if (typeof content === "string") {
+    raw = content;
+  } else {
+    for (const block of content) {
+      if (block.type === "text") {
+        raw = block.text;
+        break;
+      }
+    }
+  }
+  if (!raw)
+    return;
+  const clean = stripDisplayTagsAllowEmpty(raw);
+  return clean || undefined;
+}
+function handleIngressMessage(data, recentPostedUUIDs, recentInboundUUIDs, onInboundMessage, onPermissionResponse, onControlRequest) {
+  try {
+    const parsed = normalizeControlMessageKeys(jsonParse(data));
+    if (isSDKControlResponse(parsed)) {
+      logForDebugging("[bridge:repl] Ingress message type=control_response");
+      onPermissionResponse?.(parsed);
+      return;
+    }
+    if (isSDKControlRequest(parsed)) {
+      logForDebugging(`[bridge:repl] Inbound control_request subtype=${parsed.request.subtype}`);
+      onControlRequest?.(parsed);
+      return;
+    }
+    if (!isSDKMessage(parsed))
+      return;
+    const uuid = "uuid" in parsed && typeof parsed.uuid === "string" ? parsed.uuid : undefined;
+    if (uuid && recentPostedUUIDs.has(uuid)) {
+      logForDebugging(`[bridge:repl] Ignoring echo: type=${parsed.type} uuid=${uuid}`);
+      return;
+    }
+    if (uuid && recentInboundUUIDs.has(uuid)) {
+      logForDebugging(`[bridge:repl] Ignoring re-delivered inbound: type=${parsed.type} uuid=${uuid}`);
+      return;
+    }
+    logForDebugging(`[bridge:repl] Ingress message type=${parsed.type}${uuid ? ` uuid=${uuid}` : ""}`);
+    if (parsed.type === "user") {
+      if (uuid)
+        recentInboundUUIDs.add(uuid);
+      logEvent("tengu_bridge_message_received", {
+        is_repl: true
+      });
+      onInboundMessage?.(parsed);
+    } else {
+      logForDebugging(`[bridge:repl] Ignoring non-user inbound message: type=${parsed.type}`);
+    }
+  } catch (err) {
+    logForDebugging(`[bridge:repl] Failed to parse ingress message: ${errorMessage(err)}`);
+  }
+}
+var OUTBOUND_ONLY_ERROR = "This session is outbound-only. Enable Remote Control locally to allow inbound control.";
+function handleServerControlRequest(request, handlers) {
+  const {
+    transport,
+    sessionId,
+    outboundOnly,
+    onInterrupt,
+    onSetModel,
+    onSetMaxThinkingTokens,
+    onSetPermissionMode
+  } = handlers;
+  if (!transport) {
+    logForDebugging("[bridge:repl] Cannot respond to control_request: transport not configured");
+    return;
+  }
+  let response;
+  const req = request.request;
+  if (outboundOnly && req.subtype !== "initialize") {
+    response = {
+      type: "control_response",
+      response: {
+        subtype: "error",
+        request_id: request.request_id,
+        error: OUTBOUND_ONLY_ERROR
+      }
+    };
+    const event2 = { ...response, session_id: sessionId };
+    transport.write(event2);
+    logForDebugging(`[bridge:repl] Rejected ${req.subtype} (outbound-only) request_id=${request.request_id}`);
+    return;
+  }
+  switch (req.subtype) {
+    case "initialize":
+      response = {
+        type: "control_response",
+        response: {
+          subtype: "success",
+          request_id: request.request_id,
+          response: {
+            commands: [],
+            output_style: "normal",
+            available_output_styles: ["normal"],
+            models: [],
+            account: {},
+            pid: process.pid
+          }
+        }
+      };
+      break;
+    case "set_model":
+      onSetModel?.(req.model);
+      response = {
+        type: "control_response",
+        response: {
+          subtype: "success",
+          request_id: request.request_id
+        }
+      };
+      break;
+    case "set_max_thinking_tokens":
+      onSetMaxThinkingTokens?.(req.max_thinking_tokens ?? null);
+      response = {
+        type: "control_response",
+        response: {
+          subtype: "success",
+          request_id: request.request_id
+        }
+      };
+      break;
+    case "set_permission_mode": {
+      const verdict = onSetPermissionMode?.(req.mode) ?? {
+        ok: false,
+        error: "set_permission_mode is not supported in this context (onSetPermissionMode callback not registered)"
+      };
+      if (verdict.ok) {
+        response = {
+          type: "control_response",
+          response: {
+            subtype: "success",
+            request_id: request.request_id
+          }
+        };
+      } else {
+        response = {
+          type: "control_response",
+          response: {
+            subtype: "error",
+            request_id: request.request_id,
+            error: verdict.error
+          }
+        };
+      }
+      break;
+    }
+    case "interrupt":
+      onInterrupt?.();
+      response = {
+        type: "control_response",
+        response: {
+          subtype: "success",
+          request_id: request.request_id
+        }
+      };
+      break;
+    default:
+      response = {
+        type: "control_response",
+        response: {
+          subtype: "error",
+          request_id: request.request_id,
+          error: `REPL bridge does not handle control_request subtype: ${req.subtype}`
+        }
+      };
+  }
+  const event = { ...response, session_id: sessionId };
+  transport.write(event);
+  logForDebugging(`[bridge:repl] Sent control_response for ${req.subtype} request_id=${request.request_id} result=${response.response.subtype}`);
+}
+function makeResultMessage(sessionId) {
+  return {
+    type: "result_success",
+    subtype: "success",
+    duration_ms: 0,
+    duration_api_ms: 0,
+    is_error: false,
+    num_turns: 0,
+    result: "",
+    stop_reason: null,
+    total_cost_usd: 0,
+    usage: { ...EMPTY_USAGE },
+    modelUsage: {},
+    permission_denials: [],
+    session_id: sessionId,
+    uuid: randomUUID()
+  };
+}
+
+class BoundedUUIDSet {
+  capacity;
+  ring;
+  set = new Set;
+  writeIdx = 0;
+  constructor(capacity) {
+    this.capacity = capacity;
+    this.ring = new Array(capacity);
+  }
+  add(uuid) {
+    if (this.set.has(uuid))
+      return;
+    const evicted = this.ring[this.writeIdx];
+    if (evicted !== undefined) {
+      this.set.delete(evicted);
+    }
+    this.ring[this.writeIdx] = uuid;
+    this.set.add(uuid);
+    this.writeIdx = (this.writeIdx + 1) % this.capacity;
+  }
+  has(uuid) {
+    return this.set.has(uuid);
+  }
+  clear() {
+    this.set.clear();
+    this.ring.fill(undefined);
+    this.writeIdx = 0;
+  }
+}
+
+export { isEligibleBridgeMessage, extractTitleText, handleIngressMessage, handleServerControlRequest, makeResultMessage, BoundedUUIDSet };

package/dist/chunk-5wrm5rwf.js

@@ -0,0 +1,202 @@
+// @bun
+import {
+  disableAllPluginsOp,
+  disablePluginOp,
+  enablePluginOp,
+  init_pluginOperations,
+  installPluginOp,
+  uninstallPluginOp,
+  updatePluginOp
+} from "./chunk-1bwnpgmv.js";
+import {
+  buildPluginTelemetryFields,
+  classifyPluginCommandError,
+  getManagedPluginNames,
+  gracefulShutdown,
+  init_gracefulShutdown,
+  init_managedPlugins,
+  init_pluginIdentifier,
+  init_pluginTelemetry,
+  parsePluginIdentifier
+} from "./chunk-5eecpt8g.js";
+import {
+  init_analytics,
+  logEvent
+} from "./chunk-h0rbjg6x.js";
+import {
+  figures_default,
+  init_figures
+} from "./chunk-gzzfhtdv.js";
+import {
+  init_log,
+  logError
+} from "./chunk-yysj6sxt.js";
+import {
+  errorMessage,
+  init_errors
+} from "./chunk-sbbj6ta3.js";
+import {
+  init_process,
+  writeToStdout
+} from "./chunk-fbv4apne.js";
+
+// src/services/plugins/pluginCliCommands.ts
+init_figures();
+init_errors();
+init_gracefulShutdown();
+init_log();
+init_managedPlugins();
+init_pluginIdentifier();
+init_process();
+init_pluginTelemetry();
+init_analytics();
+init_pluginOperations();
+function handlePluginCommandError(error, command, plugin) {
+  logError(error);
+  const operation = plugin ? `${command} plugin "${plugin}"` : command === "disable-all" ? "disable all plugins" : `${command} plugins`;
+  console.error(`${figures_default.cross} Failed to ${operation}: ${errorMessage(error)}`);
+  const telemetryFields = plugin ? (() => {
+    const { name, marketplace } = parsePluginIdentifier(plugin);
+    return {
+      _PROTO_plugin_name: name,
+      ...marketplace && {
+        _PROTO_marketplace_name: marketplace
+      },
+      ...buildPluginTelemetryFields(name, marketplace, getManagedPluginNames())
+    };
+  })() : {};
+  logEvent("tengu_plugin_command_failed", {
+    command,
+    error_category: classifyPluginCommandError(error),
+    ...telemetryFields
+  });
+  process.exit(1);
+}
+async function installPlugin(plugin, scope = "user") {
+  try {
+    console.log(`Installing plugin "${plugin}"...`);
+    const result = await installPluginOp(plugin, scope);
+    if (!result.success) {
+      throw new Error(result.message);
+    }
+    console.log(`${figures_default.tick} ${result.message}`);
+    const { name, marketplace } = parsePluginIdentifier(result.pluginId || plugin);
+    logEvent("tengu_plugin_installed_cli", {
+      _PROTO_plugin_name: name,
+      ...marketplace && {
+        _PROTO_marketplace_name: marketplace
+      },
+      scope: result.scope || scope,
+      install_source: "cli-explicit",
+      ...buildPluginTelemetryFields(name, marketplace, getManagedPluginNames())
+    });
+    process.exit(0);
+  } catch (error) {
+    handlePluginCommandError(error, "install", plugin);
+  }
+}
+async function uninstallPlugin(plugin, scope = "user", keepData = false) {
+  try {
+    const result = await uninstallPluginOp(plugin, scope, !keepData);
+    if (!result.success) {
+      throw new Error(result.message);
+    }
+    console.log(`${figures_default.tick} ${result.message}`);
+    const { name, marketplace } = parsePluginIdentifier(result.pluginId || plugin);
+    logEvent("tengu_plugin_uninstalled_cli", {
+      _PROTO_plugin_name: name,
+      ...marketplace && {
+        _PROTO_marketplace_name: marketplace
+      },
+      scope: result.scope || scope,
+      ...buildPluginTelemetryFields(name, marketplace, getManagedPluginNames())
+    });
+    process.exit(0);
+  } catch (error) {
+    handlePluginCommandError(error, "uninstall", plugin);
+  }
+}
+async function enablePlugin(plugin, scope) {
+  try {
+    const result = await enablePluginOp(plugin, scope);
+    if (!result.success) {
+      throw new Error(result.message);
+    }
+    console.log(`${figures_default.tick} ${result.message}`);
+    const { name, marketplace } = parsePluginIdentifier(result.pluginId || plugin);
+    logEvent("tengu_plugin_enabled_cli", {
+      _PROTO_plugin_name: name,
+      ...marketplace && {
+        _PROTO_marketplace_name: marketplace
+      },
+      scope: result.scope,
+      ...buildPluginTelemetryFields(name, marketplace, getManagedPluginNames())
+    });
+    process.exit(0);
+  } catch (error) {
+    handlePluginCommandError(error, "enable", plugin);
+  }
+}
+async function disablePlugin(plugin, scope) {
+  try {
+    const result = await disablePluginOp(plugin, scope);
+    if (!result.success) {
+      throw new Error(result.message);
+    }
+    console.log(`${figures_default.tick} ${result.message}`);
+    const { name, marketplace } = parsePluginIdentifier(result.pluginId || plugin);
+    logEvent("tengu_plugin_disabled_cli", {
+      _PROTO_plugin_name: name,
+      ...marketplace && {
+        _PROTO_marketplace_name: marketplace
+      },
+      scope: result.scope,
+      ...buildPluginTelemetryFields(name, marketplace, getManagedPluginNames())
+    });
+    process.exit(0);
+  } catch (error) {
+    handlePluginCommandError(error, "disable", plugin);
+  }
+}
+async function disableAllPlugins() {
+  try {
+    const result = await disableAllPluginsOp();
+    if (!result.success) {
+      throw new Error(result.message);
+    }
+    console.log(`${figures_default.tick} ${result.message}`);
+    logEvent("tengu_plugin_disabled_all_cli", {});
+    process.exit(0);
+  } catch (error) {
+    handlePluginCommandError(error, "disable-all");
+  }
+}
+async function updatePluginCli(plugin, scope) {
+  try {
+    writeToStdout(`Checking for updates for plugin "${plugin}" at ${scope} scope\u2026
+`);
+    const result = await updatePluginOp(plugin, scope);
+    if (!result.success) {
+      throw new Error(result.message);
+    }
+    writeToStdout(`${figures_default.tick} ${result.message}
+`);
+    if (!result.alreadyUpToDate) {
+      const { name, marketplace } = parsePluginIdentifier(result.pluginId || plugin);
+      logEvent("tengu_plugin_updated_cli", {
+        _PROTO_plugin_name: name,
+        ...marketplace && {
+          _PROTO_marketplace_name: marketplace
+        },
+        old_version: result.oldVersion || "unknown",
+        new_version: result.newVersion || "unknown",
+        ...buildPluginTelemetryFields(name, marketplace, getManagedPluginNames())
+      });
+    }
+    await gracefulShutdown(0);
+  } catch (error) {
+    handlePluginCommandError(error, "update", plugin);
+  }
+}
+
+export { installPlugin, uninstallPlugin, enablePlugin, disablePlugin, disableAllPlugins, updatePluginCli };