@agentxjs/portagent 0.0.2

package/dist/server/index.js

@@ -0,0 +1,642 @@
+// src/server/index.ts
+import { dirname, resolve } from "path";
+import { fileURLToPath } from "url";
+import { serve } from "@hono/node-server";
+import { Hono as Hono2 } from "hono";
+import { cors } from "hono/cors";
+import { serveStatic } from "@hono/node-server/serve-static";
+import { existsSync, readFileSync } from "fs";
+import { createAgentX, defineAgent } from "agentxjs";
+import { createAgentXHandler } from "agentxjs/server";
+import { toHonoHandler } from "agentxjs/server/adapters/hono";
+import { nodeRuntime } from "@agentxjs/node-runtime";
+import { homedir } from "os";
+import { join } from "path";
+
+// src/server/auth.ts
+import { Hono } from "hono";
+import { createMiddleware } from "hono/factory";
+import * as jose from "jose";
+var TOKEN_EXPIRY = "7d";
+async function createToken(secret, userId) {
+  const secretKey = new TextEncoder().encode(secret);
+  const token = await new jose.SignJWT({ sub: userId }).setProtectedHeader({ alg: "HS256" }).setIssuedAt().setExpirationTime(TOKEN_EXPIRY).sign(secretKey);
+  return token;
+}
+async function verifyToken(secret, token) {
+  try {
+    const secretKey = new TextEncoder().encode(secret);
+    const { payload } = await jose.jwtVerify(token, secretKey);
+    return { userId: payload.sub };
+  } catch {
+    return null;
+  }
+}
+function toUserInfo(user) {
+  return {
+    userId: user.userId,
+    username: user.username,
+    email: user.email,
+    containerId: user.containerId,
+    displayName: user.displayName,
+    avatar: user.avatar,
+    createdAt: user.createdAt
+  };
+}
+function authRoutes(userRepository, jwtSecret, agentx) {
+  const app = new Hono();
+  app.post("/register", async (c) => {
+    try {
+      const body = await c.req.json();
+      if (!body.username || !body.email || !body.password) {
+        return c.json({ error: "Username, email, and password are required" }, 400);
+      }
+      if (body.username.length < 3) {
+        return c.json({ error: "Username must be at least 3 characters" }, 400);
+      }
+      if (body.password.length < 6) {
+        return c.json({ error: "Password must be at least 6 characters" }, 400);
+      }
+      if (!body.email.includes("@")) {
+        return c.json({ error: "Invalid email format" }, 400);
+      }
+      const container = await agentx.containers.create();
+      const user = await userRepository.createUser({
+        username: body.username,
+        email: body.email,
+        password: body.password,
+        containerId: container.containerId,
+        displayName: body.displayName,
+        avatar: body.avatar
+      });
+      const token = await createToken(jwtSecret, user.userId);
+      return c.json(
+        {
+          token,
+          user: toUserInfo(user),
+          expiresIn: TOKEN_EXPIRY
+        },
+        201
+      );
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Registration failed";
+      return c.json({ error: message }, 400);
+    }
+  });
+  app.post("/login", async (c) => {
+    try {
+      const body = await c.req.json();
+      if (!body.usernameOrEmail || !body.password) {
+        return c.json({ error: "Username/email and password are required" }, 400);
+      }
+      const user = await userRepository.verifyPassword(body.usernameOrEmail, body.password);
+      if (!user) {
+        return c.json({ error: "Invalid credentials" }, 401);
+      }
+      const token = await createToken(jwtSecret, user.userId);
+      return c.json({
+        token,
+        user: toUserInfo(user),
+        expiresIn: TOKEN_EXPIRY
+      });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Login failed";
+      return c.json({ error: message }, 500);
+    }
+  });
+  app.get("/verify", async (c) => {
+    const authHeader = c.req.header("Authorization");
+    if (!authHeader || !authHeader.startsWith("Bearer ")) {
+      return c.json({ valid: false }, 401);
+    }
+    const token = authHeader.slice(7);
+    const result = await verifyToken(jwtSecret, token);
+    if (!result) {
+      return c.json({ valid: false }, 401);
+    }
+    const user = await userRepository.findUserById(result.userId);
+    if (!user || !user.isActive) {
+      return c.json({ valid: false }, 401);
+    }
+    return c.json({ valid: true, user: toUserInfo(user) });
+  });
+  app.post("/logout", (c) => {
+    return c.json({ success: true });
+  });
+  return app;
+}
+function createAuthMiddleware(jwtSecret) {
+  return createMiddleware(async (c, next) => {
+    const url = new URL(c.req.url);
+    const queryToken = url.searchParams.get("token");
+    const authHeader = c.req.header("Authorization");
+    let token = null;
+    if (authHeader && authHeader.startsWith("Bearer ")) {
+      token = authHeader.slice(7);
+    } else if (queryToken) {
+      token = queryToken;
+    }
+    if (!token) {
+      return c.json({ error: "Unauthorized" }, 401);
+    }
+    const result = await verifyToken(jwtSecret, token);
+    if (!result) {
+      return c.json({ error: "Invalid token" }, 401);
+    }
+    c.set("userId", result.userId);
+    c.header("X-User-Id", result.userId);
+    await next();
+  });
+}
+
+// src/server/database/SQLiteUserRepository.ts
+import Database from "better-sqlite3";
+import { randomUUID } from "crypto";
+import { hash, compare } from "bcrypt";
+var SALT_ROUNDS = 10;
+var SQLiteUserRepository = class {
+  db;
+  constructor(dbPath) {
+    this.db = new Database(dbPath);
+    this.initDatabase();
+  }
+  /**
+   * Initialize database schema
+   */
+  initDatabase() {
+    this.db.pragma("foreign_keys = ON");
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS users (
+        userId TEXT PRIMARY KEY,
+        username TEXT UNIQUE NOT NULL,
+        email TEXT UNIQUE NOT NULL,
+        passwordHash TEXT NOT NULL,
+        containerId TEXT NOT NULL,
+        displayName TEXT,
+        avatar TEXT,
+        isActive INTEGER NOT NULL DEFAULT 1,
+        createdAt INTEGER NOT NULL,
+        updatedAt INTEGER NOT NULL
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_users_username ON users(username);
+      CREATE INDEX IF NOT EXISTS idx_users_email ON users(email);
+      CREATE INDEX IF NOT EXISTS idx_users_containerId ON users(containerId);
+    `);
+  }
+  /**
+   * Create a new user
+   */
+  async createUser(input) {
+    if (await this.usernameExists(input.username)) {
+      throw new Error(`Username '${input.username}' already exists`);
+    }
+    if (await this.emailExists(input.email)) {
+      throw new Error(`Email '${input.email}' already exists`);
+    }
+    const passwordHash = await hash(input.password, SALT_ROUNDS);
+    const userId = randomUUID();
+    const now = Date.now();
+    const user = {
+      userId,
+      username: input.username,
+      email: input.email,
+      passwordHash,
+      containerId: input.containerId,
+      displayName: input.displayName,
+      avatar: input.avatar,
+      isActive: true,
+      createdAt: now,
+      updatedAt: now
+    };
+    const stmt = this.db.prepare(`
+      INSERT INTO users (
+        userId, username, email, passwordHash, containerId, displayName, avatar, isActive, createdAt, updatedAt
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+    stmt.run(
+      user.userId,
+      user.username,
+      user.email,
+      user.passwordHash,
+      user.containerId,
+      user.displayName,
+      user.avatar,
+      user.isActive ? 1 : 0,
+      user.createdAt,
+      user.updatedAt
+    );
+    return user;
+  }
+  /**
+   * Find user by ID
+   */
+  async findUserById(userId) {
+    const stmt = this.db.prepare(`
+      SELECT * FROM users WHERE userId = ?
+    `);
+    const row = stmt.get(userId);
+    return row ? this.rowToUser(row) : null;
+  }
+  /**
+   * Find user by username
+   */
+  async findUserByUsername(username) {
+    const stmt = this.db.prepare(`
+      SELECT * FROM users WHERE username = ?
+    `);
+    const row = stmt.get(username);
+    return row ? this.rowToUser(row) : null;
+  }
+  /**
+   * Find user by email
+   */
+  async findUserByEmail(email) {
+    const stmt = this.db.prepare(`
+      SELECT * FROM users WHERE email = ?
+    `);
+    const row = stmt.get(email);
+    return row ? this.rowToUser(row) : null;
+  }
+  /**
+   * Find user by username or email
+   */
+  async findUserByUsernameOrEmail(usernameOrEmail) {
+    const stmt = this.db.prepare(`
+      SELECT * FROM users WHERE username = ? OR email = ?
+    `);
+    const row = stmt.get(usernameOrEmail, usernameOrEmail);
+    return row ? this.rowToUser(row) : null;
+  }
+  /**
+   * Update user
+   */
+  async updateUser(userId, updates) {
+    const user = await this.findUserById(userId);
+    if (!user) {
+      throw new Error(`User ${userId} not found`);
+    }
+    const fields = [];
+    const values = [];
+    if (updates.username !== void 0) {
+      fields.push("username = ?");
+      values.push(updates.username);
+    }
+    if (updates.email !== void 0) {
+      fields.push("email = ?");
+      values.push(updates.email);
+    }
+    if (updates.passwordHash !== void 0) {
+      fields.push("passwordHash = ?");
+      values.push(updates.passwordHash);
+    }
+    if (updates.displayName !== void 0) {
+      fields.push("displayName = ?");
+      values.push(updates.displayName);
+    }
+    if (updates.avatar !== void 0) {
+      fields.push("avatar = ?");
+      values.push(updates.avatar);
+    }
+    if (updates.isActive !== void 0) {
+      fields.push("isActive = ?");
+      values.push(updates.isActive ? 1 : 0);
+    }
+    fields.push("updatedAt = ?");
+    values.push(Date.now());
+    if (fields.length === 0) {
+      return user;
+    }
+    values.push(userId);
+    const stmt = this.db.prepare(`
+      UPDATE users SET ${fields.join(", ")} WHERE userId = ?
+    `);
+    stmt.run(...values);
+    return await this.findUserById(userId);
+  }
+  /**
+   * Delete user
+   */
+  async deleteUser(userId) {
+    const stmt = this.db.prepare(`
+      DELETE FROM users WHERE userId = ?
+    `);
+    const result = stmt.run(userId);
+    return result.changes > 0;
+  }
+  /**
+   * List all users
+   */
+  async listUsers() {
+    const stmt = this.db.prepare(`
+      SELECT * FROM users ORDER BY createdAt DESC
+    `);
+    const rows = stmt.all();
+    return rows.map((row) => this.rowToUser(row));
+  }
+  /**
+   * Check if username exists
+   */
+  async usernameExists(username) {
+    const stmt = this.db.prepare(`
+      SELECT 1 FROM users WHERE username = ?
+    `);
+    return stmt.get(username) !== void 0;
+  }
+  /**
+   * Check if email exists
+   */
+  async emailExists(email) {
+    const stmt = this.db.prepare(`
+      SELECT 1 FROM users WHERE email = ?
+    `);
+    return stmt.get(email) !== void 0;
+  }
+  /**
+   * Verify password for login
+   *
+   * @param usernameOrEmail - Username or email
+   * @param password - Plain text password
+   * @returns User record if valid, null if invalid
+   */
+  async verifyPassword(usernameOrEmail, password) {
+    const user = await this.findUserByUsernameOrEmail(usernameOrEmail);
+    if (!user) {
+      return null;
+    }
+    if (!user.isActive) {
+      return null;
+    }
+    const isValid = await compare(password, user.passwordHash);
+    return isValid ? user : null;
+  }
+  /**
+   * Close database connection
+   */
+  close() {
+    this.db.close();
+  }
+  // ============================================================================
+  // Private Helpers
+  // ============================================================================
+  rowToUser(row) {
+    return {
+      userId: row.userId,
+      username: row.username,
+      email: row.email,
+      passwordHash: row.passwordHash,
+      containerId: row.containerId,
+      displayName: row.displayName,
+      avatar: row.avatar,
+      isActive: row.isActive === 1,
+      createdAt: row.createdAt,
+      updatedAt: row.updatedAt
+    };
+  }
+};
+
+// src/server/ownership.ts
+function getUserId(request) {
+  const authHeader = request.headers.get("Authorization");
+  if (!authHeader || !authHeader.startsWith("Bearer ")) {
+    const url = new URL(request.url);
+    const queryToken = url.searchParams.get("token");
+    if (!queryToken) {
+      return null;
+    }
+  }
+  return request.headers.get("X-User-Id");
+}
+function createOwnershipHandler(agentx, baseHandler) {
+  return async (request) => {
+    const url = new URL(request.url);
+    const method = request.method;
+    const path = url.pathname;
+    const userId = getUserId(request);
+    if (!userId) {
+      return baseHandler(request);
+    }
+    if (method === "POST" && path.endsWith("/containers")) {
+      try {
+        const body = await request.json();
+        const config = body.config || {};
+        config.ownerId = userId;
+        const modifiedBody = { ...body, config };
+        const modifiedRequest = new Request(request.url, {
+          method: request.method,
+          headers: request.headers,
+          body: JSON.stringify(modifiedBody)
+        });
+        return baseHandler(modifiedRequest);
+      } catch {
+        return baseHandler(request);
+      }
+    }
+    const putContainerMatch = path.match(/\/containers\/([^/]+)$/);
+    if (method === "PUT" && putContainerMatch) {
+      const containerId = putContainerMatch[1];
+      const existingContainer = await agentx.containers.get(containerId);
+      if (existingContainer) {
+        const ownerId = existingContainer.config?.ownerId;
+        if (ownerId && ownerId !== userId) {
+          return new Response(JSON.stringify({ error: "Access denied" }), {
+            status: 403,
+            headers: { "Content-Type": "application/json" }
+          });
+        }
+        return baseHandler(request);
+      } else {
+        try {
+          const body = await request.json();
+          const config = body.config || {};
+          config.ownerId = userId;
+          const modifiedBody = { ...body, config };
+          const modifiedRequest = new Request(request.url, {
+            method: request.method,
+            headers: request.headers,
+            body: JSON.stringify(modifiedBody)
+          });
+          return baseHandler(modifiedRequest);
+        } catch {
+          return baseHandler(request);
+        }
+      }
+    }
+    const getContainerMatch = path.match(/\/containers\/([^/]+)$/);
+    if (method === "GET" && getContainerMatch) {
+      const containerId = getContainerMatch[1];
+      const container = await agentx.containers.get(containerId);
+      if (!container) {
+        return new Response(JSON.stringify({ error: "Container not found" }), {
+          status: 404,
+          headers: { "Content-Type": "application/json" }
+        });
+      }
+      const ownerId = container.config?.ownerId;
+      if (ownerId && ownerId !== userId) {
+        return new Response(JSON.stringify({ error: "Access denied" }), {
+          status: 403,
+          headers: { "Content-Type": "application/json" }
+        });
+      }
+      return baseHandler(request);
+    }
+    const deleteContainerMatch = path.match(/\/containers\/([^/]+)$/);
+    if (method === "DELETE" && deleteContainerMatch) {
+      const containerId = deleteContainerMatch[1];
+      const container = await agentx.containers.get(containerId);
+      if (!container) {
+        return new Response(JSON.stringify({ error: "Container not found" }), {
+          status: 404,
+          headers: { "Content-Type": "application/json" }
+        });
+      }
+      const ownerId = container.config?.ownerId;
+      if (ownerId && ownerId !== userId) {
+        return new Response(JSON.stringify({ error: "Access denied" }), {
+          status: 403,
+          headers: { "Content-Type": "application/json" }
+        });
+      }
+      return baseHandler(request);
+    }
+    if (method === "GET" && path.endsWith("/containers")) {
+      const response = await baseHandler(request);
+      if (response.ok) {
+        const body = await response.json();
+        if (Array.isArray(body)) {
+          const filtered = body.filter((container) => {
+            const ownerId = container.config?.ownerId;
+            return !ownerId || ownerId === userId;
+          });
+          return new Response(JSON.stringify(filtered), {
+            status: 200,
+            headers: { "Content-Type": "application/json" }
+          });
+        }
+      }
+      return response;
+    }
+    return baseHandler(request);
+  };
+}
+
+// src/server/index.ts
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = dirname(__filename);
+var PORT = parseInt(process.env.PORT || "5200", 10);
+var JWT_SECRET = process.env.JWT_SECRET || crypto.randomUUID();
+var USER_DB_PATH = process.env.USER_DB_PATH || join(homedir(), ".agentx/data/portagent.db");
+var DefaultAgent = defineAgent({
+  name: "Assistant",
+  systemPrompt: "You are a helpful AI assistant."
+});
+function createApp() {
+  const app = new Hono2();
+  app.use(
+    "*",
+    cors({
+      origin: "*",
+      allowMethods: ["GET", "POST", "PUT", "DELETE", "HEAD", "OPTIONS"],
+      allowHeaders: ["Content-Type", "Authorization"]
+    })
+  );
+  const runtime = nodeRuntime();
+  const agentx = createAgentX(runtime);
+  agentx.definitions.register(DefaultAgent);
+  const agentxHandler = createAgentXHandler(agentx, {
+    basePath: "/agentx",
+    allowDynamicCreation: true,
+    allowedDefinitions: ["Assistant"],
+    repository: runtime.repository
+  });
+  agentxHandler.registerDefinition("Assistant", DefaultAgent);
+  const userRepository = new SQLiteUserRepository(USER_DB_PATH);
+  const authMiddleware = createAuthMiddleware(JWT_SECRET);
+  app.get("/health", (c) => c.json({ status: "ok", timestamp: Date.now() }));
+  app.route("/api/auth", authRoutes(userRepository, JWT_SECRET, agentx));
+  const ownershipHandler = createOwnershipHandler(agentx, agentxHandler);
+  app.use("/agentx/*", authMiddleware);
+  app.all("/agentx/*", toHonoHandler(ownershipHandler));
+  const publicDir = resolve(__dirname, "../public");
+  const isDev = process.env.NODE_ENV !== "production";
+  if (existsSync(publicDir)) {
+    app.use("/*", serveStatic({ root: publicDir }));
+    app.get("*", (c) => {
+      const indexPath = resolve(publicDir, "index.html");
+      if (existsSync(indexPath)) {
+        const html = readFileSync(indexPath, "utf-8");
+        return c.html(html);
+      }
+      return c.text("Not Found", 404);
+    });
+  } else if (isDev) {
+    app.get("*", (c) => {
+      return c.text(
+        "Static files not found. Run 'pnpm build:client' first, or use 'pnpm dev' for development.",
+        404
+      );
+    });
+  }
+  return { app, agentx, userRepository };
+}
+async function startServer() {
+  if (!process.env.LLM_PROVIDER_KEY) {
+    console.error("Error: LLM_PROVIDER_KEY is required");
+    console.log("\nSet it via environment variable:");
+    console.log("  export LLM_PROVIDER_KEY=sk-ant-xxx");
+    process.exit(1);
+  }
+  const { app, agentx, userRepository } = createApp();
+  console.log(`
+  ____            _                         _
+ |  _ \\ ___  _ __| |_ __ _  __ _  ___ _ __ | |_
+ | |_) / _ \\| '__| __/ _\` |/ _\` |/ _ \\ '_ \\| __|
+ |  __/ (_) | |  | || (_| | (_| |  __/ | | | |_
+ |_|   \\___/|_|   \\__\\__,_|\\__, |\\___|_| |_|\\__|
+                           |___/
+
+  AgentX Portal - Your AI Agent Gateway (Multi-User Mode)
+`);
+  console.log("Configuration:");
+  console.log(`  Port: ${PORT}`);
+  console.log(`  API Key: ${process.env.LLM_PROVIDER_KEY.substring(0, 15)}...`);
+  console.log(`  User DB: ${USER_DB_PATH}`);
+  console.log(`  AgentX DB: ${join(homedir(), ".agentx/data/agentx.db")}`);
+  console.log(`
+Endpoints:`);
+  console.log(`  GET  /health                    - Health check`);
+  console.log(`  POST /api/auth/register         - Register new user`);
+  console.log(`  POST /api/auth/login            - Login`);
+  console.log(`  GET  /api/auth/verify           - Verify token`);
+  console.log(`  ---  AgentX API (protected) ---`);
+  console.log(`  GET  /agentx/info               - Platform info`);
+  console.log(`  GET  /agentx/containers         - List containers`);
+  console.log(`  POST /agentx/containers         - Create container`);
+  console.log(`  GET  /agentx/containers/:id     - Get container`);
+  console.log(`  DELETE /agentx/containers/:id   - Delete container`);
+  console.log(`  POST /agentx/agents             - Create agent`);
+  console.log(`  GET  /agentx/agents/:id/sse     - SSE stream`);
+  console.log(`  POST /agentx/agents/:id/messages- Send message`);
+  serve({
+    fetch: app.fetch,
+    port: PORT,
+    hostname: "0.0.0.0"
+  });
+  console.log(`
+\u{1F680} Server running at http://localhost:${PORT}`);
+  const shutdown = async () => {
+    console.log("\nShutting down...");
+    await agentx.agents.destroyAll();
+    userRepository.close();
+    console.log("Server stopped");
+    process.exit(0);
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+}
+export {
+  createApp,
+  startServer
+};
+//# sourceMappingURL=index.js.map