@foxclicom/foxcli 2.1.89

package/dist/chunk-g3t0act8.js

@@ -0,0 +1,8 @@
+// @bun
+import {
+  __esm
+} from "./chunk-qp2qdcda.js";
+
+// src/ink/devtools.ts
+var init_devtools = () => {};
+init_devtools();

package/dist/chunk-g4bng3yk.js

@@ -0,0 +1,140 @@
+// @bun
+import {
+  clearAllCaches,
+  clearPluginCacheExclusions,
+  getAgentDefinitionsWithOverrides,
+  getPluginCommands,
+  init_cacheUtils,
+  init_loadAgentsDir,
+  init_loadPluginCommands,
+  init_loadPluginHooks,
+  init_lspPluginIntegration,
+  init_manager,
+  init_mcpPluginIntegration,
+  init_orphanedPluginFilter,
+  init_pluginLoader,
+  loadAllPlugins,
+  loadPluginHooks,
+  loadPluginLspServers,
+  loadPluginMcpServers,
+  reinitializeLspServerManager
+} from "./chunk-363p49h1.js";
+import {
+  init_log,
+  logError
+} from "./chunk-p7g7pf3f.js";
+import {
+  errorMessage,
+  init_debug,
+  init_errors,
+  logForDebugging
+} from "./chunk-nxsh6de2.js";
+import {
+  getOriginalCwd,
+  init_state
+} from "./chunk-qqfa0dqg.js";
+import {
+  __esm
+} from "./chunk-qp2qdcda.js";
+
+// src/utils/plugins/refresh.ts
+async function refreshActivePlugins(setAppState) {
+  logForDebugging("refreshActivePlugins: clearing all plugin caches");
+  clearAllCaches();
+  clearPluginCacheExclusions();
+  const pluginResult = await loadAllPlugins();
+  const [pluginCommands, agentDefinitions] = await Promise.all([
+    getPluginCommands(),
+    getAgentDefinitionsWithOverrides(getOriginalCwd())
+  ]);
+  const { enabled, disabled, errors } = pluginResult;
+  const [mcpCounts, lspCounts] = await Promise.all([
+    Promise.all(enabled.map(async (p) => {
+      if (p.mcpServers)
+        return Object.keys(p.mcpServers).length;
+      const servers = await loadPluginMcpServers(p, errors);
+      if (servers)
+        p.mcpServers = servers;
+      return servers ? Object.keys(servers).length : 0;
+    })),
+    Promise.all(enabled.map(async (p) => {
+      if (p.lspServers)
+        return Object.keys(p.lspServers).length;
+      const servers = await loadPluginLspServers(p, errors);
+      if (servers)
+        p.lspServers = servers;
+      return servers ? Object.keys(servers).length : 0;
+    }))
+  ]);
+  const mcp_count = mcpCounts.reduce((sum, n) => sum + n, 0);
+  const lsp_count = lspCounts.reduce((sum, n) => sum + n, 0);
+  setAppState((prev) => ({
+    ...prev,
+    plugins: {
+      ...prev.plugins,
+      enabled,
+      disabled,
+      commands: pluginCommands,
+      errors: mergePluginErrors(prev.plugins.errors, errors),
+      needsRefresh: false
+    },
+    agentDefinitions,
+    mcp: {
+      ...prev.mcp,
+      pluginReconnectKey: prev.mcp.pluginReconnectKey + 1
+    }
+  }));
+  reinitializeLspServerManager();
+  let hook_load_failed = false;
+  try {
+    await loadPluginHooks();
+  } catch (e) {
+    hook_load_failed = true;
+    logError(e);
+    logForDebugging(`refreshActivePlugins: loadPluginHooks failed: ${errorMessage(e)}`);
+  }
+  const hook_count = enabled.reduce((sum, p) => {
+    if (!p.hooksConfig)
+      return sum;
+    return sum + Object.values(p.hooksConfig).reduce((s, matchers) => s + (matchers?.reduce((h, m) => h + m.hooks.length, 0) ?? 0), 0);
+  }, 0);
+  logForDebugging(`refreshActivePlugins: ${enabled.length} enabled, ${pluginCommands.length} commands, ${agentDefinitions.allAgents.length} agents, ${hook_count} hooks, ${mcp_count} MCP, ${lsp_count} LSP`);
+  return {
+    enabled_count: enabled.length,
+    disabled_count: disabled.length,
+    command_count: pluginCommands.length,
+    agent_count: agentDefinitions.allAgents.length,
+    hook_count,
+    mcp_count,
+    lsp_count,
+    error_count: errors.length + (hook_load_failed ? 1 : 0),
+    agentDefinitions,
+    pluginCommands
+  };
+}
+function mergePluginErrors(existing, fresh) {
+  const preserved = existing.filter((e) => e.source === "lsp-manager" || e.source.startsWith("plugin:"));
+  const freshKeys = new Set(fresh.map(errorKey));
+  const deduped = preserved.filter((e) => !freshKeys.has(errorKey(e)));
+  return [...deduped, ...fresh];
+}
+function errorKey(e) {
+  return e.type === "generic-error" ? `generic-error:${e.source}:${e.error}` : `${e.type}:${e.source}`;
+}
+var init_refresh = __esm(() => {
+  init_state();
+  init_manager();
+  init_loadAgentsDir();
+  init_debug();
+  init_errors();
+  init_log();
+  init_cacheUtils();
+  init_loadPluginCommands();
+  init_loadPluginHooks();
+  init_lspPluginIntegration();
+  init_mcpPluginIntegration();
+  init_orphanedPluginFilter();
+  init_pluginLoader();
+});
+
+export { refreshActivePlugins, init_refresh };

