luckytri 1.0.0

package/server/plugins/install.js

@@ -0,0 +1,295 @@
+import { createHash, randomUUID } from "node:crypto";
+import { lookup } from "node:dns/promises";
+import { cpSync, mkdirSync, readdirSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { assertPublicHost } from "../core/net-guard.js";
+import { VERSION } from "../version.js";
+import { readManifest, satisfies, validateManifest } from "./manifest.js";
+import { readZip, stripRoot, writeTree } from "./zip.js";
+
+const DOWNLOAD = 20 * 1024 * 1024;
+const STAGED_FOR = 30 * 60000;
+
+async function download(url, hops = 0, timeoutMs = 30000) {
+  if (hops > 3) throw new Error("跳转过多");
+  const parsed = new URL(url);
+  if (parsed.protocol !== "https:" || parsed.username || parsed.password)
+    throw new Error("这个地址不能访问");
+  await assertPublicHost(parsed.hostname, lookup, "这个地址不能访问");
+  let response;
+  try {
+    response = await fetch(parsed, {
+      redirect: "manual",
+      headers: { "User-Agent": `LuckyTri/${VERSION}` },
+      signal: AbortSignal.timeout(timeoutMs),
+    });
+  } catch {
+    throw new Error("插件包下载失败");
+  }
+  if ([301, 302, 303, 307, 308].includes(response.status)) {
+    const next = new URL(response.headers.get("location") || "", parsed).href;
+    return download(next, hops + 1, timeoutMs);
+  }
+  if (!response.ok) throw new Error("插件包下载失败");
+  const length = Number(response.headers.get("content-length"));
+  if (length > DOWNLOAD) throw new Error("插件包过大");
+  const bytes = Buffer.from(await response.arrayBuffer());
+  if (bytes.length > DOWNLOAD) throw new Error("插件包过大");
+  return bytes;
+}
+
+function preview(bytes, { source, trusted = false, sha256 = "" }) {
+  const hash = createHash("sha256").update(bytes).digest("hex");
+  if (sha256 && sha256.toLowerCase() !== hash)
+    throw new Error("插件包校验不符");
+  const files = stripRoot(readZip(bytes));
+  const manifestFile = files.find(
+    (file) => file.name === "luckytri-plugin.json",
+  );
+  if (!manifestFile) throw new Error("插件清单无法读取");
+  const manifest = validateManifest(
+    JSON.parse(manifestFile.bytes.toString("utf8")),
+  );
+  return {
+    token: randomUUID(),
+    bytes,
+    files,
+    manifest,
+    sha256: hash,
+    source,
+    trusted: trusted && !!sha256,
+    at: Date.now(),
+  };
+}
+
+export function createInstaller(host) {
+  const staged = new Map();
+  function remember(item) {
+    for (const [token, old] of staged)
+      if (Date.now() - old.at > STAGED_FOR) staged.delete(token);
+    staged.set(item.token, item);
+    return describe(item);
+  }
+  function describe(item) {
+    return {
+      token: item.token,
+      trusted: item.trusted,
+      sha256: item.sha256,
+      source: item.source,
+      manifest: item.manifest,
+      permissions: item.manifest.permissions,
+      network: item.manifest.network,
+    };
+  }
+  return {
+    async stageUrl({ url, sha256 = "" }) {
+      const bytes = await download(url);
+      return remember(
+        preview(bytes, { source: "url", sha256, trusted: !!sha256 }),
+      );
+    },
+    async stageRegistry({ url, sha256, id }) {
+      const bytes = await download(url);
+      const item = preview(bytes, { source: "market", sha256, trusted: true });
+      if (id && item.manifest.id !== id) throw new Error("插件包和索引不一致");
+      return remember(item);
+    },
+    async stageGithub(repository) {
+      const parsed = new URL(repository);
+      if (parsed.hostname !== "github.com") throw new Error("这个地址不能访问");
+      const [owner, repo] = parsed.pathname.split("/").filter(Boolean);
+      if (!owner || !repo) throw new Error("插件仓库地址无效");
+      const name = repo.replace(/\.git$/, "");
+      let bytes;
+      try {
+        const release = await download(
+          `https://api.github.com/repos/${owner}/${name}/releases/latest`,
+        );
+        const data = JSON.parse(bytesToText(release));
+        const asset = (data.assets || []).find((item) =>
+          String(item.name || "").endsWith(".zip"),
+        );
+        bytes = await download(asset?.browser_download_url || data.zipball_url);
+      } catch {
+        bytes = await download(
+          `https://codeload.github.com/${owner}/${name}/zip/refs/heads/main`,
+        );
+      }
+      return remember(preview(bytes, { source: "github", trusted: false }));
+    },
+    stageUpload(bytes) {
+      return remember(
+        preview(Buffer.from(bytes), { source: "upload", trusted: false }),
+      );
+    },
+    stageDir(dir) {
+      const manifest = readManifest(dir);
+      const item = {
+        token: randomUUID(),
+        dir,
+        manifest,
+        sha256: "",
+        source: "dev",
+        trusted: false,
+        at: Date.now(),
+      };
+      return remember(item);
+    },
+    commit(token) {
+      const item = staged.get(token);
+      if (!item || Date.now() - item.at > STAGED_FOR)
+        throw new Error("这次导入已经过期");
+      const { manifest } = item;
+      const target =
+        item.source === "dev"
+          ? item.dir
+          : join(host.dataRoot, manifest.id, manifest.version);
+      if (item.source !== "dev") {
+        rmSync(target, { recursive: true, force: true });
+        mkdirSync(target, { recursive: true });
+        writeTree(target, item.files);
+        const checked = readManifest(target);
+        if (checked.id !== manifest.id || checked.version !== manifest.version)
+          throw new Error("插件包和索引不一致");
+      }
+      host.db
+        .prepare(
+          `INSERT INTO plugin_installs(id,version,enabled,state,source,sha256,api,permissions,granted,manifest,path,error,installed,updated)
+           VALUES (?,?,0,'installed',?,?,?,?,'[]',?,?, '',?,?)
+           ON CONFLICT(id) DO UPDATE SET version=excluded.version,source=excluded.source,sha256=excluded.sha256,api=excluded.api,permissions=excluded.permissions,manifest=excluded.manifest,path=excluded.path,error='',updated=excluded.updated`,
+        )
+        .run(
+          manifest.id,
+          manifest.version,
+          item.source,
+          item.sha256,
+          manifest.pluginApi,
+          JSON.stringify(manifest.permissions),
+          JSON.stringify(manifest),
+          target,
+          host.now(),
+          host.now(),
+        );
+      staged.delete(token);
+      host.store.revision++;
+      return host.list().find((row) => row.id === manifest.id);
+    },
+    async registries() {
+      const saved = host.db
+        .prepare("SELECT id,url FROM plugin_sources ORDER BY created")
+        .all();
+      if (saved.length) return saved;
+      const url =
+        "https://raw.githubusercontent.com/TodayYueC/LuckyTri-Plugins/main/index.json";
+      return [{ id: "default", url }];
+    },
+    saveRegistry(url) {
+      const parsed = new URL(url);
+      if (parsed.protocol !== "https:") throw new Error("这个地址不能访问");
+      const id = createHash("sha256").update(url).digest("hex").slice(0, 16);
+      host.db
+        .prepare(
+          "INSERT INTO plugin_sources(id,url,created) VALUES (?,?,?) ON CONFLICT(id) DO UPDATE SET url=excluded.url",
+        )
+        .run(id, url, host.now());
+      return id;
+    },
+    removeRegistry(id) {
+      host.db.prepare("DELETE FROM plugin_sources WHERE id=?").run(id);
+    },
+    async catalog() {
+      const plugins = [];
+      let unavailable = false;
+      for (const source of await this.registries()) {
+        try {
+          const bytes = await download(source.url, 0, 8000);
+          const index = JSON.parse(bytes.toString("utf8"));
+          if (index.format !== 1 || !Array.isArray(index.plugins))
+            throw new Error("插件索引无效");
+          for (const plugin of index.plugins) {
+            const versions = (plugin.versions || []).filter(
+              (item) =>
+                item.pluginApi &&
+                satisfies(item.luckytri || ">=1.0.0 <2.0.0", VERSION),
+            );
+            if (!versions.length) continue;
+            plugins.push({
+              ...plugin,
+              source: source.url,
+              versions,
+              latest: versions[versions.length - 1],
+            });
+          }
+        } catch {
+          unavailable = true;
+        }
+      }
+      return { plugins, unavailable };
+    },
+    async remove(id, { data = false } = {}) {
+      await host.disable(id);
+      const row = host.db
+        .prepare("SELECT * FROM plugin_installs WHERE id=?")
+        .get(id);
+      if (row?.source !== "builtin" && row?.source !== "dev" && row?.path)
+        rmSync(row.path, { recursive: true, force: true });
+      if (data) {
+        rmSync(join(host.dataRoot, id, "data"), {
+          recursive: true,
+          force: true,
+        });
+        host.db
+          .prepare("DELETE FROM plugin_settings WHERE plugin_id=?")
+          .run(id);
+        host.db.prepare("DELETE FROM plugin_kv WHERE plugin_id=?").run(id);
+      }
+      if (row?.source !== "builtin")
+        host.db.prepare("DELETE FROM plugin_installs WHERE id=?").run(id);
+      else
+        host.db
+          .prepare(
+            "UPDATE plugin_installs SET enabled=0,state='installed',granted='[]' WHERE id=?",
+          )
+          .run(id);
+      host.store.revision++;
+      return host.list();
+    },
+    rollback(id) {
+      const row = host.db
+        .prepare("SELECT * FROM plugin_installs WHERE id=?")
+        .get(id);
+      if (!row) throw new Error("插件不存在");
+      const parent = join(host.dataRoot, id);
+      const versions = readdirSync(parent).filter(
+        (name) => name !== "data" && name !== row.version,
+      );
+      const previous = versions.sort().at(-1);
+      if (!previous) throw new Error("没有可以退回的版本");
+      const dir = join(parent, previous);
+      const manifest = readManifest(dir);
+      host.db
+        .prepare(
+          "UPDATE plugin_installs SET version=?,path=?,manifest=?,permissions=?,updated=? WHERE id=?",
+        )
+        .run(
+          manifest.version,
+          dir,
+          JSON.stringify(manifest),
+          JSON.stringify(manifest.permissions),
+          host.now(),
+          id,
+        );
+      host.store.revision++;
+      return host.list().find((item) => item.id === id);
+    },
+  };
+}
+
+function bytesToText(bytes) {
+  return Buffer.from(bytes).toString("utf8");
+}
+
+export function copyPlugin(from, to) {
+  mkdirSync(to, { recursive: true });
+  cpSync(from, to, { recursive: true });
+}

package/server/plugins/manifest.js

@@ -0,0 +1,201 @@
+import { readFileSync } from "node:fs";
+import { join, normalize, sep } from "node:path";
+import { VERSION } from "../version.js";
+import { API_VERSION, permissionKnown } from "./permissions.js";
+
+export const RESERVED_IDS = new Set([
+  "onebot",
+  "qqbot",
+  "preview",
+  "core",
+  "mind",
+  "luckytri",
+]);
+const ID = /^[a-z][a-z0-9-]{1,39}$/;
+const SETTING_KEY = /^[a-z][A-Za-z0-9-]{0,39}$/;
+const SEMVER =
+  /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/;
+const HOST = /^[a-z0-9.-]+$/i;
+
+export function parseVersion(value) {
+  const match = SEMVER.exec(String(value || ""));
+  if (!match) return null;
+  return match.slice(1, 4).map(Number);
+}
+
+export function satisfies(range, version) {
+  const have = parseVersion(version);
+  if (!have || typeof range !== "string") return false;
+  const parts = range.trim().split(/\s+/);
+  return parts.every((part) => {
+    const match = /^(>=|>|<=|<)?(\d+\.\d+\.\d+)$/.exec(part);
+    if (!match) return false;
+    const op = match[1] || "=";
+    const want = parseVersion(match[2]);
+    const cmp = have[0] - want[0] || have[1] - want[1] || have[2] - want[2];
+    if (op === ">=") return cmp >= 0;
+    if (op === ">") return cmp > 0;
+    if (op === "<=") return cmp <= 0;
+    if (op === "<") return cmp < 0;
+    return cmp === 0;
+  });
+}
+
+export function apiCompatible(wanted, host = API_VERSION) {
+  const plugin = parseVersion(`${wanted}.0`);
+  const current = parseVersion(`${host}.0`);
+  if (!plugin || !current) return false;
+  return plugin[0] === current[0] && plugin[1] <= current[1];
+}
+
+function setting(field) {
+  const types = [
+    "text",
+    "secret",
+    "number",
+    "boolean",
+    "select",
+    "textarea",
+    "urls",
+  ];
+  if (
+    !field ||
+    !SETTING_KEY.test(field.key || "") ||
+    !types.includes(field.type)
+  )
+    throw Error("插件设置项无效");
+  if (typeof field.label !== "string" || !field.label.trim())
+    throw Error("插件设置项无效");
+  if (field.type === "select" && !Array.isArray(field.options))
+    throw Error("插件设置项无效");
+  return {
+    key: field.key,
+    type: field.type,
+    label: String(field.label).slice(0, 80),
+    required: !!field.required,
+    default: field.default ?? (field.type === "boolean" ? false : ""),
+    ...(field.allowNetwork ? { allowNetwork: true } : {}),
+    ...(Array.isArray(field.options)
+      ? {
+          options: field.options.slice(0, 20).map((item) => ({
+            value: String(item.value ?? item).slice(0, 80),
+            label: String(item.label ?? item.value ?? item).slice(0, 80),
+          })),
+        }
+      : {}),
+  };
+}
+
+function named(list, pattern, map) {
+  if (!Array.isArray(list)) return [];
+  return list.map((item) => {
+    const value = map(item);
+    if (!pattern.test(value.name || value.kind || value.type || ""))
+      throw Error("插件贡献的名字无效");
+    return value;
+  });
+}
+
+// A manifest is data. Anything that does not fit is refused before the
+// plugin process is ever started.
+export function readManifest(dir) {
+  let raw;
+  try {
+    raw = JSON.parse(readFileSync(join(dir, "luckytri-plugin.json"), "utf8"));
+  } catch {
+    throw Error("插件清单无法读取");
+  }
+  return validateManifest(raw);
+}
+
+export function validateManifest(raw, version = VERSION) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw))
+    throw Error("插件清单无效");
+  if (!ID.test(raw.id || "") || RESERVED_IDS.has(raw.id))
+    throw Error("插件标识无效");
+  if (!parseVersion(raw.version)) throw Error("插件版本号无效");
+  if (!apiCompatible(raw.pluginApi)) throw Error("插件 API 版本不兼容");
+  if (raw.luckytri && !satisfies(raw.luckytri, version))
+    throw Error("插件不支持这个 LuckyTri 版本");
+  const entry = normalize(String(raw.entry || "index.js"));
+  if (
+    !entry ||
+    entry.startsWith("..") ||
+    entry.startsWith("/") ||
+    entry.includes(`..${sep}`) ||
+    entry.includes("..\\") ||
+    entry.includes("../")
+  )
+    throw Error("插件入口无效");
+  const permissions = [...new Set(raw.permissions || [])];
+  if (permissions.some((item) => !permissionKnown(item)))
+    throw Error("插件权限无效");
+  const network = [
+    ...new Set((raw.network || []).map((host) => String(host).toLowerCase())),
+  ];
+  if (network.some((host) => !HOST.test(host) || host.length > 200))
+    throw Error("插件网络主机无效");
+  const name = String(raw.name || "")
+    .trim()
+    .slice(0, 40);
+  if (!name) throw Error("插件清单无效");
+  const contributes = raw.contributes || {};
+  const short = /^[a-z][a-z0-9-]{0,40}$/;
+  return {
+    id: raw.id,
+    name,
+    version: raw.version,
+    pluginApi: raw.pluginApi,
+    luckytri: raw.luckytri || "",
+    description: String(raw.description || "").slice(0, 400),
+    author: String(raw.author || "").slice(0, 80),
+    license: String(raw.license || "").slice(0, 40),
+    entry,
+    permissions,
+    network,
+    settings: (raw.settings || []).map(setting),
+    contributes: {
+      senses: (contributes.senses || []).map((key) => {
+        if (!short.test(key)) throw Error("插件贡献的名字无效");
+        return key;
+      }),
+      channels: named(contributes.channels, short, (item) => ({
+        type: item.type === raw.id ? item.type : `${raw.id}-${item.type}`,
+        label: String(item.label || item.type).slice(0, 40),
+        capabilities: item.capabilities || {},
+        mediaHosts: String(item.mediaHosts || "").slice(0, 200),
+      })),
+      activities: (contributes.activities || []).map((item) => {
+        if (!short.test(item?.kind || "")) throw Error("插件贡献的名字无效");
+        return {
+          kind: `${raw.id}.${item.kind}`,
+          label: String(item.label || item.kind).slice(0, 40),
+          describe: String(item.describe || "").slice(0, 160),
+          keywords: String(item.keywords || "").slice(0, 200),
+          minutes: Number(item.minutes) || 15,
+          energy: !!item.energy,
+        };
+      }),
+      actions: (contributes.actions || []).map((item) => {
+        if (!short.test(item?.name || "")) throw Error("插件贡献的名字无效");
+        return {
+          name: `${raw.id}.${item.name}`,
+          label: String(item.label || item.name).slice(0, 40),
+          describe: String(item.describe || "").slice(0, 160),
+          input: Array.isArray(item.input) ? item.input.slice(0, 12) : [],
+          risk: item.risk === "high" ? "high" : "low",
+          confirm: item.confirm === "owner" ? "owner" : "none",
+          where: item.where === "any" ? "any" : "private",
+          dailyLimit: Number.isInteger(item.dailyLimit) ? item.dailyLimit : 20,
+        };
+      }),
+      perceive: (contributes.perceive || []).map((type) => {
+        const value = String(type).slice(0, 40);
+        if (!value) throw Error("插件贡献的名字无效");
+        return value;
+      }),
+      page: !!contributes.ui?.page,
+    },
+    i18n: raw.i18n && typeof raw.i18n === "object" ? raw.i18n : {},
+  };
+}

