@yep-ai/cli 0.0.0-stage → 1.0.0

package/bin/yep.js

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+import { runMarketplace } from "./market.js";
+import { runDevice } from "../lib/device/command.js";
+const argv = process.argv.slice(2);
+try {
+  if (argv[0] === "device") await runDevice(argv.slice(1));
+  else await runMarketplace(argv);
+} catch (error) {
+  console.error(error.message);
+  process.exitCode = 1;
+}

package/lib/device/client.js

@@ -0,0 +1,411 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import os from "node:os";
+import { createHash, randomUUID } from "node:crypto";
+import { spawn } from "node:child_process";
+import WebSocket from "ws";
+import { rootDescriptor, resolveSafe, list, execute } from "./tools.js";
+const PROTOCOL = 2;
+const DEFAULT_SERVER = "https://yep.nihao.cool";
+function serverOrigin(value) {
+  const u = new URL(value);
+  if (u.username || u.password || u.search || u.hash || u.pathname !== "/") throw new Error("--server must be an origin");
+  const local = ["localhost", "127.0.0.1", "[::1]"].includes(u.hostname);
+  if (u.protocol !== "https:" && !(u.protocol === "http:" && local)) throw new Error("HTTPS required (HTTP only for loopback development)");
+  return u.origin;
+}
+function configDirectory() {
+  return process.env.YEP_DEVICE_CONFIG_DIR || path.join(process.env.YEP_CONFIG_DIR || path.join(process.env.YEP_HOME || os.homedir(), ".config", "yep"), "devices");
+}
+async function protect(location, directory = false) {
+  if (process.platform === "win32") {
+    await new Promise((resolve, reject) => {
+      const identity = process.env.USERDOMAIN ? `${process.env.USERDOMAIN}\\${process.env.USERNAME}` : process.env.USERNAME;
+      if (!identity) return reject(new Error("Cannot determine Windows account for private credentials"));
+      const p = spawn("icacls", [location, "/inheritance:r", "/grant:r", `${identity}:${directory ? "(OI)(CI)" : ""}F`], { stdio: "ignore", windowsHide: true });
+      p.on("error", reject);
+      p.on("exit", (code) => code === 0 ? resolve() : reject(new Error("Failed to restrict Windows credential ACL")));
+    });
+  } else await fs.chmod(location, directory ? 448 : 384);
+}
+async function checkPrivate(location, directory = false) {
+  const st = await fs.lstat(location);
+  if (st.isSymbolicLink() || directory && !st.isDirectory() || !directory && !st.isFile()) throw new Error("Unsafe CLI credential path");
+  if (process.platform !== "win32" && ((st.mode & 63) !== 0 || st.uid !== process.getuid())) throw new Error("CLI credential permissions are unsafe; correct ownership and permissions");
+  if (process.platform === "win32") {
+    const script = "$ErrorActionPreference='Stop'; $acl=Get-Acl -LiteralPath $env:YEP_DEVICE_ACL_PATH; if(-not $acl.AreAccessRulesProtected){exit 2}; $sid=[System.Security.Principal.WindowsIdentity]::GetCurrent().User.Value; foreach($rule in $acl.Access){ if($rule.AccessControlType -eq 'Allow'){ $who=$rule.IdentityReference.Translate([System.Security.Principal.SecurityIdentifier]).Value; if($who -ne $sid -and $who -ne 'S-1-5-18' -and $who -ne 'S-1-5-32-544'){exit 3} } }; exit 0";
+    await new Promise((resolve, reject) => {
+      const child = spawn("powershell.exe", ["-NoProfile", "-NonInteractive", "-Command", script], { env: { ...process.env, YEP_DEVICE_ACL_PATH: location }, stdio: "ignore", windowsHide: true });
+      child.on("error", () => reject(new Error("Cannot verify Windows private credential ACL")));
+      child.on("exit", (code) => code === 0 ? resolve() : reject(new Error("Windows credential ACL is unsafe; restrict access to the current account")));
+    });
+  }
+  return st;
+}
+async function initializeConfig(directory = configDirectory()) {
+  try {
+    const created = await fs.mkdir(directory, { recursive: true, mode: 448 });
+    if (created) await protect(directory, true);
+    await checkPrivate(directory, true);
+  } catch (e) {
+    if (e.code !== "ENOENT") throw e;
+  }
+  ;
+  const uuidPath = path.join(directory, "installation-id");
+  let installationId;
+  try {
+    await checkPrivate(uuidPath);
+    installationId = (await fs.readFile(uuidPath, "utf8")).trim();
+    if (!/^[0-9a-f-]{36}$/u.test(installationId)) throw new Error("Corrupt installation identity");
+  } catch (e) {
+    if (e.code !== "ENOENT") throw e;
+    installationId = randomUUID();
+    await fs.writeFile(uuidPath, installationId, { mode: 384, flag: "wx" });
+    await protect(uuidPath);
+  }
+  ;
+  return { directory, installationId };
+}
+function credentialPath(directory, server) {
+  return path.join(directory, createHash("sha256").update(server).digest("hex") + ".json");
+}
+async function loadCredential(directory, server) {
+  const location = credentialPath(directory, server);
+  try {
+    await checkPrivate(location);
+    const v = JSON.parse(await fs.readFile(location, "utf8"));
+    if (v.server !== server || typeof v.token !== "string" || !v.deviceId || !Number.isFinite(Date.parse(v.expiresAt))) throw new Error("Corrupt or wrong-origin device credential");
+    return v;
+  } catch (e) {
+    if (e.code === "ENOENT") return null;
+    throw e;
+  }
+}
+async function saveCredential(directory, server, value) {
+  const location = credentialPath(directory, server);
+  const temporary = location + "." + randomUUID();
+  await fs.writeFile(temporary, JSON.stringify({ ...value, server }), { mode: 384, flag: "wx" });
+  await protect(temporary);
+  await fs.rename(temporary, location);
+}
+async function loadDefaultServer(directory) {
+  const location = path.join(directory, "default-server.json");
+  try {
+    await checkPrivate(location);
+    return serverOrigin(JSON.parse(await fs.readFile(location, "utf8")).server);
+  } catch (error) {
+    if (error.code === "ENOENT") return DEFAULT_SERVER;
+    throw error;
+  }
+}
+async function rememberServer(directory, server) {
+  const location = path.join(directory, "default-server.json");
+  try { await checkPrivate(location); } catch (error) { if (error.code !== "ENOENT") throw error; }
+  const temporary = location + "." + randomUUID();
+  await fs.writeFile(temporary, JSON.stringify({ server: serverOrigin(server) }), { mode: 0o600, flag: "wx" });
+  await protect(temporary);
+  await fs.rename(temporary, location);
+}
+async function api(server, route, { token, body, method = "GET" } = {}) {
+  const response = await fetch(server + route, { method, headers: { ...token ? { Authorization: `Bearer ${token}` } : {}, ...body ? { "Content-Type": "application/json" } : {} }, body: body ? JSON.stringify(body) : void 0, signal: AbortSignal.timeout(15e3), redirect: "error" });
+  let result;
+  try {
+    result = await response.json();
+  } catch {
+    throw new Error("Server returned an invalid response");
+  }
+  ;
+  if (!response.ok) {
+    const e = new Error(result.error || `HTTP ${response.status}`);
+    e.status = response.status;
+    throw e;
+  }
+  return result;
+}
+function openBrowser(url) {
+  const exe = process.platform === "win32" ? "rundll32" : process.platform === "darwin" ? "open" : "xdg-open";
+  const args = process.platform === "win32" ? ["url.dll,FileProtocolHandler", url] : [url];
+  const child = spawn(exe, args, { stdio: "ignore", detached: true, windowsHide: true });
+  child.on("error", () => {
+  });
+  child.unref();
+}
+async function login(server, config, { name = os.hostname(), noOpen = false, signal } = {}) {
+  const result = await api(server, "/api/local-cli/login/start", { method: "POST", body: { installationId: config.installationId, name, platform: process.platform } });
+  const verify = new URL(result.verificationUri);
+  if (verify.origin !== server) throw new Error("Server returned a pairing URL for another origin");
+  console.log(`在网页核对设备「${name}」及确认码 ${result.userCode}：
+${verify.href}`);
+  if (!noOpen) openBrowser(verify.href);
+  while (Date.now() < Date.parse(result.expiresAt)) {
+    await new Promise((resolve, reject) => {
+      const t = setTimeout(resolve, Math.max(2, result.interval) * 1e3);
+      signal?.addEventListener("abort", () => {
+        clearTimeout(t);
+        reject(new Error("Pairing canceled"));
+      }, { once: true });
+    });
+    if (signal?.aborted) throw new Error("Pairing canceled");
+    let response;
+    try {
+      response = await api(server, "/api/local-cli/login/poll", { method: "POST", body: { deviceCode: result.deviceCode } });
+    } catch (e) {
+      if (e.message === "slow_down") continue;
+      throw e;
+    }
+    ;
+    if (response.status === "denied") throw new Error("Device authorization was denied");
+    if (response.status === "authorized") {
+      await saveCredential(config.directory, server, response);
+      console.log("设备授权已保存（最多24小时）。");
+      return response;
+    }
+    if (response.status === "claimed") throw new Error("Pairing credential was already claimed");
+  }
+  ;
+  throw new Error("Pairing expired");
+}
+async function systemRoots(privateDir) {
+  let directories;
+  if (process.platform === "win32") {
+    directories = [];
+    for (const letter of "ABCDEFGHIJKLMNOPQRSTUVWXYZ") {
+      const drive = letter + ":\\";
+      try {
+        await fs.access(drive);
+        directories.push(drive);
+      } catch {
+      }
+    }
+  } else directories = ["/"];
+  return Promise.all(directories.map(async (p, i) => {
+    const root = await rootDescriptor("root-" + (i + 1), p, privateDir);
+    if (process.platform === "win32") root.name = `${p[0]} 盘`;
+    return root;
+  }));
+}
+class DeviceAgent {
+  constructor(roots, { restricted = true, privateDir, token, connectionId, expiresAt } = {}) {
+    this.roots = roots;
+    this.restricted = restricted;
+    this.privateDir = privateDir;
+    this.token = token;
+    this.connectionId = connectionId;
+    this.expiresAt = expiresAt;
+    this.closed = false;
+    this.bindings = /* @__PURE__ */ new Map();
+    this.active = /* @__PURE__ */ new Map();
+  }
+  publicRoots() {
+    return this.roots.map(({ id, name }) => ({ id, name }));
+  }
+  cancel(frame = {}) {
+    const waiting = [];
+    for (const [id, op] of this.active) {
+      if (!frame.id && !frame.roundId && !frame.bindingId || frame.id === id || frame.roundId === op.roundId || frame.bindingId === op.bindingId) {
+        op.abort.abort();
+        waiting.push(op.done);
+      }
+    }
+    return Promise.allSettled(waiting);
+  }
+  close() {
+    this.closed = true;
+    this.cancel();
+    this.bindings.clear();
+  }
+  async frame(frame) {
+    if (this.closed) throw new Error("Stale device connection");
+    if (this.expiresAt && Date.now() >= Date.parse(this.expiresAt)) {
+      this.close();
+      throw new Error("Device authorization expired");
+    }
+    const base = { id: frame.id, consultationId: frame.consultationId, bindingId: frame.bindingId, roundId: frame.roundId };
+    if (frame.type === "cancel") {
+      await this.cancel(frame);
+      return null;
+    }
+    if (frame.type === "unbound") {
+      const pending = this.cancel(frame);
+      this.bindings.delete(frame.bindingId);
+      await pending;
+      return null;
+    }
+    if (frame.type === "browse") {
+      const root2 = this.roots.find((x) => x.id === frame.folderId);
+      if (!root2) throw new Error("Unknown root");
+      return { ...base, type: "browse_result", browse: await list(root2, frame.path ?? "", frame.offset ?? 0, frame.includeFiles !== false) };
+    }
+    if (frame.type === "bind") {
+      if (!Array.isArray(frame.folders) || frame.folders.length < 1 || frame.folders.length > 5 || !["full", "confirm", "read-only"].includes(frame.permissionMode)) throw new Error("Invalid binding");
+      const folders = [];
+      for (const item of frame.folders) {
+        const source = this.roots.find((x) => x.id === item.id);
+        if (!source) throw new Error("Unknown root");
+        const resolved = await resolveSafe(source, item.path ?? "", item.kind === "file" ? "file" : "directory");
+        const targetFile = item.kind === "file" ? path.basename(resolved.absolute) : void 0;
+        const absolute = targetFile ? path.dirname(resolved.absolute) : resolved.absolute;
+        const root2 = await rootDescriptor("folder-" + randomUUID(), absolute, this.privateDir);
+        if (targetFile) root2.targetFile = targetFile;
+        folders.push(root2);
+      }
+      const id = frame.bindingId || frame.id;
+      if (this.closed) throw new Error("Stale device connection");
+      this.bindings.set(id, { id, consultationId: frame.consultationId, permissionMode: frame.permissionMode, permissionVersion: frame.permissionVersion ?? 1, folders });
+      return { ...base, type: "bind_result", approved: true, folders: folders.map(({ id: id2, name, targetFile }) => ({ id: id2, name, targetFile })) };
+    }
+    if (frame.type === "permissions") {
+      const binding2 = this.bindings.get(frame.bindingId);
+      if (!binding2 || binding2.changing || binding2.consultationId !== frame.consultationId || !["full", "confirm", "read-only"].includes(frame.permissionMode) || frame.permissionVersion !== binding2.permissionVersion + 1) throw new Error("Invalid permission change");
+      binding2.changing = true;
+      await this.cancel({ bindingId: frame.bindingId });
+      binding2.permissionMode = frame.permissionMode;
+      binding2.permissionVersion = frame.permissionVersion;
+      binding2.changing = false;
+      return { ...base, type: "permissions_result", approved: true, permissionVersion: binding2.permissionVersion };
+    }
+    if (frame.type !== "request") return null;
+    if (this.active.size >= 8 || this.active.has(frame.id)) throw new Error("Too many or duplicate local operations");
+    const binding = this.bindings.get(frame.bindingId);
+    if (!binding || binding.changing || binding.consultationId !== frame.consultationId || frame.connectionId !== this.connectionId || frame.permissionVersion !== binding.permissionVersion || frame.permissionMode !== binding.permissionMode) throw new Error("Stale connection, binding or permission");
+    const request = frame.request;
+    if (!request || typeof request !== "object") throw new Error("Invalid request");
+    if (request.operation === "exec" && binding.permissionMode === "read-only" || ["exec", "read"].includes(request.operation) && binding.permissionMode === "confirm" && frame.approved !== true) throw new Error("Operation requires current approval");
+    const root = binding.folders.find((x) => x.id === request.folderId);
+    if (!root) throw new Error("Folder outside binding");
+    const abort = new AbortController();
+    let complete;
+    const done = new Promise((resolve) => {
+      complete = resolve;
+    });
+    this.active.set(frame.id, { abort, bindingId: frame.bindingId, roundId: frame.roundId, done });
+    try {
+      const result = await execute(root, request, { restricted: this.restricted, signal: abort.signal, secrets: [this.token] });
+      if (abort.signal.aborted || this.bindings.get(frame.bindingId) !== binding || frame.permissionVersion !== binding.permissionVersion) throw new Error("Authorization changed during operation");
+      return { ...base, type: "result", result };
+    } finally {
+      this.active.delete(frame.id);
+      complete();
+    }
+  }
+}
+async function start(server, config, credential, directories, { name, noOpen, signal } = {}) {
+  const restricted = directories.length > 0;
+  if (directories.length > 5) throw new Error("At most five startup directories");
+  const roots = restricted ? await Promise.all(directories.map((p, i) => rootDescriptor("root-" + (i + 1), p, config.directory))) : await systemRoots(config.directory);
+  if (!roots.length) throw new Error("No accessible filesystem roots");
+  console.log(restricted ? "受限目录模式：仅内置命令，不能启动 shell 或外部程序。" : "完整系统模式：网页授权执行的命令拥有当前系统用户权限，可访问其他文件和网络；这不是沙箱。");
+  let delay = 1e3;
+  while (!signal?.aborted) {
+    if (Date.now() >= Date.parse(credential.expiresAt)) throw new Error("Device authorization expired; run login again");
+    let fatal;
+    await new Promise((resolve, reject) => {
+      const url = new URL("/api/local-cli/connect", server);
+      url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
+      const ws = new WebSocket(url, { headers: { Authorization: `Bearer ${credential.token}` }, maxPayload: 15 * 1024 * 1024, handshakeTimeout: 15e3, followRedirects: false });
+      const agent = new DeviceAgent(roots, { restricted, privateDir: config.directory, token: credential.token, expiresAt: credential.expiresAt });
+      let ready = false;
+      let heartbeat;
+      const cleanup = () => {
+        clearInterval(heartbeat);
+        agent.close();
+        signal?.removeEventListener("abort", abort);
+      };
+      const abort = () => {
+        ready = false;
+        agent.close();
+        ws.close();
+      };
+      signal?.addEventListener("abort", abort, { once: true });
+      ws.on("open", () => {
+        ws.send(JSON.stringify({ type: "hello", protocol: PROTOCOL, consentVersion: "yep-device-v2", directoryMode: restricted ? "restricted" : "system", folders: agent.publicRoots(), commandsEnabled: true, fileSelection: true }));
+      });
+      ws.on("unexpected-response", (_req, res) => {
+        if ([401, 403].includes(res.statusCode)) {
+          fatal = new Error("Device authorization expired or revoked");
+          ws.terminate();
+        }
+      });
+      ws.on("message", async (bytes) => {
+        if (fatal || signal?.aborted) return;
+        let frame;
+        try {
+          frame = JSON.parse(bytes.toString());
+          if (frame.type === "ready") {
+            if (frame.protocol !== PROTOCOL) throw new Error("Unsupported server protocol");
+            agent.connectionId = frame.connectionId;
+            ready = true;
+            delay = 1e3;
+            console.log("设备已上线。请在网页选择目录；退出此终端将断开。");
+            heartbeat = setInterval(() => {
+              if (Date.now() >= Date.parse(credential.expiresAt)) {
+                fatal = new Error("Device authorization expired");
+                agent.close();
+                ws.close();
+                return;
+              }
+              if (ws.readyState === WebSocket.OPEN) ws.send(JSON.stringify({ type: "ping" }));
+            }, 1e4);
+            return;
+          }
+          if (["revoked", "expired", "replaced"].includes(frame.type)) {
+            fatal = new Error(`Device ${frame.type}; local operations stopped`);
+            ready = false;
+            agent.close();
+            ws.close();
+            return;
+          }
+          if (frame.type === "ping") {
+            ws.send(JSON.stringify({ type: "pong" }));
+            return;
+          }
+          if (!ready) return;
+          const result = await agent.frame(frame);
+          if (result && ws.readyState === WebSocket.OPEN) ws.send(JSON.stringify(result));
+        } catch (e) {
+          if (fatal || signal?.aborted) return;
+          if (frame?.id && ws.readyState === WebSocket.OPEN) {
+            let error = String(e.message).split(credential.token).join("[REDACTED]").split(config.directory).join("[私有目录]");
+            for (const root of [...agent.roots].sort((a, b) => b.absolute.length - a.absolute.length)) error = error.split(root.absolute).join("[授权目录]");
+            ws.send(JSON.stringify({ type: "result", id: frame.id, bindingId: frame.bindingId, consultationId: frame.consultationId, error: error.slice(0, 8192) }));
+          } else {
+            fatal = e;
+            ws.close();
+          }
+        }
+      });
+      ws.on("error", () => {
+      });
+      ws.on("close", () => {
+        cleanup();
+        resolve();
+      });
+    });
+    if (fatal) throw fatal;
+    if (signal?.aborted) break;
+    console.log(`连接已断开；${Math.ceil(delay / 1e3)}秒后重连。原咨询绑定已失效，重连后需重新选择。`);
+    await new Promise((resolve) => {
+      const t = setTimeout(resolve, delay);
+      signal?.addEventListener("abort", () => {
+        clearTimeout(t);
+        resolve();
+      }, { once: true });
+    });
+    delay = Math.min(delay * 2, 3e4);
+  }
+}
+export {
+  DeviceAgent,
+  PROTOCOL,
+  api,
+  configDirectory,
+  credentialPath,
+  initializeConfig,
+  loadCredential,
+  loadDefaultServer,
+  login,
+  rememberServer,
+  saveCredential,
+  serverOrigin,
+  start
+};

