hob-bot 0.0.0-stage → 1.0.2

package/server/src/ids.ts

@@ -0,0 +1,19 @@
+import { randomBytes } from "node:crypto";
+
+const ALPHABET = "abcdefghijklmnopqrstuvwxyz0123456789";
+
+export function newId(prefix: string, length = 6): string {
+  const bytes = randomBytes(length);
+  let out = "";
+  for (let i = 0; i < length; i += 1) out += ALPHABET[bytes[i] % ALPHABET.length];
+  return `${prefix}${out}`;
+}
+
+/** 中文 slug：英文/数字保留，其余按拼音做不到就退回随机后缀。 */
+export function slugify(name: string): string {
+  const base = name
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-|-$/g, "");
+  return base || newId("a-", 4);
+}

package/server/src/image.ts

@@ -0,0 +1,218 @@
+// 图像生成：OpenAI 兼容接口（Key 存 secrets.json，只写不读回界面）。
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { basename, extname, join } from "node:path";
+import type { ImageSettings } from "../../shared/types.ts";
+import { IMAGE_TYPES } from "../../shared/media.ts";
+import { newId } from "./ids.ts";
+import { readSecrets } from "./secrets.ts";
+
+/** secrets.json 里 OpenAI 兼容接口的 Key。 */
+export const IMAGE_KEY_SECRET = "imageApiKey";
+
+/** 生成图像可能很慢（一张图几十秒），别让它挂死一个任务。 */
+const TIMEOUT_MS = 180_000;
+
+const MIME_BY_EXT = IMAGE_TYPES;
+
+const EXT_BY_MIME: Record<string, string> = {
+  "image/png": "png",
+  "image/jpeg": "jpg",
+  "image/webp": "webp",
+  "image/gif": "gif",
+};
+
+/** 配置不合法就抛错，界面把原因原样显示。 */
+export function checkImageSettings(raw: unknown): ImageSettings {
+  const input = (raw ?? {}) as Record<string, unknown>;
+  const source = input.source;
+  if (source === "off") return { source: "off" };
+  if (source === "openai") {
+    const baseUrl = typeof input.baseUrl === "string" ? input.baseUrl.trim().replace(/\/+$/, "") : "";
+    if (!baseUrl) throw new Error("请填写服务地址，如 http://127.0.0.1:8080/v1。");
+    let url: URL;
+    try {
+      url = new URL(baseUrl);
+    } catch {
+      throw new Error("服务地址无效：需以 http:// 或 https:// 开头，如 http://127.0.0.1:8080/v1。");
+    }
+    if (url.protocol !== "http:" && url.protocol !== "https:") {
+      throw new Error("服务地址协议无效：仅支持 http:// 或 https://。");
+    }
+    const model = typeof input.model === "string" ? input.model.trim() : "";
+    if (!model) throw new Error("请填写图像模型名称，如 gpt-image-1。");
+    const size = typeof input.size === "string" ? input.size.trim() : "";
+    return { source: "openai", baseUrl, model, ...(size ? { size } : {}) };
+  }
+  throw new Error("图片来源无效：可选值为关闭或 OpenAI 兼容接口。");
+}
+
+/** 读存盘的配置：坏的就退回上一次的值，不因为一个字段把整份设置弄坏。 */
+export function normalizeImageSettings(raw: unknown, fallback: ImageSettings): ImageSettings {
+  try {
+    return checkImageSettings(raw);
+  } catch {
+    return fallback;
+  }
+}
+
+export function imageConfigured(image: ImageSettings): boolean {
+  return image.source !== "off";
+}
+
+/** OpenAI 兼容接口的 Key（没配就是空字符串）。 */
+export function imageKey(home: string): string {
+  return readSecrets(home)[IMAGE_KEY_SECRET]?.trim() ?? "";
+}
+
+/** 生成图片的上下文。 */
+export interface ImageContext {
+  /** HOB_HOME：OpenAI 兼容接口的 Key 从 secrets.json 读 */
+  home: string;
+  /** 生成的图片存这个目录 */
+  dir: string;
+  config: ImageSettings;
+  /** 给了就用它，不给从 secrets.json 读 */
+  apiKey?: string;
+  /** 测试注入假服务器 */
+  fetchImpl?: typeof fetch;
+}
+
+export interface GenerateImageInput {
+  prompt: string;
+  size?: string;
+  refs?: string[]; // 参考图（绝对路径）
+}
+
+interface ImageBytes {
+  data: Buffer;
+  mimeType: string;
+}
+
+function mimeOfPath(path: string): string {
+  const mime = MIME_BY_EXT[extname(path).toLowerCase()];
+  if (!mime) throw new Error(`参考图格式不支持：仅支持 png、jpg、jpeg、gif、webp，当前文件为 ${path}。`);
+  return mime;
+}
+
+/** 生成一张图，存进目录，返回绝对路径。失败抛错，原因直接给用户看。 */
+export async function generateImage(ctx: ImageContext, input: GenerateImageInput): Promise<string> {
+  const prompt = input.prompt.trim();
+  if (!prompt) throw new Error("生成失败：提示词为空。");
+  if (ctx.config.source !== "openai") {
+    throw new Error("尚未配置图像生成：请在「设置 → 图像生成」中选择 OpenAI 兼容接口。");
+  }
+  const bytes: ImageBytes = await openAIImage(ctx, ctx.config, prompt, input);
+  if (!bytes.data.length) throw new Error("生成失败：接口返回了空图片。");
+  mkdirSync(ctx.dir, { recursive: true });
+  const ext = EXT_BY_MIME[bytes.mimeType.toLowerCase()] ?? "png";
+  const path = join(ctx.dir, `${newId("img-")}.${ext}`);
+  writeFileSync(path, bytes.data);
+  return path;
+}
+
+
+async function openAIImage(
+  ctx: ImageContext,
+  config: Extract<ImageSettings, { source: "openai" }>,
+  prompt: string,
+  input: GenerateImageInput,
+): Promise<ImageBytes> {
+  const key = ctx.apiKey?.trim() || imageKey(ctx.home);
+  if (!key) throw new Error("尚未填写 API Key：请在「设置 → 图像生成」中填写后重试。");
+  const size = input.size?.trim() || config.size?.trim() || "";
+  const refs = input.refs ?? [];
+  const fetchImpl = ctx.fetchImpl ?? fetch;
+  const endpoint = `${config.baseUrl}${refs.length ? "/images/edits" : "/images/generations"}`;
+
+  let request: RequestInit;
+  if (refs.length) {
+    // 有参考图：multipart 打到 /images/edits
+    const form = new FormData();
+    form.append("model", config.model);
+    form.append("prompt", prompt);
+    if (size) form.append("size", size);
+    for (const ref of refs) {
+      const mimeType = mimeOfPath(ref);
+      form.append(refs.length > 1 ? "image[]" : "image", new Blob([readFileSync(ref)], { type: mimeType }), basename(ref));
+    }
+    request = { method: "POST", headers: { authorization: `Bearer ${key}` }, body: form };
+  } else {
+    request = {
+      method: "POST",
+      headers: { authorization: `Bearer ${key}`, "content-type": "application/json" },
+      // 不传 response_format：有的服务只给 URL，两种都支持，别逼它
+      body: JSON.stringify({ model: config.model, prompt, ...(size ? { size } : {}), n: 1 }),
+    };
+  }
+
+  const response = await send(fetchImpl, endpoint, request, config.baseUrl);
+  const body = (await response.json().catch(() => undefined)) as unknown;
+  const first = firstImage(body);
+  if (!first) throw new Error(`生成失败：接口未返回图片：${snippet(body)}`);
+  if (first.b64_json) return { data: Buffer.from(first.b64_json, "base64"), mimeType: "image/png" };
+  const fetched = await send(fetchImpl, first.url!, { method: "GET" }, first.url!);
+  const mimeType = fetched.headers.get("content-type")?.split(";")[0]?.trim() || "image/png";
+  return { data: Buffer.from(await fetched.arrayBuffer()), mimeType };
+}
+
+/** OpenAI 兼容接口的返回里挑第一张图（base64 或 URL 都行）。 */
+export function firstImage(body: unknown): { b64_json?: string; url?: string } | undefined {
+  const data = (body as { data?: unknown } | undefined)?.data;
+  if (!Array.isArray(data) || !data.length) return undefined;
+  const first = data[0] as { b64_json?: unknown; url?: unknown } | undefined;
+  if (!first || typeof first !== "object") return undefined;
+  const b64 = typeof first.b64_json === "string" && first.b64_json ? first.b64_json : undefined;
+  const url = typeof first.url === "string" && first.url ? first.url : undefined;
+  return b64 || url ? { ...(b64 ? { b64_json: b64 } : {}), ...(url ? { url } : {}) } : undefined;
+}
+
+async function send(fetchImpl: typeof fetch, url: string, init: RequestInit, label: string): Promise<Response> {
+  let response: Response;
+  try {
+    response = await fetchImpl(url, { ...init, signal: AbortSignal.timeout(TIMEOUT_MS) });
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : String(error);
+    if (/timeout|timed out|abort/i.test(reason)) throw new Error(`${label} 请求超时：${TIMEOUT_MS / 1000} 秒内未响应。`);
+    throw new Error(`无法连接 ${label}：${reason}`);
+  }
+  if (!response.ok) throw new Error(await describeFailure(response, label));
+  return response;
+}
+
+async function describeFailure(response: Response, label: string): Promise<string> {
+  const detail = errorText(await response.text().catch(() => ""));
+  const suffix = detail ? `：${detail}` : "";
+  if (response.status === 401 || response.status === 403) {
+    return `${label} 拒绝该 API Key（${response.status}）${suffix}`;
+  }
+  if (response.status === 404) {
+    return `${label} 未提供该接口或模型（404）${suffix}。请检查服务地址是否需要包含 /v1，以及模型名称是否正确。`;
+  }
+  return `${label} 返回状态码 ${response.status}${suffix}`;
+}
+
+/** 从错误体里抠出人能看懂的一句话。 */
+function errorText(body: string): string {
+  const text = body.trim();
+  if (!text) return "";
+  try {
+    const parsed = JSON.parse(text) as { error?: unknown; message?: unknown };
+    const error = parsed.error;
+    if (typeof error === "string") return error;
+    if (error && typeof error === "object") {
+      const message = (error as { message?: unknown }).message;
+      if (typeof message === "string") return message;
+    }
+    if (typeof parsed.message === "string") return parsed.message;
+  } catch {
+    // 不是 JSON：原样给一小段
+  }
+  return snippet(text);
+}
+
+function snippet(body: unknown): string {
+  const text = typeof body === "string" ? body : JSON.stringify(body ?? "");
+  const clean = text.replace(/\s+/g, " ").trim();
+  if (!clean) return "（空）";
+  return clean.length > 200 ? `${clean.slice(0, 199)}…` : clean;
+}