package/server/plugins/permissions.js

@@ -0,0 +1,42 @@
+// What a plugin may be given. The risk is shown when the owner agrees;
+// the host is what actually refuses a call the plugin was not given.
+export const PERMISSIONS = {
+  "mind.read": {
+    risk: "low",
+    label: "知道她醒着没有、心情和在做什么",
+  },
+  notify: { risk: "low", label: "给工作室发一条通知" },
+  ui: { risk: "low", label: "在工作室里放一个自己的页面" },
+  "http.routes": { risk: "low", label: "给自己的页面提供接口" },
+  senses: { risk: "medium", label: "把感知放进她的此刻" },
+  observe: { risk: "medium", label: "把发生的事作为经历交给她" },
+  "knowledge.offer": { risk: "medium", label: "往她的书架放资料" },
+  activities: { risk: "medium", label: "给她一件可以自己做的事" },
+  models: { risk: "medium", label: "使用她的模型服务" },
+  "net.fetch": { risk: "medium", label: "访问声明过的网站" },
+  actions: { risk: "high", label: "让她可以选择做一件事" },
+  perceive: { risk: "high", label: "读取聊天里的附件" },
+  channel: { risk: "high", label: "接入一个平台，并看到那里的消息" },
+  "http.public": { risk: "high", label: "开放一个不需要令牌的地址" },
+  "net.raw": { risk: "high", label: "自己直接联网" },
+};
+
+export const API_VERSION = "1.0";
+export const API_FEATURES = [
+  "senses",
+  "observe",
+  "activities",
+  "actions",
+  "perceive",
+  "channel",
+  "knowledge",
+  "models",
+  "http",
+  "notify",
+  "mind.read",
+  "ui",
+];
+
+export function permissionKnown(name) {
+  return Object.hasOwn(PERMISSIONS, name);
+}

package/server/plugins/runner/guard.mjs

@@ -0,0 +1,36 @@
+import { registerHooks } from "node:module";
+
+// A plugin process may use the language. It may not open the database, start
+// another process, or reach the network unless it was explicitly allowed to.
+const raw = process.env.LUCKYTRI_NET_RAW === "1";
+const blocked = new Set([
+  "sqlite",
+  "child_process",
+  "worker_threads",
+  "cluster",
+  "inspector",
+  ...(raw
+    ? []
+    : ["net", "http", "https", "tls", "dgram", "dns", "http2", "tls"]),
+]);
+
+function denied(specifier) {
+  const name = String(specifier || "").replace(/^node:/, "");
+  const root = name.split("/")[0];
+  return blocked.has(name) || blocked.has(root);
+}
+
+registerHooks({
+  resolve(specifier, context, next) {
+    if (denied(specifier)) {
+      const error = new Error("插件没有这个能力");
+      error.code = "ERR_PLUGIN_DENIED";
+      throw error;
+    }
+    return next(specifier, context);
+  },
+});
+
+process.kill = () => {
+  throw new Error("插件不能结束别的进程");
+};