package/lib/device/command.js

@@ -0,0 +1,93 @@
+#!/usr/bin/env node
+import fs from "node:fs/promises";
+import { readFileSync } from "node:fs";
+const { version } = JSON.parse(readFileSync(new URL("../../package.json", import.meta.url), "utf8"));
+import { serverOrigin, initializeConfig, loadCredential, loadDefaultServer, rememberServer, credentialPath, login, start, api } from "./client.js";
+const HELP = `Yep 本地设备节点 ${version} (协议2，Node.js 22+)
+
+yep device start [目录1 ... 目录5] [--server https://your-site.example]
+yep device login [--server https://your-site.example] [--no-open]
+yep device status [--server https://your-site.example]
+yep device logout [--server https://your-site.example]
+
+选项：--name 名称、--no-open、--help、--version
+不带目录的 start 使用当前系统用户 shell（非沙箱）；带目录只支持受限内置命令。
+授权最长24小时；start不安装后台服务。
+默认连接 https://yep.nihao.cool；显式 --server 会记住源站，令牌仍按源站隔离。`;
+export async function runDevice(args = process.argv.slice(2)) {
+  args = [...args];
+  if (args.includes("--help") || args.length === 0) {
+    console.log(HELP);
+    return;
+  }
+  if (args.includes("--version")) {
+    console.log(version);
+    return;
+  }
+  const command = args.shift();
+  let server, name, noOpen = false;
+  const directories = [];
+  while (args.length) {
+    const a = args.shift();
+    if (a === "--server") {
+      server = args.shift();
+      if (!server) throw new Error("--server requires a URL");
+    } else if (a === "--name") {
+      name = args.shift();
+      if (!name) throw new Error("--name requires a value");
+    } else if (a === "--no-open") noOpen = true;
+    else if (a.startsWith("-")) throw new Error(`Unknown option ${a}`);
+    else directories.push(a);
+  }
+  if (!["start", "login", "status", "logout"].includes(command)) throw new Error("Unknown command; use --help");
+  if (server) server = serverOrigin(server);
+  const config = await initializeConfig();
+  if (server) await rememberServer(config.directory, server);
+  else server = await loadDefaultServer(config.directory);
+  let credential = await loadCredential(config.directory, server);
+  const controller = new AbortController();
+  const stop = () => controller.abort();
+  process.once("SIGINT", stop);
+  process.once("SIGTERM", stop);
+  try {
+    if (command === "logout") {
+      if (credential) {
+        try {
+          await api(server, "/api/local-cli/logout", { method: "POST", token: credential.token });
+        } catch (error) {
+          if (error.status !== 401 && error.status !== 403) throw error;
+        }
+        await fs.unlink(credentialPath(config.directory, server));
+      }
+      console.log("设备授权已撤销并删除。");
+      return;
+    }
+    if (command === "status") {
+      if (!credential) {
+        console.log("尚未授权。");
+        return;
+      }
+      if (Date.now() >= Date.parse(credential.expiresAt)) throw new Error("Device authorization expired");
+      const me = await api(server, "/api/local-cli/me", { token: credential.token });
+      console.log(JSON.stringify({ deviceId: me.deviceId, name: me.name, expiresAt: me.expiresAt, protocol: me.protocol }, null, 2));
+      return;
+    }
+    if (command === "login") {
+      await login(server, config, { name, noOpen, signal: controller.signal });
+      return;
+    }
+    if (credential && Date.now() < Date.parse(credential.expiresAt)) {
+      try {
+        await api(server, "/api/local-cli/me", { token: credential.token });
+      } catch (e) {
+        if (e.status === 401 || e.status === 403) credential = null;
+        else throw e;
+      }
+    } else credential = null;
+    if (!credential) credential = await login(server, config, { name, noOpen, signal: controller.signal });
+    await start(server, config, credential, directories, { name, noOpen, signal: controller.signal });
+  } finally {
+    process.removeListener("SIGINT", stop);
+    process.removeListener("SIGTERM", stop);
+  }
+}