zrocclaw 0.0.3 → 0.0.6

package/.turbo/turbo-build.log

@@ -0,0 +1,14 @@
+
+
+> zrocclaw@0.0.6 build /Users/zroc/Desktop/Zroc/AI/zrocclaw/apps/gateway
+> tsup
+
+CLI Building entry: src/server.ts
+CLI Using tsconfig: tsconfig.json
+CLI tsup v8.5.1
+CLI Using tsup config: /Users/zroc/Desktop/Zroc/AI/zrocclaw/apps/gateway/tsup.config.ts
+CLI Target: node18
+CLI Cleaning output folder
+CJS Build start
+CJS dist/server.js 7.68 KB
+CJS ⚡️ Build success in 7ms

package/bin/zrocclaw.js

@@ -1,2 +1,69 @@
 #!/usr/bin/env node
-require('../dist/index.js');
+
+const path = require('path');
+// Set PM2_HOME to a local directory to avoid permission issues in sandboxed environments
+if (!process.env.PM2_HOME) {
+  process.env.PM2_HOME = path.resolve(__dirname, '../../.pm2');
+}
+
+const { program } = require('commander');
+const pm2 = require('pm2');
+const pkg = require('../package.json');
+
+const APP_NAME = 'zrocclaw';
+const SCRIPT_PATH = path.resolve(__dirname, '../dist/server.js');
+
+program
+  .name('zrocclaw')
+  .description('ZrocClaw Gateway CLI')
+  .version(pkg.version);
+
+program
+  .command('start')
+  .description('启动网关服务')
+  .action(() => {
+    pm2.connect((err) => {
+      if (err) {
+        console.error('连接 PM2 失败:', err);
+        process.exit(2);
+      }
+
+      pm2.start({
+        name: APP_NAME,
+        script: SCRIPT_PATH,
+        env: {
+          NODE_ENV: 'production'
+        }
+      }, (err, apps) => {
+        pm2.disconnect();
+        if (err) {
+          console.error('网关服务启动失败:', err.message || err);
+          process.exit(2);
+        }
+        console.log(`✅ 网关服务 [${APP_NAME}] 已成功启动!`);
+      });
+    });
+  });
+
+program
+  .command('stop')
+  .description('关闭网关服务')
+  .action(() => {
+    pm2.connect((err) => {
+      if (err) {
+        console.error('连接 PM2 失败:', err);
+        process.exit(2);
+      }
+
+      pm2.stop(APP_NAME, (err, apps) => {
+        pm2.disconnect();
+        if (err) {
+          console.error('网关服务关闭失败 (可能服务并未运行):', err.message || err);
+          process.exit(2);
+        }
+        console.log(`⛔ 网关服务 [${APP_NAME}] 已成功关闭!`);
+      });
+    });
+  });
+
+program.parse(process.argv);

package/dist/server.js