package/server/src/imports.ts

@@ -0,0 +1,302 @@
+// 从本机已有的配置导入服务商和 Lore 连接：只读来源文件，绝不写回、不改权限和时间戳。
+// Key / Token 只在内存里传给调用方，任何接口返回值和日志里都不出现明文。
+import { existsSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { THINKING_LEVELS, THINKING_TEXT_MAX } from "../../shared/thinking.ts";
+import type {
+  LoreImportView,
+  ProviderApi,
+  ProviderImportItem,
+  ProviderImportKey,
+  ProviderModelSetting,
+  ProviderSettings,
+  ThinkingLevelMapSetting,
+} from "../../shared/types.ts";
+
+const MAX_BYTES = 256 * 1024;
+const SLUG = /^[a-z0-9][a-z0-9._-]*$/;
+/** 整个值就是一个环境变量引用的写法（和引擎的解析规则一致：`$NAME` / `${NAME}`）。 */
+const SINGLE_ENV_REF = /^\$\{?([A-Za-z_][A-Za-z0-9_]*)\}?$/;
+/** 服务商里由 Hob 自己管的字段，其余（compat、headers、authHeader…）原样透传给引擎。 */
+const PROVIDER_OWNED_KEYS = new Set(["name", "baseUrl", "api", "apiKey", "models"]);
+/** 模型里由 Hob 自己映射的字段，其余进模型的 extra；thinkingLevelMap 进 Hob 的自定义思考档。 */
+const MODEL_OWNED_KEYS = new Set(["id", "name", "input", "reasoning", "contextWindow", "maxTokens", "thinkingLevelMap"]);
+
+const COMMAND_KEY_NOTE = "Key 需通过命令获取，请导入后手动填写。";
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+function text(value: unknown): string {
+  return typeof value === "string" ? value.trim() : "";
+}
+
+function positive(value: unknown): number | undefined {
+  const n = Number(value);
+  return Number.isFinite(n) && n > 0 ? Math.round(n) : undefined;
+}
+
+function readJson(path: string): Record<string, unknown> | undefined {
+  if (!existsSync(path)) return undefined;
+  try {
+    const raw = readFileSync(path, "utf8");
+    if (Buffer.byteLength(raw, "utf8") > MAX_BYTES) return undefined;
+    const parsed: unknown = JSON.parse(raw);
+    return isRecord(parsed) ? parsed : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+/** 本机原有的引擎目录（启动时记下的原值，没启动过就用默认位置）。 */
+export function localPiDir(env: NodeJS.ProcessEnv = process.env): string {
+  return text(env.HOB_LOCAL_PI_DIR) || join(homedir(), ".pi", "agent");
+}
+
+/** 本机原有的 Lore 目录。 */
+export function localLoreHome(env: NodeJS.ProcessEnv = process.env): string {
+  return text(env.HOB_LOCAL_LORE_HOME) || join(homedir(), ".lore");
+}
+
+export interface ImportKey {
+  kind: ProviderImportKey;
+  /** 字面值或环境变量的值；命令不执行，所以没有 */
+  value?: string;
+  note?: string;
+}
+
+/** 把本机配置里的 Key 解析成能直接用的样子：字面值直接用，环境变量取值，命令不执行。 */
+export function resolveImportKey(raw: unknown, env: NodeJS.ProcessEnv = process.env): ImportKey {
+  const value = text(raw);
+  if (!value) return { kind: "none" };
+  if (value.startsWith("!")) return { kind: "command", note: COMMAND_KEY_NOTE };
+  const reference = SINGLE_ENV_REF.exec(value);
+  if (reference) {
+    const name = reference[1]!;
+    const resolved = text(env[name]);
+    if (resolved) return { kind: "env", value: resolved };
+    return { kind: "none", note: `Key 引用的环境变量 ${name} 未设置，请导入后手动填写。` };
+  }
+  return { kind: "literal", value };
+}
+
+/**
+ * 本机那份 thinkingLevelMap 在导入那一刻原样复制进 Hob 的自定义档位：
+ * 写明的字符串和 null 都带上（null = 这一档不要），没写的键不补。
+ * 没写的档之后按 Hob 的默认规则算（默认范围里引擎默认不开的 xhigh / max 会自动开），
+ * 不再拿档名去补齐——写了字符串的档引擎会原样发出去，那不是每个协议都收的值。
+ * 返回 undefined 表示本机没写思考档（用默认规则）。
+ */
+function importThinking(raw: unknown): ThinkingLevelMapSetting | undefined {
+  if (!isRecord(raw)) return undefined;
+  const map: ThinkingLevelMapSetting = {};
+  for (const level of THINKING_LEVELS) {
+    if (!(level in raw)) continue;
+    const value = raw[level];
+    if (value === null) {
+      // 关闭这一档不能删（Hob 的规矩），本机写 null 就当没改
+      if (level !== "off") map[level] = null;
+      continue;
+    }
+    const text = typeof value === "string" ? value.trim() : "";
+    // 读不懂的值当没写，不因此把这一档删掉
+    if (!text || text.length > THINKING_TEXT_MAX) continue;
+    map[level] = text;
+  }
+  return Object.keys(map).length ? map : undefined;
+}
+
+function mapModel(raw: unknown): { model: ProviderModelSetting; thinking?: ThinkingLevelMapSetting } | undefined {
+  if (!isRecord(raw)) return undefined;
+  const id = text(raw.id);
+  if (!id) return undefined;
+  const extra: Record<string, unknown> = {};
+  for (const [key, value] of Object.entries(raw)) {
+    if (!MODEL_OWNED_KEYS.has(key)) extra[key] = value;
+  }
+  const name = text(raw.name);
+  const input = Array.isArray(raw.input)
+    ? raw.input.filter((kind): kind is "text" | "image" => kind === "text" || kind === "image")
+    : [];
+  const contextWindow = positive(raw.contextWindow);
+  const maxTokens = positive(raw.maxTokens);
+  const reasoning = typeof raw.reasoning === "boolean" ? raw.reasoning : false;
+  // 本机那份的思考档只复制这一次：之后只看 Hob 设置里存的，和本机再无关系
+  const thinking = reasoning ? importThinking(raw.thinkingLevelMap) : undefined;
+  return {
+    model: {
+      id,
+      ...(name ? { name } : {}),
+      ...(input.length ? { input } : {}),
+      ...(typeof raw.reasoning === "boolean" ? { reasoning: raw.reasoning } : {}),
+      ...(contextWindow ? { contextWindow } : {}),
+      ...(maxTokens ? { maxTokens } : {}),
+      ...(Object.keys(extra).length ? { extra } : {}),
+    },
+    ...(thinking ? { thinking } : {}),
+  };
+}
+
+/** 一个候选：界面看到的那一项 + 真正要写进设置的内容。 */
+export interface ProviderImportCandidate {
+  item: ProviderImportItem;
+  /** 可导入时有值：要写进 settings.json 的服务商（Key 不在里面） */
+  provider?: ProviderSettings;
+  /** 要写进 secrets.json 的 Key（命令和缺失的环境变量没有） */
+  key?: string;
+  /** 导入那一刻从本机复制的思考档，键是模型 ref（之后只看 Hob 设置） */
+  thinking?: Record<string, ThinkingLevelMapSetting>;
+}
+
+export interface ListProviderImportsOptions {
+  /** 本机引擎目录（HOB_LOCAL_PI_DIR） */
+  source: string;
+  /** 已经配置过的服务商 id（界面上标「将覆盖」） */
+  existing: Set<string>;
+  /** 引擎自带的服务商 id（auth.json 里的条目只有引擎认识才列出来） */
+  builtinIds: ReadonlySet<string>;
+  /** 引擎自带的模型数（内置服务商那一项显示用） */
+  builtinModelCount?: (id: string) => number;
+  /** 支持哪些协议（和注册进引擎时一致） */
+  apis: readonly ProviderApi[];
+  env?: NodeJS.ProcessEnv;
+}
+
+function customCandidate(
+  id: string,
+  raw: unknown,
+  options: ListProviderImportsOptions,
+): ProviderImportCandidate | undefined {
+  if (!isRecord(raw)) return undefined;
+  const knownApi = options.apis.includes(text(raw.api) as ProviderApi);
+  const api = text(raw.api) as ProviderApi;
+  const baseUrl = text(raw.baseUrl).replace(/\/+$/, "");
+  const mapped = Array.isArray(raw.models) ? raw.models.map(mapModel).filter((entry) => entry !== undefined) : [];
+  const models = mapped.map((entry) => entry.model);
+  const thinking: Record<string, ThinkingLevelMapSetting> = {};
+  for (const entry of mapped) {
+    if (entry.thinking) thinking[`${id}/${entry.model.id}`] = entry.thinking;
+  }
+  const extra: Record<string, unknown> = {};
+  for (const [key, value] of Object.entries(raw)) {
+    if (!PROVIDER_OWNED_KEYS.has(key)) extra[key] = value;
+  }
+  const key = resolveImportKey(raw.apiKey, options.env ?? process.env);
+  const usable = SLUG.test(id) && knownApi && baseUrl !== "" && models.length > 0;
+  const note = usable
+    ? key.note
+    : !SLUG.test(id)
+      ? "服务商标识不符合要求，无法导入。"
+      : !knownApi
+        ? "缺少协议或协议不支持，无法导入。"
+        : baseUrl === ""
+          ? "缺少服务地址，无法导入。"
+          : "没有模型列表，无法导入。";
+  const item: ProviderImportItem = {
+    id,
+    kind: "custom",
+    ...(knownApi ? { api } : {}),
+    ...(baseUrl ? { baseUrl } : {}),
+    models: models.length,
+    key: key.kind,
+    exists: options.existing.has(id),
+    selectable: usable,
+    ...(note ? { note } : {}),
+  };
+  if (!usable) return { item };
+  const provider: ProviderSettings = {
+    kind: "custom",
+    id,
+    // 显示名就用 id：本机那份的 name 只是那边起的名字，换成 id 两边好对应
+    name: id,
+    api,
+    baseUrl,
+    models,
+    ...(Object.keys(extra).length ? { extra } : {}),
+  };
+  return { item, provider, ...(key.value ? { key: key.value } : {}), ...(Object.keys(thinking).length ? { thinking } : {}) };
+}
+
+function builtinCandidate(
+  id: string,
+  raw: unknown,
+  options: ListProviderImportsOptions,
+): ProviderImportCandidate | undefined {
+  if (!options.builtinIds.has(id) || !isRecord(raw)) return undefined;
+  const models = options.builtinModelCount?.(id) ?? 0;
+  const credentialType = text(raw.type);
+  if (credentialType !== "api_key") {
+    return {
+      item: {
+        id,
+        kind: "builtin",
+        models,
+        key: "none",
+        exists: options.existing.has(id),
+        selectable: false,
+        note: "登录授权类凭据无法导入。",
+      },
+    };
+  }
+  const key = resolveImportKey(raw.key, options.env ?? process.env);
+  return {
+    item: {
+      id,
+      kind: "builtin",
+      models,
+      key: key.kind,
+      exists: options.existing.has(id),
+      selectable: true,
+      ...(key.note ? { note: key.note } : {}),
+    },
+    provider: { kind: "builtin", id },
+    ...(key.value ? { key: key.value } : {}),
+  };
+}
+
+/**
+ * 读本机的 models.json（兼容接口）和 auth.json（内置服务商），列出能导入的项。
+ * 同一 id 只列一次，models.json 的先列。
+ */
+export function listProviderImports(options: ListProviderImportsOptions): ProviderImportCandidate[] {
+  const modelsFile = readJson(join(options.source, "models.json"));
+  const authFile = readJson(join(options.source, "auth.json"));
+  const out: ProviderImportCandidate[] = [];
+  const seen = new Set<string>();
+  const push = (candidate: ProviderImportCandidate | undefined) => {
+    if (!candidate || seen.has(candidate.item.id)) return;
+    seen.add(candidate.item.id);
+    out.push(candidate);
+  };
+  const providers = modelsFile?.providers;
+  if (isRecord(providers)) {
+    for (const [id, raw] of Object.entries(providers)) push(customCandidate(id, raw, options));
+  }
+  if (authFile) {
+    for (const [id, raw] of Object.entries(authFile)) push(builtinCandidate(id, raw, options));
+  }
+  return out;
+}
+
+/** 读本机的 Lore 连接（只读）。token 只在导入时用，不返回给页面。 */
+export function readLocalLoreConnection(loreHome: string): { view: LoreImportView; token?: string } {
+  const document = readJson(join(loreHome, "config.json")) ?? {};
+  const baseUrl = text(document.base_url).replace(/\/+$/, "");
+  const token = text(document.api_token);
+  return {
+    view: {
+      source: loreHome,
+      found: baseUrl !== "",
+      ...(baseUrl ? { baseUrl } : {}),
+      tokenPresent: token !== "",
+    },
+    ...(token ? { token } : {}),
+  };
+}
+
+/** 本机 Lore 连接的页面视图（不带 Token）。 */
+export function readLocalLore(loreHome: string): LoreImportView {
+  return readLocalLoreConnection(loreHome).view;
+}