hypercore-cli 1.1.2 → 1.4.0

package/dist/chunk-5GDYH676.js

@@ -1,271 +0,0 @@
-import {
-  hookManager
-} from "./chunk-CLKIMCXZ.js";
-
-// src/llm/openai-compat.ts
-import OpenAI from "openai";
-function createOpenAIClient(config) {
-  return new OpenAI({
-    apiKey: config.apiKey,
-    baseURL: config.baseURL
-  });
-}
-async function triggerToolHook(event, context) {
-  try {
-    return await hookManager.trigger(event, context);
-  } catch {
-    return { intercepted: false };
-  }
-}
-async function callOpenAILLM(client, options) {
-  const {
-    systemPrompt,
-    userPrompt,
-    tools,
-    model = "gemini-2.5-flash",
-    maxTokens = 8192,
-    onText,
-    onToolCall,
-    onThinking,
-    onToolCallDone
-  } = options;
-  const toolDefinitions = tools.map((t) => ({
-    type: "function",
-    function: {
-      name: t.definition.name,
-      description: t.definition.description,
-      parameters: t.definition.input_schema
-    }
-  }));
-  const messages = [
-    { role: "system", content: systemPrompt },
-    { role: "user", content: userPrompt }
-  ];
-  let totalOutput = "";
-  let currentRoundText = "";
-  const allToolCalls = [];
-  let totalInputTokens = 0;
-  let totalOutputTokens = 0;
-  let maxIterations = 10;
-  while (maxIterations-- > 0) {
-    currentRoundText = "";
-    const response = await client.chat.completions.create({
-      model,
-      max_tokens: maxTokens,
-      messages,
-      tools: toolDefinitions.length > 0 ? toolDefinitions : void 0
-    });
-    if (response.usage) {
-      totalInputTokens += response.usage.prompt_tokens || 0;
-      totalOutputTokens += response.usage.completion_tokens || 0;
-    }
-    const choice = response.choices[0];
-    if (!choice) break;
-    const message = choice.message;
-    if (message.content) {
-      totalOutput += message.content;
-      currentRoundText += message.content;
-      onText?.(message.content);
-    }
-    if (message.tool_calls && message.tool_calls.length > 0) {
-      if (currentRoundText.trim()) {
-        onThinking?.(currentRoundText.trim());
-      }
-      messages.push(message);
-      for (const toolCall of message.tool_calls) {
-        const fn = toolCall.function;
-        const fnName = fn.name;
-        let fnArgs = {};
-        try {
-          fnArgs = JSON.parse(fn.arguments || "{}");
-        } catch {
-        }
-        const toolInputText = JSON.stringify(fnArgs);
-        onToolCall?.(fnName, fnArgs);
-        const tool = tools.find((t) => t.definition.name === fnName);
-        let result;
-        const toolStart = Date.now();
-        const hookResult = await triggerToolHook("onToolCall", {
-          model,
-          toolName: fnName,
-          toolInput: toolInputText
-        });
-        if (hookResult.intercepted) {
-          result = `Error: Hook intercepted tool call - ${hookResult.reason || "blocked"}`;
-        } else if (tool) {
-          try {
-            result = await tool.handler(fnArgs);
-          } catch (err) {
-            result = `Error: ${err instanceof Error ? err.message : String(err)}`;
-          }
-        } else {
-          result = `Error: Tool "${fnName}" not found`;
-        }
-        const toolDuration = Date.now() - toolStart;
-        onToolCallDone?.(fnName, toolDuration);
-        await triggerToolHook("onToolResult", {
-          model,
-          toolName: fnName,
-          toolInput: toolInputText,
-          toolResult: result
-        });
-        allToolCalls.push({
-          toolName: fnName,
-          input: fnArgs,
-          output: result
-        });
-        messages.push({
-          role: "tool",
-          tool_call_id: toolCall.id,
-          content: result
-        });
-      }
-      continue;
-    }
-    break;
-  }
-  return {
-    output: totalOutput,
-    responseText: allToolCalls.length > 0 ? currentRoundText : totalOutput,
-    toolCalls: allToolCalls,
-    tokenUsage: {
-      inputTokens: totalInputTokens,
-      outputTokens: totalOutputTokens
-    }
-  };
-}
-async function streamOpenAIChat(client, messages, options) {
-  const { model, tools = [], onChunk, onToolCall, onThinking, onToolCallDone } = options;
-  const toolDefinitions = tools.map((t) => ({
-    type: "function",
-    function: {
-      name: t.definition.name,
-      description: t.definition.description,
-      parameters: t.definition.input_schema
-    }
-  }));
-  let totalContent = "";
-  let currentRoundContent = "";
-  let hasCalledTools = false;
-  let totalInputTokens = 0;
-  let totalOutputTokens = 0;
-  let maxIterations = 10;
-  while (maxIterations-- > 0) {
-    currentRoundContent = "";
-    let stream;
-    let lastError;
-    for (let retry = 0; retry < 5; retry++) {
-      try {
-        stream = await client.chat.completions.create({
-          model,
-          max_tokens: 4096,
-          messages,
-          tools: toolDefinitions.length > 0 ? toolDefinitions : void 0,
-          stream: true
-        });
-        lastError = null;
-        break;
-      } catch (err) {
-        lastError = err;
-        const status = err.status;
-        if (status === 429) {
-          const wait = (retry + 1) * 5e3;
-          process.stdout.write(`\x1B[2m  \u23F3 API \u9650\u6D41\uFF0C${wait / 1e3}s \u540E\u91CD\u8BD5...\x1B[0m
-`);
-          await new Promise((r) => setTimeout(r, wait));
-          continue;
-        }
-        throw err;
-      }
-    }
-    if (lastError) throw lastError;
-    let chunkContent = "";
-    const toolCalls = /* @__PURE__ */ new Map();
-    for await (const chunk of stream) {
-      const delta = chunk.choices[0]?.delta;
-      if (!delta) continue;
-      if (delta.content) {
-        chunkContent += delta.content;
-        totalContent += delta.content;
-        currentRoundContent += delta.content;
-        onChunk?.(delta.content);
-      }
-      if (delta.tool_calls) {
-        for (const tc of delta.tool_calls) {
-          const existing = toolCalls.get(tc.index) || { id: "", name: "", args: "" };
-          if (tc.id) existing.id = tc.id;
-          if (tc.function?.name) existing.name = tc.function.name;
-          if (tc.function?.arguments) existing.args += tc.function.arguments;
-          toolCalls.set(tc.index, existing);
-        }
-      }
-      if (chunk.usage) {
-        totalInputTokens += chunk.usage.prompt_tokens || 0;
-        totalOutputTokens += chunk.usage.completion_tokens || 0;
-      }
-    }
-    if (toolCalls.size === 0) break;
-    hasCalledTools = true;
-    if (chunkContent.trim()) {
-      onThinking?.(chunkContent.trim());
-    }
-    const assistantMessage = {
-      role: "assistant",
-      content: chunkContent || null,
-      tool_calls: Array.from(toolCalls.values()).map((tc) => ({
-        id: tc.id,
-        type: "function",
-        function: { name: tc.name, arguments: tc.args }
-      }))
-    };
-    messages.push(assistantMessage);
-    for (const [, tc] of toolCalls) {
-      let fnArgs = {};
-      try {
-        fnArgs = JSON.parse(tc.args || "{}");
-      } catch {
-      }
-      onToolCall?.(tc.name, fnArgs);
-      const toolInputText = JSON.stringify(fnArgs);
-      const tool = tools.find((t) => t.definition.name === tc.name);
-      let result;
-      const toolStart = Date.now();
-      const hookResult = await triggerToolHook("onToolCall", {
-        model,
-        toolName: tc.name,
-        toolInput: toolInputText
-      });
-      if (hookResult.intercepted) {
-        result = `Error: Hook intercepted tool call - ${hookResult.reason || "blocked"}`;
-      } else if (tool) {
-        try {
-          result = await tool.handler(fnArgs);
-        } catch (err) {
-          result = `Error: ${err instanceof Error ? err.message : String(err)}`;
-        }
-      } else {
-        result = `Error: Tool "${tc.name}" not found`;
-      }
-      const toolDuration = Date.now() - toolStart;
-      onToolCallDone?.(tc.name, toolDuration);
-      await triggerToolHook("onToolResult", {
-        model,
-        toolName: tc.name,
-        toolInput: toolInputText,
-        toolResult: result
-      });
-      messages.push({ role: "tool", tool_call_id: tc.id, content: result });
-    }
-  }
-  return {
-    content: totalContent,
-    responseContent: hasCalledTools ? currentRoundContent : totalContent,
-    tokenUsage: { inputTokens: totalInputTokens, outputTokens: totalOutputTokens }
-  };
-}
-
-export {
-  createOpenAIClient,
-  callOpenAILLM,
-  streamOpenAIChat
-};