@@ -0,0 +1,223 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/app.ts
+var import_express3 = __toESM(require("express"));
+var import_cors = __toESM(require("cors"));
+var import_helmet = __toESM(require("helmet"));
+
+// src/routes/config.ts
+var import_express = require("express");
+var import_fileManager = require("@zrocclaw/core/fileManager");
+var import_promises = __toESM(require("fs/promises"));
+var import_path = __toESM(require("path"));
+var router = (0, import_express.Router)();
+router.get("/", (req, res) => {
+  res.json({ configPath: (0, import_fileManager.getConfigPath)() });
+});
+var configDir = (0, import_fileManager.getConfigPath)();
+var configFilePath = import_path.default.join(configDir, "model.json");
+router.get("/model", async (req, res) => {
+  try {
+    try {
+      await import_promises.default.access(configFilePath);
+      const data = await import_promises.default.readFile(configFilePath, "utf-8");
+      res.json(JSON.parse(data));
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        await import_promises.default.mkdir(configDir, { recursive: true });
+        await import_promises.default.writeFile(configFilePath, "{}", "utf-8");
+        res.json({});
+      } else {
+        throw error;
+      }
+    }
+  } catch (error) {
+    console.error("\u83B7\u53D6\u6A21\u578B\u5931\u8D25:", error);
+    res.status(500).json({ error: "\u83B7\u53D6\u6A21\u578B\u5931\u8D25" });
+  }
+});
+router.post("/model", async (req, res) => {
+  try {
+    await import_promises.default.mkdir(configDir, { recursive: true });
+    let currentConfig = {};
+    try {
+      const data = await import_promises.default.readFile(configFilePath, "utf-8");
+      currentConfig = JSON.parse(data);
+    } catch (error) {
+      if (error.code !== "ENOENT") {
+        throw error;
+      }
+    }
+    const newConfig = { ...currentConfig, ...req.body };
+    await import_promises.default.writeFile(configFilePath, JSON.stringify(newConfig, null, 2), "utf-8");
+    res.json(newConfig);
+  } catch (error) {
+    console.error("\u4FEE\u6539\u6A21\u578B\u5931\u8D25:", error);
+    res.status(500).json({ error: "\u4FEE\u6539\u6A21\u578B\u5931\u8D25" });
+  }
+});
+var config_default = router;
+
+// src/routes/chat.ts
+var import_express2 = require("express");
+var import_agents = require("@zrocclaw/core/agents");
+var import_fileManager3 = require("@zrocclaw/core/fileManager");
+var import_promises2 = __toESM(require("fs/promises"));
+var import_path3 = __toESM(require("path"));
+var import_crypto = __toESM(require("crypto"));
+
+// src/models/session.ts
+var import_fileManager2 = require("@zrocclaw/core/fileManager");
+var import_fs = __toESM(require("fs"));
+var import_path2 = __toESM(require("path"));
+var SessionModel = class _SessionModel {
+  constructor() {
+    this.filePath = import_path2.default.join((0, import_fileManager2.getConfigPath)(), "session.json");
+    this.data = {
+      sessionId: null,
+      sessionData: {}
+    };
+    this.load();
+  }
+  static getInstance() {
+    if (!_SessionModel.instance) {
+      _SessionModel.instance = new _SessionModel();
+    }
+    return _SessionModel.instance;
+  }
+  load() {
+    if (import_fs.default.existsSync(this.filePath)) {
+      try {
+        const fileContent = import_fs.default.readFileSync(this.filePath, "utf-8");
+        const parsed = JSON.parse(fileContent);
+        this.data = { ...this.data, ...parsed };
+      } catch (error) {
+        console.error("Failed to parse session.json:", error);
+      }
+    } else {
+      this.save();
+    }
+  }
+  save() {
+    try {
+      const dir = import_path2.default.dirname(this.filePath);
+      if (!import_fs.default.existsSync(dir)) {
+        import_fs.default.mkdirSync(dir, { recursive: true });
+      }
+      import_fs.default.writeFileSync(this.filePath, JSON.stringify(this.data, null, 2), "utf-8");
+    } catch (error) {
+      console.error("Failed to save session.json:", error);
+    }
+  }
+  getSessionId() {
+    return this.data.sessionId;
+  }
+  setSessionId(id) {
+    this.data.sessionId = id;
+    this.save();
+  }
+  getSessionData() {
+    return this.data.sessionData;
+  }
+  setSessionData(data) {
+    this.data.sessionData = data;
+    this.save();
+  }
+};
+var sessionModel = SessionModel.getInstance();
+var session_default = sessionModel;
+
+// src/routes/chat.ts
+var configDir2 = (0, import_fileManager3.getConfigPath)();
+var configFilePath2 = import_path3.default.join(configDir2, "model.json");
+var router2 = (0, import_express2.Router)();
+router2.get("/", (req, res) => {
+  res.json({ status: "OK" });
+});
+router2.post("/stream", async (req, res) => {
+  try {
+    const query = req.body.query;
+    const thread_id = req.body.thread_id;
+    if (!query || !thread_id) {
+      return res.status(400).json({ error: "Missing query or thread_id in request body" });
+    }
+    const configContent = await import_promises2.default.readFile(configFilePath2, "utf-8");
+    const config = JSON.parse(configContent);
+    const modelConfig = config.defaultModel;
+    if (!modelConfig) {
+      return res.status(500).json({ error: "defaultModel not found in config" });
+    }
+    res.setHeader("Content-Type", "text/event-stream");
+    res.setHeader("Cache-Control", "no-cache");
+    res.setHeader("Connection", "keep-alive");
+    const stream = (0, import_agents.browser_stream_invoke)(query, thread_id, modelConfig);
+    for await (const chunk of stream) {
+      res.write(chunk);
+    }
+    res.end();
+  } catch (error) {
+    console.error("Stream error:", error);
+    if (!res.headersSent) {
+      res.status(500).json({ error: "Internal server error" });
+    } else {
+      res.end();
+    }
+  }
+});
+router2.get("/session", (req, res) => {
+  const isNew = req.query.new === "true";
+  let sessionId = session_default.getSessionId();
+  if (!sessionId || isNew) {
+    sessionId = import_crypto.default.randomUUID();
+    session_default.setSessionId(sessionId);
+  }
+  res.json({ sessionId });
+});
+var chat_default = router2;
+
+// src/app.ts
+var import_dotenv = __toESM(require("dotenv"));
+var import_path4 = __toESM(require("path"));
+import_dotenv.default.config();
+var app = (0, import_express3.default)();
+app.use((0, import_helmet.default)());
+app.use((0, import_cors.default)());
+app.use(import_express3.default.json());
+app.get("/health", (req, res) => {
+  res.json({ status: "OK", timestamp: (/* @__PURE__ */ new Date()).toISOString() });
+});
+app.use("/config", config_default);
+app.use("/chat", chat_default);
+if (true) {
+  app.use("/web", import_express3.default.static(import_path4.default.join(__dirname, "../src/static")));
+}
+var app_default = app;
+
+// src/server.ts
+var PORT = 18302;
+app_default.listen(PORT, () => {
+  console.log(`Gateway is running at http://localhost:${PORT}`);
+  console.log(`Environment: ${"production"}`);
+});

