@witqq/agent-sdk 0.6.0 → 0.7.0

package/dist/chat/server.cjs

@@ -0,0 +1,643 @@
+'use strict';
+
+var fs = require('fs');
+var path = require('path');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var fs__namespace = /*#__PURE__*/_interopNamespace(fs);
+var path__namespace = /*#__PURE__*/_interopNamespace(path);
+
+// src/chat/backends/transport.ts
+var SSEChatTransport = class {
+  res;
+  _open;
+  _heartbeatTimer;
+  constructor(res, options) {
+    this.res = res;
+    this._open = true;
+    res.writeHead(200, {
+      "Content-Type": "text/event-stream",
+      "Cache-Control": "no-cache",
+      "Connection": "keep-alive",
+      "X-Accel-Buffering": "no"
+    });
+    if (options?.request) {
+      options.request.on("close", () => {
+        this._cleanup();
+      });
+    }
+    const heartbeatMs = options?.heartbeatMs;
+    if (heartbeatMs && heartbeatMs > 0) {
+      this._heartbeatTimer = setInterval(() => {
+        if (!this.isOpen) {
+          this._clearHeartbeat();
+          return;
+        }
+        this.res.write(": heartbeat\n\n");
+      }, heartbeatMs);
+    }
+  }
+  get isOpen() {
+    return this._open && !this.res.writableEnded;
+  }
+  send(event) {
+    if (!this.isOpen) return;
+    this.res.write(`data: ${JSON.stringify(event)}
+
+`);
+  }
+  close() {
+    if (!this.isOpen) return;
+    this._open = false;
+    this._clearHeartbeat();
+    this.res.write(`data: [DONE]
+
+`);
+    this.res.end();
+  }
+  error(err) {
+    if (!this.isOpen) return;
+    this._open = false;
+    this._clearHeartbeat();
+    const errorEvent = {
+      type: "error",
+      error: err.message,
+      recoverable: false
+    };
+    this.res.write(`data: ${JSON.stringify(errorEvent)}
+
+`);
+    this.res.end();
+  }
+  _cleanup() {
+    this._open = false;
+    this._clearHeartbeat();
+  }
+  _clearHeartbeat() {
+    if (this._heartbeatTimer !== void 0) {
+      clearInterval(this._heartbeatTimer);
+      this._heartbeatTimer = void 0;
+    }
+  }
+};
+async function streamToTransport(events, transport) {
+  try {
+    let accumulatedText = "";
+    for await (const event of events) {
+      if (!transport.isOpen) break;
+      transport.send(event);
+      if (event.type === "message:delta") {
+        accumulatedText += event.text;
+      }
+    }
+    if (transport.isOpen) {
+      transport.send({ type: "done", finalOutput: accumulatedText || void 0 });
+    }
+    transport.close();
+  } catch (err) {
+    transport.error(err instanceof Error ? err : new Error(String(err)));
+  }
+}
+
+// src/chat/server/handler.ts
+function createChatHandler(runtime, options) {
+  const prefix = options?.prefix ?? "";
+  const maxBodySize = options?.maxBodySize ?? 1048576;
+  const heartbeatMs = options?.heartbeatMs;
+  return async (req, res) => {
+    const url = req.url || "";
+    const method = req.method || "GET";
+    const rawPath = prefix ? url.slice(prefix.length) : url;
+    const path2 = rawPath.split("?")[0];
+    const sessionMatch = path2.match(/^\/sessions\/([^/]+)$/);
+    const archiveMatch = path2.match(/^\/sessions\/([^/]+)\/archive$/);
+    try {
+      if (method === "POST" && path2 === "/sessions/create") {
+        const body = await readBody(req, maxBodySize);
+        const session = await runtime.createSession({
+          title: body.title || `Chat ${(/* @__PURE__ */ new Date()).toLocaleTimeString()}`,
+          config: body.config || {
+            model: runtime.currentModel || "",
+            backend: runtime.currentBackend
+          },
+          ...body.tags ? { tags: body.tags } : {},
+          ...body.custom ? { custom: body.custom } : {}
+        });
+        json(res, session);
+        return;
+      }
+      if (method === "POST" && archiveMatch) {
+        const id = decodeURIComponent(archiveMatch[1]);
+        await runtime.archiveSession(id);
+        json(res, { ok: true });
+        return;
+      }
+      if (method === "GET" && sessionMatch) {
+        const id = decodeURIComponent(sessionMatch[1]);
+        const session = await runtime.getSession(id);
+        if (!session) {
+          json(res, { error: "Not found" }, 404);
+          return;
+        }
+        json(res, session);
+        return;
+      }
+      if (method === "DELETE" && sessionMatch) {
+        const id = decodeURIComponent(sessionMatch[1]);
+        await runtime.deleteSession(id);
+        json(res, { ok: true });
+        return;
+      }
+      if (method === "GET" && path2 === "/sessions") {
+        const sessions = await runtime.listSessions();
+        json(res, sessions);
+        return;
+      }
+      if (method === "POST" && path2 === "/send") {
+        const body = await readBody(req, maxBodySize);
+        const sessionId = body.sessionId;
+        const message = body.message || body.content;
+        if (!sessionId || !message) {
+          json(res, { error: "sessionId and message are required" }, 400);
+          return;
+        }
+        const transport = new SSEChatTransport(res, {
+          heartbeatMs,
+          request: req
+        });
+        try {
+          const opts = {};
+          if (body.model) opts.model = body.model;
+          const stream = runtime.send(
+            sessionId,
+            message,
+            Object.keys(opts).length > 0 ? opts : void 0
+          );
+          await streamToTransport(stream, transport);
+        } catch (err) {
+          transport.error(err instanceof Error ? err : new Error(String(err)));
+        }
+        return;
+      }
+      if (method === "POST" && path2 === "/abort") {
+        runtime.abort();
+        json(res, { ok: true });
+        return;
+      }
+      if (method === "GET" && path2 === "/models") {
+        const models = await runtime.listModels();
+        json(res, models);
+        return;
+      }
+      if (method === "POST" && path2 === "/backend/switch") {
+        const body = await readBody(req, maxBodySize);
+        if (!body.backend || typeof body.backend !== "string") {
+          json(res, { error: "backend is required" }, 400);
+          return;
+        }
+        await runtime.switchBackend(body.backend);
+        json(res, { ok: true });
+        return;
+      }
+      if (method === "POST" && path2 === "/model/switch") {
+        const body = await readBody(req, maxBodySize);
+        if (!body.model || typeof body.model !== "string") {
+          json(res, { error: "model is required" }, 400);
+          return;
+        }
+        runtime.switchModel(body.model);
+        json(res, { ok: true });
+        return;
+      }
+      json(res, { error: "Not found" }, 404);
+    } catch (err) {
+      if (err instanceof BodyParseError) {
+        json(res, { error: err.message }, err.statusCode);
+      } else {
+        const message = err instanceof Error ? err.message : String(err);
+        json(res, { error: message }, 500);
+      }
+    }
+  };
+}
+var BodyParseError = class extends Error {
+  statusCode;
+  constructor(message, statusCode) {
+    super(message);
+    this.name = "BodyParseError";
+    this.statusCode = statusCode;
+  }
+};
+function readBody(req, maxSize) {
+  return new Promise((resolve2, reject) => {
+    let body = "";
+    let size = 0;
+    let exceeded = false;
+    req.on("data", (chunk) => {
+      if (exceeded) return;
+      const str = chunk.toString();
+      size += Buffer.byteLength(str);
+      if (size > maxSize) {
+        exceeded = true;
+        reject(new BodyParseError("Request body too large", 413));
+        return;
+      }
+      body += str;
+    });
+    req.on("end", () => {
+      if (exceeded) return;
+      try {
+        resolve2(JSON.parse(body || "{}"));
+      } catch {
+        reject(new BodyParseError("Invalid JSON in request body", 400));
+      }
+    });
+    if ("once" in req && typeof req.once === "function") {
+      req.once(
+        "error",
+        () => reject(new BodyParseError("Request error", 500))
+      );
+    }
+  });
+}
+function json(res, data, status = 200) {
+  res.writeHead(status, { "Content-Type": "application/json" });
+  res.end(JSON.stringify(data));
+}
+
+// src/chat/server/auth-handler.ts
+function createAuthHandler(options) {
+  const { tokenStore, onAuth } = options;
+  const prefix = options.prefix ?? "";
+  const maxBodySize = options.maxBodySize ?? 1048576;
+  let pendingCopilot = null;
+  let pendingClaude = null;
+  return async (req, res) => {
+    const url = req.url || "";
+    const method = req.method || "GET";
+    const rawPath = prefix ? url.slice(prefix.length) : url;
+    const path2 = rawPath.split("?")[0];
+    try {
+      if (method === "POST" && path2 === "/auth/start") {
+        const body = await readBody2(req, maxBodySize);
+        const provider = body.provider;
+        if (!provider || !isValidProvider(provider)) {
+          json2(res, { error: "provider is required (copilot, claude, vercel-ai)" }, 400);
+          return;
+        }
+        pendingCopilot = null;
+        pendingClaude = null;
+        if (provider === "copilot") {
+          if (!options.createCopilotAuth) {
+            json2(res, { error: "Copilot auth not configured" }, 400);
+            return;
+          }
+          const auth = options.createCopilotAuth();
+          const flow = await auth.startDeviceFlow();
+          pendingCopilot = { waitForToken: flow.waitForToken };
+          json2(res, { userCode: flow.userCode, verificationUrl: flow.verificationUrl });
+          return;
+        }
+        if (provider === "claude") {
+          if (!options.createClaudeAuth) {
+            json2(res, { error: "Claude auth not configured" }, 400);
+            return;
+          }
+          const auth = options.createClaudeAuth();
+          const flow = auth.startOAuthFlow();
+          pendingClaude = { completeAuth: flow.completeAuth };
+          json2(res, { authorizeUrl: flow.authorizeUrl });
+          return;
+        }
+        json2(res, { ready: true });
+        return;
+      }
+      if (method === "POST" && path2 === "/auth/copilot/poll") {
+        if (!pendingCopilot) {
+          json2(res, { error: "No active Copilot flow" }, 400);
+          return;
+        }
+        const token = await pendingCopilot.waitForToken();
+        pendingCopilot = null;
+        await tokenStore.save("copilot", token);
+        if (onAuth) await onAuth("copilot", token);
+        json2(res, { ok: true, login: token.login });
+        return;
+      }
+      if (method === "POST" && path2 === "/auth/claude/complete") {
+        if (!pendingClaude) {
+          json2(res, { error: "No active Claude flow" }, 400);
+          return;
+        }
+        const body = await readBody2(req, maxBodySize);
+        const code = body.code;
+        if (!code || typeof code !== "string") {
+          json2(res, { error: "code is required" }, 400);
+          return;
+        }
+        const token = await pendingClaude.completeAuth(code);
+        pendingClaude = null;
+        await tokenStore.save("claude", token);
+        if (onAuth) await onAuth("claude", token);
+        json2(res, { ok: true });
+        return;
+      }
+      if (method === "POST" && path2 === "/auth/vercel/complete") {
+        const body = await readBody2(req, maxBodySize);
+        const apiKey = body.apiKey;
+        if (!apiKey || typeof apiKey !== "string") {
+          json2(res, { error: "apiKey is required" }, 400);
+          return;
+        }
+        const token = {
+          accessToken: apiKey,
+          tokenType: "bearer",
+          obtainedAt: Date.now()
+        };
+        const storeToken = body.baseUrl ? { ...token, baseUrl: body.baseUrl } : token;
+        await tokenStore.save("vercel-ai", storeToken);
+        if (onAuth) await onAuth("vercel-ai", storeToken);
+        json2(res, { ok: true });
+        return;
+      }
+      if (method === "GET" && path2 === "/tokens/saved") {
+        const saved = await tokenStore.list();
+        json2(res, { saved });
+        return;
+      }
+      if (method === "POST" && path2 === "/tokens/use") {
+        const body = await readBody2(req, maxBodySize);
+        const provider = body.provider;
+        if (!provider || !isValidProvider(provider)) {
+          json2(res, { error: "provider is required (copilot, claude, vercel-ai)" }, 400);
+          return;
+        }
+        const token = await tokenStore.load(provider);
+        if (!token) {
+          json2(res, { error: `No saved token for ${provider}` }, 404);
+          return;
+        }
+        if (onAuth) await onAuth(provider, token);
+        json2(res, { ok: true, provider });
+        return;
+      }
+      if (method === "POST" && path2 === "/tokens/clear") {
+        await tokenStore.clearAll();
+        if (options.onLogout) await options.onLogout();
+        json2(res, { ok: true });
+        return;
+      }
+      if (method === "POST" && path2 === "/auth/dispose") {
+        pendingCopilot = null;
+        pendingClaude = null;
+        if (options.onLogout) await options.onLogout();
+        json2(res, { ok: true });
+        return;
+      }
+      json2(res, { error: "Not found" }, 404);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      json2(res, { error: message }, 500);
+    }
+  };
+}
+function isValidProvider(p) {
+  return p === "copilot" || p === "claude" || p === "vercel-ai";
+}
+function readBody2(req, maxSize) {
+  return new Promise((resolve2) => {
+    let body = "";
+    let size = 0;
+    let exceeded = false;
+    req.on("data", (chunk) => {
+      if (exceeded) return;
+      const str = chunk.toString();
+      size += Buffer.byteLength(str);
+      if (size > maxSize) {
+        exceeded = true;
+        resolve2({});
+        return;
+      }
+      body += str;
+    });
+    req.on("end", () => {
+      if (exceeded) return;
+      try {
+        resolve2(JSON.parse(body || "{}"));
+      } catch {
+        resolve2({});
+      }
+    });
+    if ("once" in req && typeof req.once === "function") {
+      req.once("error", () => resolve2({}));
+    }
+  });
+}
+function json2(res, data, status = 200) {
+  res.writeHead(status, { "Content-Type": "application/json" });
+  res.end(JSON.stringify(data));
+}
+
+// src/chat/server/cors.ts
+function corsMiddleware(options) {
+  const origin = options?.origin ?? "*";
+  const methods = options?.methods ?? ["GET", "POST", "DELETE", "OPTIONS"];
+  const headers = options?.headers ?? ["Content-Type"];
+  const maxAge = options?.maxAge ?? 86400;
+  const methodsValue = methods.join(", ");
+  const headersValue = headers.join(", ");
+  return (req, res) => {
+    let originValue;
+    if (Array.isArray(origin)) {
+      const reqOrigin = typeof req.headers?.origin === "string" ? req.headers.origin : "";
+      originValue = origin.includes(reqOrigin) ? reqOrigin : origin[0];
+      res.setHeader("Vary", "Origin");
+    } else {
+      originValue = origin;
+    }
+    res.setHeader("Access-Control-Allow-Origin", originValue);
+    res.setHeader("Access-Control-Allow-Methods", methodsValue);
+    res.setHeader("Access-Control-Allow-Headers", headersValue);
+    if (req.method === "OPTIONS") {
+      res.setHeader("Access-Control-Max-Age", String(maxAge));
+      res.writeHead(204);
+      res.end();
+      return true;
+    }
+    return false;
+  };
+}
+var MIME_TYPES = {
+  ".html": "text/html",
+  ".css": "text/css",
+  ".js": "application/javascript",
+  ".mjs": "application/javascript",
+  ".json": "application/json",
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".svg": "image/svg+xml",
+  ".ico": "image/x-icon",
+  ".woff": "font/woff",
+  ".woff2": "font/woff2",
+  ".ttf": "font/ttf",
+  ".txt": "text/plain",
+  ".map": "application/json"
+};
+function createChatServer(options) {
+  const chatPrefix = options.chatPrefix ?? "/api/chat";
+  const authPrefix = options.authPrefix ?? "/api/auth";
+  const staticPrefix = options.staticPrefix ?? "/";
+  const staticDir = options.staticDir ? path__namespace.resolve(options.staticDir) : void 0;
+  const chatHandler = createChatHandler(options.runtime, {
+    prefix: chatPrefix,
+    ...options.chatHandlerOptions
+  });
+  const authHandler = options.auth ? createAuthHandler(options.auth) : void 0;
+  const cors = options.cors !== false ? corsMiddleware(options.cors) : void 0;
+  return async (req, res) => {
+    const url = req.url || "/";
+    const urlPath = url.split("?")[0];
+    if (cors) {
+      const corsReq = { method: req.method, headers: req.headers };
+      const corsRes = {
+        setHeader: (name, value) => res.setHeader(name, value),
+        writeHead: (statusCode) => res.writeHead(statusCode, {}),
+        end: () => res.end()
+      };
+      if (cors(corsReq, corsRes)) {
+        return;
+      }
+    }
+    if (urlPath.startsWith(chatPrefix + "/") || urlPath === chatPrefix) {
+      await chatHandler(req, res);
+      return;
+    }
+    if (authHandler && (urlPath.startsWith(authPrefix + "/") || urlPath === authPrefix)) {
+      const authReq = Object.create(req, {
+        url: { value: url.replace(authPrefix, ""), enumerable: true }
+      });
+      await authHandler(authReq, res);
+      return;
+    }
+    if (staticDir && req.method === "GET" && urlPath.startsWith(staticPrefix)) {
+      const relativePath = urlPath === staticPrefix || urlPath === staticPrefix + "/" ? "/index.html" : urlPath.slice(staticPrefix.length) || "/index.html";
+      const filePath = path__namespace.join(staticDir, relativePath);
+      if (!filePath.startsWith(staticDir + path__namespace.sep) && filePath !== staticDir) {
+        res.writeHead(403, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: "Forbidden" }));
+        return;
+      }
+      try {
+        const stat = fs__namespace.statSync(filePath);
+        if (stat.isFile()) {
+          const ext = path__namespace.extname(filePath).toLowerCase();
+          const contentType = MIME_TYPES[ext] || "application/octet-stream";
+          const content = fs__namespace.readFileSync(filePath);
+          res.writeHead(200, {
+            "Content-Type": contentType,
+            "Content-Length": String(content.length)
+          });
+          res.write(content.toString());
+          res.end();
+          return;
+        }
+      } catch {
+      }
+    }
+    json3(res, 404, { error: "Not found" });
+  };
+}
+function json3(res, status, body) {
+  const data = JSON.stringify(body);
+  res.writeHead(status, { "Content-Type": "application/json" });
+  res.end(data);
+}
+var InMemoryTokenStore = class {
+  tokens = /* @__PURE__ */ new Map();
+  async save(provider, token) {
+    this.tokens.set(provider, { ...token });
+  }
+  async load(provider) {
+    const t = this.tokens.get(provider);
+    return t ? { ...t } : null;
+  }
+  async clear(provider) {
+    this.tokens.delete(provider);
+  }
+  async clearAll() {
+    this.tokens.clear();
+  }
+  async list() {
+    return [...this.tokens.keys()];
+  }
+};
+var FileTokenStore = class {
+  dir;
+  constructor(options) {
+    this.dir = options.directory;
+  }
+  async save(provider, token) {
+    fs.mkdirSync(this.dir, { recursive: true });
+    fs.writeFileSync(this.filePath(provider), JSON.stringify(token));
+  }
+  async load(provider) {
+    try {
+      const data = fs.readFileSync(this.filePath(provider), "utf-8");
+      return JSON.parse(data);
+    } catch {
+      return null;
+    }
+  }
+  async clear(provider) {
+    try {
+      fs.unlinkSync(this.filePath(provider));
+    } catch {
+    }
+  }
+  async clearAll() {
+    if (!fs.existsSync(this.dir)) return;
+    for (const f of fs.readdirSync(this.dir)) {
+      if (f.endsWith("-token.json")) {
+        try {
+          fs.unlinkSync(path.join(this.dir, f));
+        } catch {
+        }
+      }
+    }
+  }
+  async list() {
+    if (!fs.existsSync(this.dir)) return [];
+    return fs.readdirSync(this.dir).filter((f) => f.endsWith("-token.json")).map((f) => f.replace(/-token\.json$/, ""));
+  }
+  filePath(provider) {
+    return path.join(this.dir, `${provider}-token.json`);
+  }
+};
+
+exports.FileTokenStore = FileTokenStore;
+exports.InMemoryTokenStore = InMemoryTokenStore;
+exports.corsMiddleware = corsMiddleware;
+exports.createAuthHandler = createAuthHandler;
+exports.createChatHandler = createChatHandler;
+exports.createChatServer = createChatServer;
+//# sourceMappingURL=server.cjs.map
+//# sourceMappingURL=server.cjs.map