package/dist/chunk-gax0fcbx.js

@@ -0,0 +1,182 @@
+// @bun
+import {
+  init_path
+} from "./chunk-ctw5jwcd.js";
+import {
+  sanitizePath
+} from "./chunk-vratq94g.js";
+import {
+  createBufferedWriter,
+  getFsImplementation,
+  init_bufferedWriter,
+  init_cleanupRegistry,
+  init_debug,
+  init_fsOperations,
+  init_slowOperations,
+  jsonStringify,
+  logForDebugging,
+  registerCleanup
+} from "./chunk-nxsh6de2.js";
+import {
+  getClaudeConfigHomeDir,
+  init_envUtils,
+  isEnvTruthy
+} from "./chunk-3r24h7t6.js";
+import {
+  getOriginalCwd,
+  getSessionId,
+  init_state
+} from "./chunk-qqfa0dqg.js";
+
+// src/utils/asciicast.ts
+init_state();
+init_bufferedWriter();
+init_cleanupRegistry();
+init_debug();
+init_envUtils();
+init_fsOperations();
+init_path();
+init_slowOperations();
+import { appendFile, rename } from "fs/promises";
+import { basename, dirname, join } from "path";
+var recordingState = {
+  filePath: null,
+  timestamp: 0
+};
+function getRecordFilePath() {
+  if (recordingState.filePath !== null) {
+    return recordingState.filePath;
+  }
+  if (process.env.USER_TYPE !== "ant") {
+    return null;
+  }
+  if (!isEnvTruthy(process.env.CLAUDE_CODE_TERMINAL_RECORDING)) {
+    return null;
+  }
+  const projectsDir = join(getClaudeConfigHomeDir(), "projects");
+  const projectDir = join(projectsDir, sanitizePath(getOriginalCwd()));
+  recordingState.timestamp = Date.now();
+  recordingState.filePath = join(projectDir, `${getSessionId()}-${recordingState.timestamp}.cast`);
+  return recordingState.filePath;
+}
+function _resetRecordingStateForTesting() {
+  recordingState.filePath = null;
+  recordingState.timestamp = 0;
+}
+function getSessionRecordingPaths() {
+  const sessionId = getSessionId();
+  const projectsDir = join(getClaudeConfigHomeDir(), "projects");
+  const projectDir = join(projectsDir, sanitizePath(getOriginalCwd()));
+  try {
+    const entries = getFsImplementation().readdirSync(projectDir);
+    const names = typeof entries[0] === "string" ? entries : entries.map((e) => e.name);
+    const files = names.filter((f) => f.startsWith(sessionId) && f.endsWith(".cast")).sort();
+    return files.map((f) => join(projectDir, f));
+  } catch {
+    return [];
+  }
+}
+async function renameRecordingForSession() {
+  const oldPath = recordingState.filePath;
+  if (!oldPath || recordingState.timestamp === 0) {
+    return;
+  }
+  const projectsDir = join(getClaudeConfigHomeDir(), "projects");
+  const projectDir = join(projectsDir, sanitizePath(getOriginalCwd()));
+  const newPath = join(projectDir, `${getSessionId()}-${recordingState.timestamp}.cast`);
+  if (oldPath === newPath) {
+    return;
+  }
+  await recorder?.flush();
+  const oldName = basename(oldPath);
+  const newName = basename(newPath);
+  try {
+    await rename(oldPath, newPath);
+    recordingState.filePath = newPath;
+    logForDebugging(`[asciicast] Renamed recording: ${oldName} \u2192 ${newName}`);
+  } catch {
+    logForDebugging(`[asciicast] Failed to rename recording from ${oldName} to ${newName}`);
+  }
+}
+var recorder = null;
+function getTerminalSize() {
+  const cols = process.stdout.columns || 80;
+  const rows = process.stdout.rows || 24;
+  return { cols, rows };
+}
+async function flushAsciicastRecorder() {
+  await recorder?.flush();
+}
+function installAsciicastRecorder() {
+  const filePath = getRecordFilePath();
+  if (!filePath) {
+    return;
+  }
+  const { cols, rows } = getTerminalSize();
+  const startTime = performance.now();
+  const header = jsonStringify({
+    version: 2,
+    width: cols,
+    height: rows,
+    timestamp: Math.floor(Date.now() / 1000),
+    env: {
+      SHELL: process.env.SHELL || "",
+      TERM: process.env.TERM || ""
+    }
+  });
+  try {
+    getFsImplementation().mkdirSync(dirname(filePath));
+  } catch {}
+  getFsImplementation().appendFileSync(filePath, header + `
+`, { mode: 384 });
+  let pendingWrite = Promise.resolve();
+  const writer = createBufferedWriter({
+    writeFn(content) {
+      const currentPath = recordingState.filePath;
+      if (!currentPath) {
+        return;
+      }
+      pendingWrite = pendingWrite.then(() => appendFile(currentPath, content)).catch(() => {});
+    },
+    flushIntervalMs: 500,
+    maxBufferSize: 50,
+    maxBufferBytes: 10 * 1024 * 1024
+  });
+  const originalWrite = process.stdout.write.bind(process.stdout);
+  process.stdout.write = function(chunk, encodingOrCb, cb) {
+    const elapsed = (performance.now() - startTime) / 1000;
+    const text = typeof chunk === "string" ? chunk : Buffer.from(chunk).toString("utf-8");
+    writer.write(jsonStringify([elapsed, "o", text]) + `
+`);
+    if (typeof encodingOrCb === "function") {
+      return originalWrite(chunk, encodingOrCb);
+    }
+    return originalWrite(chunk, encodingOrCb, cb);
+  };
+  function onResize() {
+    const elapsed = (performance.now() - startTime) / 1000;
+    const { cols: newCols, rows: newRows } = getTerminalSize();
+    writer.write(jsonStringify([elapsed, "r", `${newCols}x${newRows}`]) + `
+`);
+  }
+  process.stdout.on("resize", onResize);
+  recorder = {
+    async flush() {
+      writer.flush();
+      await pendingWrite;
+    },
+    async dispose() {
+      writer.dispose();
+      await pendingWrite;
+      process.stdout.removeListener("resize", onResize);
+      process.stdout.write = originalWrite;
+    }
+  };
+  registerCleanup(async () => {
+    await recorder?.dispose();
+    recorder = null;
+  });
+  logForDebugging(`[asciicast] Recording to ${filePath}`);
+}
+
+export { getRecordFilePath, _resetRecordingStateForTesting, getSessionRecordingPaths, renameRecordingForSession, flushAsciicastRecorder, installAsciicastRecorder };

package/dist/chunk-gegyrhqa.js

@@ -0,0 +1,277 @@
+// @bun
+import {
+  normalizeControlMessageKeys
+} from "./chunk-nt837qt9.js";
+import {
+  EMPTY_USAGE,
+  init_emptyUsage
+} from "./chunk-2n877dxb.js";
+import {
+  init_analytics,
+  logEvent
+} from "./chunk-h0rbjg6x.js";
+import {
+  init_displayTags,
+  stripDisplayTagsAllowEmpty
+} from "./chunk-p7g7pf3f.js";
+import {
+  errorMessage,
+  init_debug,
+  init_errors,
+  init_slowOperations,
+  jsonParse,
+  logForDebugging
+} from "./chunk-nxsh6de2.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 };