package/nodemon.json

@@ -0,0 +1,6 @@
+{
+  "watch": ["src", "../../packages/core/src"],
+  "ext": "ts,json",
+  "ignore": ["src/**/*.spec.ts"],
+  "exec": "ts-node src/server.ts"
+}

package/package.json

@@ -1,25 +1,39 @@
 {
   "name": "zrocclaw",
-  "version": "0.0.3",
-  "description": "个人专属浏览器AI助手命令行工具",
+  "version": "0.0.6",
+  "description": "ZrocClaw Gateway Service",
+  "main": "src/server.ts",
   "bin": {
-    "zrocclaw": "bin/zrocclaw.js"
+    "zrocclaw": "./bin/zrocclaw.js"
   },
-  "files": [
-    "dist",
-    "bin",
-    "README.md"
-  ],
   "scripts": {
-    "dev": "tsc --watch",
-    "build": "tsc"
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "dev": "nodemon src/server.ts",
+    "start": "node dist/server.js",
+    "build": "tsup"
   },
+  "keywords": [],
+  "author": "ZrocLee",
+  "license": "ISC",
+  "packageManager": "pnpm@10.30.3",
   "dependencies": {
-    "@zrocclaw/gateway": "^1.0.0",
-    "commander": "^12.1.0"
+    "@zrocclaw/core": "workspace:*",
+    "commander": "^14.0.3",
+    "cors": "^2.8.6",
+    "dotenv": "^17.3.1",
+    "express": "^5.2.1",
+    "helmet": "^8.1.0",
+    "http-proxy-middleware": "^3.0.5",
+    "pm2": "^6.0.14"
   },
   "devDependencies": {
-    "@types/node": "^24.12.0",
+    "@types/cors": "^2.8.19",
+    "@types/express": "^5.0.6",
+    "@types/http-proxy-middleware": "^1.0.0",
+    "@types/node": "^25.5.0",
+    "nodemon": "^3.1.14",
+    "ts-node": "^10.9.2",
+    "tsup": "^8.5.1",
     "typescript": "^5.9.3"
   }
-}
+}

