echoclaw-relay-agent 0.22.7 → 0.23.0

package/dist/ConfigureHandler-NXQ2MDTI.js

@@ -0,0 +1,342 @@
+// src/configure/ConfigureHandler.ts
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+
+// src/configure/OpenClawConfig.ts
+import { readFile, writeFile, mkdir, rename } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { randomBytes } from "node:crypto";
+var OPENCLAW_CONFIG_DIR = join(homedir(), ".openclaw");
+var OPENCLAW_CONFIG_PATH = join(OPENCLAW_CONFIG_DIR, "openclaw.json");
+function detectProvider(apiKey, explicitProvider) {
+  if (!apiKey || typeof apiKey !== "string" || apiKey.trim().length < 10) {
+    throw new Error("API Key \u65E0\u6548\uFF1A\u957F\u5EA6\u8FC7\u77ED");
+  }
+  if (/[\x00-\x1f\x7f]/.test(apiKey)) {
+    throw new Error("API Key \u65E0\u6548\uFF1A\u5305\u542B\u63A7\u5236\u5B57\u7B26");
+  }
+  if (explicitProvider) {
+    return {
+      provider: explicitProvider,
+      modelId: getDefaultModel(explicitProvider),
+      apiKey
+    };
+  }
+  if (apiKey.startsWith("sk-ant-")) {
+    return { provider: "anthropic", modelId: "anthropic/claude-sonnet-4-5", apiKey };
+  }
+  if (apiKey.startsWith("sk-proj-") || apiKey.startsWith("sk-svcacct-") || apiKey.startsWith("sk-") && apiKey.length > 40) {
+    return { provider: "openai", modelId: "openai/gpt-4o", apiKey };
+  }
+  throw new Error(
+    "\u65E0\u6CD5\u81EA\u52A8\u8BC6\u522B API Key \u63D0\u4F9B\u5546\u3002\u8BF7\u6307\u5B9A provider \u53C2\u6570 (deepseek / anthropic / openai / openai-compatible)"
+  );
+}
+function getDefaultModel(provider) {
+  switch (provider) {
+    case "anthropic":
+      return "anthropic/claude-sonnet-4-5";
+    case "openai":
+      return "openai/gpt-4o";
+    case "deepseek":
+      return "deepseek/deepseek-chat";
+    default:
+      return `${provider}/default`;
+  }
+}
+async function readOpenClawConfig() {
+  if (!existsSync(OPENCLAW_CONFIG_PATH)) {
+    return {};
+  }
+  try {
+    const raw = await readFile(OPENCLAW_CONFIG_PATH, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return {};
+  }
+}
+async function writeOpenClawConfig(config) {
+  await mkdir(OPENCLAW_CONFIG_DIR, { recursive: true, mode: 448 });
+  const tmpPath = `${OPENCLAW_CONFIG_PATH}.${randomBytes(4).toString("hex")}.tmp`;
+  await writeFile(tmpPath, JSON.stringify(config, null, 2), { encoding: "utf-8", mode: 384 });
+  await rename(tmpPath, OPENCLAW_CONFIG_PATH);
+}
+var FORBIDDEN_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+function setNestedValue(obj, path, value) {
+  const parts = path.split(".");
+  let current = obj;
+  for (let i = 0; i < parts.length - 1; i++) {
+    if (FORBIDDEN_KEYS.has(parts[i])) throw new Error(`Invalid config path: ${path}`);
+    if (current[parts[i]] === void 0 || typeof current[parts[i]] !== "object") {
+      current[parts[i]] = {};
+    }
+    current = current[parts[i]];
+  }
+  const lastKey = parts[parts.length - 1];
+  if (FORBIDDEN_KEYS.has(lastKey)) throw new Error(`Invalid config path: ${path}`);
+  current[lastKey] = value;
+}
+function getNestedValue(obj, path) {
+  const parts = path.split(".");
+  let current = obj;
+  for (const part of parts) {
+    if (current === void 0 || current === null) return void 0;
+    current = current[part];
+  }
+  return current;
+}
+async function configureModel(providerConfig) {
+  const config = await readOpenClawConfig();
+  setNestedValue(config, "agents.defaults.model", providerConfig.modelId);
+  setNestedValue(
+    config,
+    `models.providers.${providerConfig.provider}.apiKey`,
+    providerConfig.apiKey
+  );
+  if (providerConfig.baseUrl) {
+    setNestedValue(
+      config,
+      `models.providers.${providerConfig.provider}.baseUrl`,
+      providerConfig.baseUrl
+    );
+  }
+  setNestedValue(config, "gateway.http.endpoints.chatCompletions.enabled", true);
+  await writeOpenClawConfig(config);
+}
+async function getGatewayToken() {
+  const config = await readOpenClawConfig();
+  return getNestedValue(config, "gateway.auth.token");
+}
+async function hasApiKeyConfigured() {
+  const config = await readOpenClawConfig();
+  const providers = getNestedValue(config, "models.providers");
+  if (!providers || typeof providers !== "object") return false;
+  for (const p of Object.values(providers)) {
+    if (typeof p === "object" && p !== null && "apiKey" in p && p.apiKey) {
+      return true;
+    }
+  }
+  return false;
+}
+
+// src/configure/ModelVerifier.ts
+async function verifyModel(gatewayPort, gatewayToken, model, timeoutMs = 3e4) {
+  const url = `http://localhost:${gatewayPort}/v1/chat/completions`;
+  try {
+    const res = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${gatewayToken}`
+      },
+      body: JSON.stringify({
+        model,
+        messages: [{ role: "user", content: "hi" }],
+        max_tokens: 5
+      }),
+      signal: AbortSignal.timeout(timeoutMs)
+    });
+    if (!res.ok) {
+      const body = await res.text().catch(() => "");
+      if (res.status === 401) {
+        return { success: false, error: "Gateway token \u65E0\u6548" };
+      }
+      if (res.status === 400 && body.includes("model")) {
+        return { success: false, error: `\u6A21\u578B ${model} \u4E0D\u53EF\u7528` };
+      }
+      if (res.status === 402 || body.includes("insufficient") || body.includes("quota")) {
+        return { success: false, error: "API \u4F59\u989D\u4E0D\u8DB3" };
+      }
+      return { success: false, error: `Gateway \u8FD4\u56DE ${res.status}: ${body.slice(0, 200)}` };
+    }
+    const data = await res.json();
+    if (data.choices && data.choices.length > 0) {
+      return { success: true, model };
+    }
+    return { success: false, error: "\u6A21\u578B\u8FD4\u56DE\u4E86\u7A7A\u54CD\u5E94" };
+  } catch (err) {
+    if (err.name === "AbortError" || err.name === "TimeoutError") {
+      return { success: false, error: `\u6A21\u578B\u8BF7\u6C42\u8D85\u65F6 (${timeoutMs / 1e3}s)` };
+    }
+    if (err.code === "ECONNREFUSED") {
+      return { success: false, error: `Gateway \u672A\u8FD0\u884C (localhost:${gatewayPort})` };
+    }
+    return { success: false, error: `\u8FDE\u63A5\u5931\u8D25: ${err.message}` };
+  }
+}
+async function waitForGateway(gatewayPort, gatewayToken, timeoutMs = 3e4, pollIntervalMs = 2e3) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    try {
+      const res = await fetch(`http://localhost:${gatewayPort}/v1/models`, {
+        headers: { Authorization: `Bearer ${gatewayToken}` },
+        signal: AbortSignal.timeout(5e3)
+      });
+      if (res.ok) return true;
+    } catch {
+    }
+    await new Promise((r) => setTimeout(r, pollIntervalMs));
+  }
+  return false;
+}
+
+// src/configure/ConfigureHandler.ts
+var execFileAsync = promisify(execFile);
+var DEFAULT_GATEWAY_PORT = 18789;
+async function findOpenClaw() {
+  try {
+    const { stdout } = await execFileAsync("which", ["openclaw"]);
+    return stdout.trim() || null;
+  } catch {
+    return null;
+  }
+}
+async function runOpenClaw(args, timeoutMs = 6e4) {
+  const openclawBin = await findOpenClaw();
+  if (!openclawBin) throw new Error("OpenClaw binary not found");
+  return execFileAsync(openclawBin, args, {
+    timeout: timeoutMs,
+    env: { ...process.env }
+  });
+}
+async function checkOpenClawInstalled() {
+  try {
+    const { stdout } = await runOpenClaw(["--version"], 1e4);
+    const version = stdout.trim();
+    if (version) return { installed: true, version };
+    return { installed: false };
+  } catch {
+    return { installed: false };
+  }
+}
+async function checkNeedsApiKey() {
+  return !await hasApiKeyConfigured();
+}
+async function handleConfigure(request, sendStatus) {
+  try {
+    sendStatus({
+      type: "agent_setup_status",
+      state: "configuring",
+      detail: "\u6B63\u5728\u68C0\u6D4B\u6A21\u578B\u63D0\u4F9B\u5546..."
+    }).catch(() => {
+    });
+    const providerConfig = detectProvider(request.apiKey, request.provider);
+    if (request.baseUrl) {
+      providerConfig.baseUrl = request.baseUrl;
+    }
+    sendStatus({
+      type: "agent_setup_status",
+      state: "configuring",
+      detail: `\u6B63\u5728\u914D\u7F6E ${providerConfig.provider} \u6A21\u578B...`
+    }).catch(() => {
+    });
+    await configureModel(providerConfig);
+    let gatewayToken = await getGatewayToken();
+    if (!gatewayToken) {
+      sendStatus({
+        type: "agent_setup_status",
+        state: "configuring",
+        detail: "\u6B63\u5728\u751F\u6210 Gateway \u8BA4\u8BC1\u4EE4\u724C..."
+      }).catch(() => {
+      });
+      try {
+        await runOpenClaw(["doctor", "--generate-gateway-token", "--non-interactive"], 3e4);
+      } catch (err) {
+        return {
+          type: "agent_setup_status",
+          state: "error",
+          error: `\u751F\u6210 Gateway Token \u5931\u8D25: ${err.message}`
+        };
+      }
+      gatewayToken = await getGatewayToken();
+      if (!gatewayToken) {
+        return {
+          type: "agent_setup_status",
+          state: "error",
+          error: "Gateway Token \u751F\u6210\u540E\u4ECD\u4E0D\u53EF\u7528"
+        };
+      }
+    }
+    sendStatus({
+      type: "agent_setup_status",
+      state: "configuring",
+      detail: "\u6B63\u5728\u542F\u52A8 OpenClaw Gateway..."
+    }).catch(() => {
+    });
+    try {
+      await runOpenClaw(["gateway", "install"], 3e4);
+    } catch (installErr) {
+      sendStatus({
+        type: "agent_setup_status",
+        state: "configuring",
+        detail: `Gateway install: ${installErr.message?.slice(0, 100) ?? "skipped (may already be installed)"}`
+      }).catch(() => {
+      });
+    }
+    try {
+      await runOpenClaw(["gateway", "start"], 15e3);
+    } catch (startErr) {
+      sendStatus({
+        type: "agent_setup_status",
+        state: "configuring",
+        detail: `Gateway start: ${startErr.message?.slice(0, 100) ?? "skipped (may already be running)"}`
+      }).catch(() => {
+      });
+    }
+    sendStatus({
+      type: "agent_setup_status",
+      state: "configuring",
+      detail: "\u7B49\u5F85 Gateway \u5C31\u7EEA..."
+    }).catch(() => {
+    });
+    const gatewayReady = await waitForGateway(DEFAULT_GATEWAY_PORT, gatewayToken, 3e4);
+    if (!gatewayReady) {
+      try {
+        await runOpenClaw(["gateway", "status", "--require-rpc"], 1e4);
+      } catch {
+        return {
+          type: "agent_setup_status",
+          state: "error",
+          error: "Gateway \u542F\u52A8\u8D85\u65F6\uFF0830s\uFF09\uFF0C\u8BF7\u68C0\u67E5 OpenClaw \u5B89\u88C5"
+        };
+      }
+    }
+    sendStatus({
+      type: "agent_setup_status",
+      state: "configuring",
+      detail: "\u6B63\u5728\u9A8C\u8BC1\u6A21\u578B\u8FDE\u63A5..."
+    }).catch(() => {
+    });
+    const verifyResult = await verifyModel(
+      DEFAULT_GATEWAY_PORT,
+      gatewayToken,
+      providerConfig.modelId
+    );
+    if (!verifyResult.success) {
+      return {
+        type: "agent_setup_status",
+        state: "error",
+        error: verifyResult.error ?? "\u6A21\u578B\u9A8C\u8BC1\u5931\u8D25"
+      };
+    }
+    return {
+      type: "agent_setup_status",
+      state: "ready",
+      detail: `${providerConfig.provider} \u6A21\u578B\u5DF2\u5C31\u7EEA`,
+      gatewayPort: DEFAULT_GATEWAY_PORT
+    };
+  } catch (err) {
+    return {
+      type: "agent_setup_status",
+      state: "error",
+      error: `\u914D\u7F6E\u5931\u8D25: ${err.message}`
+    };
+  }
+}
+export {
+  checkNeedsApiKey,
+  checkOpenClawInstalled,
+  handleConfigure
+};

package/dist/SessionStore-YHBFPQV7.js

@@ -0,0 +1,6 @@
+import {
+  SessionStore
+} from "./chunk-STI2237I.js";
+export {
+  SessionStore
+};