package/dist/chunk-5NLVGLD7.js

@@ -1,66 +0,0 @@
-import {
-  HYPERCORE_DIR
-} from "./chunk-I7WI3BMB.js";
-
-// src/team/auth.ts
-import { randomBytes } from "crypto";
-import { readFile, writeFile, mkdir } from "fs/promises";
-import { existsSync } from "fs";
-import { join } from "path";
-function generateId() {
-  return randomBytes(4).toString("hex");
-}
-function generateToken() {
-  return randomBytes(8).toString("hex");
-}
-function generateJoinCode() {
-  const chars = "ABCDEFGHJKLMNPQRSTUVWXYZ23456789";
-  let code = "";
-  const bytes = randomBytes(6);
-  for (let i = 0; i < 6; i++) {
-    code += chars[bytes[i] % chars.length];
-  }
-  return code;
-}
-function validateToken(team, token) {
-  return team.members.find((m) => m.token === token) || null;
-}
-function isOwner(member) {
-  return member.role === "owner";
-}
-var TOKEN_FILE = "team-token.json";
-function getTokenPath() {
-  return join(HYPERCORE_DIR, TOKEN_FILE);
-}
-async function saveLocalToken(token) {
-  await mkdir(HYPERCORE_DIR, { recursive: true });
-  await writeFile(getTokenPath(), JSON.stringify(token, null, 2), "utf-8");
-}
-async function loadLocalToken() {
-  const p = getTokenPath();
-  if (!existsSync(p)) return null;
-  try {
-    const data = await readFile(p, "utf-8");
-    return JSON.parse(data);
-  } catch {
-    return null;
-  }
-}
-async function clearLocalToken() {
-  const p = getTokenPath();
-  if (existsSync(p)) {
-    const { unlink } = await import("fs/promises");
-    await unlink(p);
-  }
-}
-
-export {
-  generateId,
-  generateToken,
-  generateJoinCode,
-  validateToken,
-  isOwner,
-  saveLocalToken,
-  loadLocalToken,
-  clearLocalToken
-};