package/src/app.ts

@@ -0,0 +1,35 @@
+// src/app.ts
+import express from "express";
+import cors from "cors"; // 可选，如果需要跨域
+import helmet from "helmet"; // 可选，安全头
+import configRouter from "./routes/config";
+import chatRouter from "./routes/chat";
+import dotenv from "dotenv";
+import path from "path";
+
+dotenv.config(); // 加载 .env 文件
+
+const app = express();
+
+// 基础中间件
+app.use(helmet()); // 安全相关
+app.use(cors()); // 允许跨域
+app.use(express.json()); // 解析 JSON 请求体
+
+// 健康检查端点
+app.get("/health", (req, res) => {
+  res.json({ status: "OK", timestamp: new Date().toISOString() });
+});
+
+// 配置路由
+app.use("/config", configRouter);
+app.use("/chat", chatRouter);
+
+// 静态文件服务：将 Vue 打包后的 dist 目录挂载到根路径
+// 注意：生产环境才使用静态文件服务，开发时通常由 Vite 自己处理
+if (process.env.NODE_ENV === "production") {
+  // 静态资源存放在 src/static（Web 构建后复制过来）
+  app.use("/web", express.static(path.join(__dirname, "../src/static")));
+}
+
+export default app;

package/src/models/session.ts

@@ -0,0 +1,78 @@
+import { getConfigPath } from '@zrocclaw/core/fileManager';
+import fs from 'fs';
+import path from 'path';
+
+interface SessionData {
+  sessionId: string | null;
+  sessionData: Record<string, any>;
+}
+
+class SessionModel {
+  private static instance: SessionModel;
+  private filePath: string;
+  private data: SessionData;
+
+  private constructor() {
+    this.filePath = path.join(getConfigPath(), 'session.json');
+    this.data = {
+      sessionId: null,
+      sessionData: {},
+    };
+    this.load();
+  }
+
+  public static getInstance(): SessionModel {
+    if (!SessionModel.instance) {
+      SessionModel.instance = new SessionModel();
+    }
+    return SessionModel.instance;
+  }
+
+  private load(): void {
+    if (fs.existsSync(this.filePath)) {
+      try {
+        const fileContent = fs.readFileSync(this.filePath, 'utf-8');
+        const parsed = JSON.parse(fileContent);
+        this.data = { ...this.data, ...parsed };
+      } catch (error) {
+        console.error('Failed to parse session.json:', error);
+      }
+    } else {
+      // 文件不存在就创建一个
+      this.save();
+    }
+  }
+
+  private save(): void {
+    try {
+      const dir = path.dirname(this.filePath);
+      if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+      }
+      fs.writeFileSync(this.filePath, JSON.stringify(this.data, null, 2), 'utf-8');
+    } catch (error) {
+      console.error('Failed to save session.json:', error);
+    }
+  }
+
+  public getSessionId(): string | null {
+    return this.data.sessionId;
+  }
+
+  public setSessionId(id: string | null): void {
+    this.data.sessionId = id;
+    this.save();
+  }
+
+  public getSessionData(): Record<string, any> {
+    return this.data.sessionData;
+  }
+
+  public setSessionData(data: Record<string, any>): void {
+    this.data.sessionData = data;
+    this.save();
+  }
+}
+
+export const sessionModel = SessionModel.getInstance();
+export default sessionModel;

package/src/routes/chat.ts

@@ -0,0 +1,67 @@
+import { Router } from 'express';
+import { browser_stream_invoke } from '@zrocclaw/core/agents'
+import { getConfigPath } from '@zrocclaw/core/fileManager';
+import fs from 'fs/promises';
+import path from 'path';
+import crypto from 'crypto';
+import sessionModel from '../models/session';
+
+const configDir = getConfigPath();
+const configFilePath = path.join(configDir, 'model.json');
+
+
+
+const router = Router();
+router.get('/', (req, res) => {
+  res.json({ status: "OK" });
+});
+
+router.post('/stream', async (req, res) => {
+  try {
+    const query = req.body.query as string;
+    const thread_id = req.body.thread_id as string;
+    
+    if (!query || !thread_id) {
+      return res.status(400).json({ error: "Missing query or thread_id in request body" });
+    }
+
+    const configContent = await fs.readFile(configFilePath, 'utf-8');
+    const config = JSON.parse(configContent);
+    const modelConfig = config.defaultModel;
+
+    if (!modelConfig) {
+      return res.status(500).json({ error: "defaultModel not found in config" });
+    }
+
+    res.setHeader('Content-Type', 'text/event-stream');
+    res.setHeader('Cache-Control', 'no-cache');
+    res.setHeader('Connection', 'keep-alive');
+
+    const stream = browser_stream_invoke(query, thread_id, modelConfig);
+
+    for await (const chunk of stream) {
+      res.write(chunk);
+    }
+
+    res.end();
+  } catch (error) {
+    console.error("Stream error:", error);
+    if (!res.headersSent) {
+      res.status(500).json({ error: "Internal server error" });
+    } else {
+      res.end();
+    }
+  }
+});
+
+router.get('/session', (req, res) => {
+  const isNew = req.query.new === 'true';
+  let sessionId = sessionModel.getSessionId();
+  if (!sessionId || isNew) {
+    sessionId = crypto.randomUUID();
+    sessionModel.setSessionId(sessionId);
+  }
+  res.json({ sessionId });
+});
+
+export default router;

package/src/routes/config.ts

@@ -0,0 +1,67 @@
+import { Router } from 'express';
+import { getConfigPath } from '@zrocclaw/core/fileManager';
+import fs from 'fs/promises';
+import path from 'path';
+
+const router = Router();
+
+router.get('/', (req, res) => {
+  res.json({ configPath: getConfigPath()});
+});
+
+
+const configDir = getConfigPath();
+const configFilePath = path.join(configDir, 'model.json');
+
+// 新增：获取模型信息
+router.get('/model', async (req, res) => {
+  try {
+
+    try {
+      await fs.access(configFilePath);
+      const data = await fs.readFile(configFilePath, 'utf-8');
+      res.json(JSON.parse(data));
+    } catch (error: any) {
+      if (error.code === 'ENOENT') {
+        // 文件不存在，创建并返回 {}
+        await fs.mkdir(configDir, { recursive: true });
+        await fs.writeFile(configFilePath, '{}', 'utf-8');
+        res.json({});
+      } else {
+        throw error;
+      }
+    }
+  } catch (error) {
+    console.error('获取模型失败:', error);
+    res.status(500).json({ error: '获取模型失败' });
+  }
+});
+
+// 新增：修改模型信息
+router.post('/model', async (req, res) => {
+  try {
+    // 确保目录存在
+    await fs.mkdir(configDir, { recursive: true });
+
+    // 读取现有配置
+    let currentConfig = {};
+    try {
+      const data = await fs.readFile(configFilePath, 'utf-8');
+      currentConfig = JSON.parse(data);
+    } catch (error: any) {
+      if (error.code !== 'ENOENT') {
+        throw error;
+      }
+    }
+
+    // 合并并写入新配置
+    const newConfig = { ...currentConfig, ...req.body };
+    await fs.writeFile(configFilePath, JSON.stringify(newConfig, null, 2), 'utf-8');
+    res.json(newConfig);
+  } catch (error) {
+    console.error('修改模型失败:', error);
+    res.status(500).json({ error: '修改模型失败' });
+  }
+});
+
+export default router;

package/src/server.ts

@@ -0,0 +1,9 @@
+// src/server.ts
+import app from './app';
+
+const PORT = 18302;
+
+app.listen(PORT, () => {
+  console.log(`Gateway is running at http://localhost:${PORT}`);
+  console.log(`Environment: ${process.env.NODE_ENV}`);
+});