teleton 0.8.0 → 0.8.2

package/dist/server-YODFBZKG.js

@@ -0,0 +1,392 @@
+import {
+  createConfigRoutes,
+  createHooksRoutes,
+  createLogsRoutes,
+  createMarketplaceRoutes,
+  createMcpRoutes,
+  createMemoryRoutes,
+  createPluginsRoutes,
+  createSoulRoutes,
+  createStatusRoutes,
+  createTasksRoutes,
+  createTonProxyRoutes,
+  createToolsRoutes,
+  createWorkspaceRoutes,
+  logInterceptor
+} from "./chunk-XBSCYMKM.js";
+import "./chunk-WFTC3JJW.js";
+import "./chunk-GGXJLMOH.js";
+import "./chunk-7YKSXOQQ.js";
+import "./chunk-55SKE6YH.js";
+import "./chunk-W25Z7CM6.js";
+import "./chunk-3UFPFWYP.js";
+import "./chunk-7TECSLJ4.js";
+import "./chunk-J73TA3UM.js";
+import "./chunk-YOSUPUAJ.js";
+import "./chunk-LC4TV3KL.js";
+import "./chunk-VYKW7FMV.js";
+import "./chunk-HEDJCLA6.js";
+import "./chunk-VFA7QMCZ.js";
+import "./chunk-C4NKJT2Z.js";
+import "./chunk-XQUHC3JZ.js";
+import "./chunk-R4YSJ4EY.js";
+import "./chunk-EYWNOHMJ.js";
+import {
+  createLogger
+} from "./chunk-NQ6FZKCE.js";
+import "./chunk-4L66JHQE.js";
+import "./chunk-3RG5ZIWI.js";
+
+// src/webui/server.ts
+import { Hono } from "hono";
+import { serve } from "@hono/node-server";
+import { cors } from "hono/cors";
+import { streamSSE } from "hono/streaming";
+import { bodyLimit } from "hono/body-limit";
+import { setCookie, getCookie, deleteCookie } from "hono/cookie";
+import { existsSync, readFileSync } from "fs";
+import { join, dirname, resolve, relative } from "path";
+import { fileURLToPath } from "url";
+
+// src/webui/middleware/auth.ts
+import { randomBytes, timingSafeEqual } from "crypto";
+var COOKIE_NAME = "teleton_session";
+var COOKIE_MAX_AGE = 7 * 24 * 60 * 60;
+function generateToken() {
+  return randomBytes(32).toString("base64url");
+}
+function maskToken(token) {
+  if (token.length < 12) return "****";
+  return `${token.slice(0, 4)}...${token.slice(-4)}`;
+}
+function safeCompare(a, b) {
+  if (!a || !b) return false;
+  const bufA = Buffer.from(a);
+  const bufB = Buffer.from(b);
+  if (bufA.length !== bufB.length) return false;
+  return timingSafeEqual(bufA, bufB);
+}
+
+// src/webui/server.ts
+var log = createLogger("WebUI");
+function findWebDist() {
+  const candidates = [
+    resolve("dist/web"),
+    // npm start / teleton start (from project root)
+    resolve("web")
+    // fallback
+  ];
+  const __dirname = dirname(fileURLToPath(import.meta.url));
+  candidates.push(
+    resolve(__dirname, "web"),
+    // dist/web when __dirname = dist/
+    resolve(__dirname, "../dist/web")
+    // when running with tsx from src/
+  );
+  for (const candidate of candidates) {
+    if (existsSync(join(candidate, "index.html"))) {
+      return candidate;
+    }
+  }
+  return null;
+}
+var WebUIServer = class {
+  app;
+  server = null;
+  deps;
+  authToken;
+  constructor(deps) {
+    this.deps = deps;
+    this.app = new Hono();
+    this.authToken = deps.config.auth_token || generateToken();
+    this.setupMiddleware();
+    this.setupRoutes();
+  }
+  /** Set an HttpOnly session cookie */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any -- Hono context type
+  setSessionCookie(c) {
+    setCookie(c, COOKIE_NAME, this.authToken, {
+      path: "/",
+      httpOnly: true,
+      sameSite: "Strict",
+      secure: false,
+      // localhost is HTTP
+      maxAge: COOKIE_MAX_AGE
+    });
+  }
+  setupMiddleware() {
+    this.app.use(
+      "*",
+      cors({
+        origin: this.deps.config.cors_origins,
+        credentials: true,
+        allowMethods: ["GET", "HEAD", "PUT", "POST", "DELETE", "PATCH"],
+        allowHeaders: ["Content-Type", "Authorization"],
+        maxAge: 3600
+      })
+    );
+    if (this.deps.config.log_requests) {
+      this.app.use("*", async (c, next) => {
+        const start = Date.now();
+        await next();
+        const duration = Date.now() - start;
+        log.info(`${c.req.method} ${c.req.path} \u2192 ${c.res.status} (${duration}ms)`);
+      });
+    }
+    this.app.use(
+      "*",
+      bodyLimit({
+        maxSize: 2 * 1024 * 1024,
+        // 2MB
+        onError: (c) => c.json({ success: false, error: "Request body too large (max 2MB)" }, 413)
+      })
+    );
+    this.app.use("*", async (c, next) => {
+      await next();
+      c.res.headers.set("X-Content-Type-Options", "nosniff");
+      c.res.headers.set("X-Frame-Options", "DENY");
+      c.res.headers.set("Referrer-Policy", "strict-origin-when-cross-origin");
+    });
+    this.app.use("/api/*", async (c, next) => {
+      const cookieToken = getCookie(c, COOKIE_NAME);
+      if (cookieToken && safeCompare(cookieToken, this.authToken)) {
+        return next();
+      }
+      const authHeader = c.req.header("Authorization");
+      if (authHeader) {
+        const match = authHeader.match(/^Bearer\s+(.+)$/i);
+        if (match && safeCompare(match[1], this.authToken)) {
+          return next();
+        }
+      }
+      const queryToken = c.req.query("token");
+      if (queryToken && safeCompare(queryToken, this.authToken)) {
+        return next();
+      }
+      return c.json({ success: false, error: "Unauthorized" }, 401);
+    });
+  }
+  setupRoutes() {
+    this.app.get("/health", (c) => c.json({ status: "ok" }));
+    this.app.get("/auth/exchange", (c) => {
+      const token = c.req.query("token");
+      if (!token || !safeCompare(token, this.authToken)) {
+        return c.json({ success: false, error: "Invalid token" }, 401);
+      }
+      this.setSessionCookie(c);
+      return c.redirect("/");
+    });
+    this.app.post("/auth/login", async (c) => {
+      try {
+        const body = await c.req.json();
+        if (!body.token || !safeCompare(body.token, this.authToken)) {
+          return c.json({ success: false, error: "Invalid token" }, 401);
+        }
+        this.setSessionCookie(c);
+        return c.json({ success: true });
+      } catch {
+        return c.json({ success: false, error: "Invalid request body" }, 400);
+      }
+    });
+    this.app.post("/auth/logout", (c) => {
+      deleteCookie(c, COOKIE_NAME, { path: "/" });
+      return c.json({ success: true });
+    });
+    this.app.get("/auth/check", (c) => {
+      const cookieToken = getCookie(c, COOKIE_NAME);
+      const authenticated = !!(cookieToken && safeCompare(cookieToken, this.authToken));
+      return c.json({ success: true, data: { authenticated } });
+    });
+    this.app.route("/api/status", createStatusRoutes(this.deps));
+    this.app.route("/api/tools", createToolsRoutes(this.deps));
+    this.app.route("/api/logs", createLogsRoutes(this.deps));
+    this.app.route("/api/memory", createMemoryRoutes(this.deps));
+    this.app.route("/api/soul", createSoulRoutes(this.deps));
+    this.app.route("/api/plugins", createPluginsRoutes(this.deps));
+    this.app.route("/api/mcp", createMcpRoutes(this.deps));
+    this.app.route("/api/workspace", createWorkspaceRoutes(this.deps));
+    this.app.route("/api/tasks", createTasksRoutes(this.deps));
+    this.app.route("/api/config", createConfigRoutes(this.deps));
+    this.app.route("/api/marketplace", createMarketplaceRoutes(this.deps));
+    this.app.route("/api/hooks", createHooksRoutes(this.deps));
+    this.app.route("/api/ton-proxy", createTonProxyRoutes(this.deps));
+    this.app.post("/api/agent/start", async (c) => {
+      const lifecycle = this.deps.lifecycle;
+      if (!lifecycle) {
+        return c.json({ error: "Agent lifecycle not available" }, 503);
+      }
+      const state = lifecycle.getState();
+      if (state === "running") {
+        return c.json({ state: "running" }, 409);
+      }
+      if (state === "stopping") {
+        return c.json({ error: "Agent is currently stopping, please wait" }, 409);
+      }
+      lifecycle.start().catch((err) => {
+        log.error({ err }, "Agent start failed");
+      });
+      return c.json({ state: "starting" });
+    });
+    this.app.post("/api/agent/stop", async (c) => {
+      const lifecycle = this.deps.lifecycle;
+      if (!lifecycle) {
+        return c.json({ error: "Agent lifecycle not available" }, 503);
+      }
+      const state = lifecycle.getState();
+      if (state === "stopped") {
+        return c.json({ state: "stopped" }, 409);
+      }
+      if (state === "starting") {
+        return c.json({ error: "Agent is currently starting, please wait" }, 409);
+      }
+      lifecycle.stop().catch((err) => {
+        log.error({ err }, "Agent stop failed");
+      });
+      return c.json({ state: "stopping" });
+    });
+    this.app.get("/api/agent/status", (c) => {
+      const lifecycle = this.deps.lifecycle;
+      if (!lifecycle) {
+        return c.json({ error: "Agent lifecycle not available" }, 503);
+      }
+      return c.json({
+        state: lifecycle.getState(),
+        uptime: lifecycle.getUptime(),
+        error: lifecycle.getError() ?? null
+      });
+    });
+    this.app.get("/api/agent/events", (c) => {
+      const lifecycle = this.deps.lifecycle;
+      if (!lifecycle) {
+        return c.json({ error: "Agent lifecycle not available" }, 503);
+      }
+      return streamSSE(c, async (stream) => {
+        let aborted = false;
+        stream.onAbort(() => {
+          aborted = true;
+        });
+        const now = Date.now();
+        await stream.writeSSE({
+          event: "status",
+          id: String(now),
+          data: JSON.stringify({
+            state: lifecycle.getState(),
+            error: lifecycle.getError() ?? null,
+            timestamp: now
+          }),
+          retry: 3e3
+        });
+        const onStateChange = (event) => {
+          if (aborted) return;
+          void stream.writeSSE({
+            event: "status",
+            id: String(event.timestamp),
+            data: JSON.stringify({
+              state: event.state,
+              error: event.error ?? null,
+              timestamp: event.timestamp
+            })
+          });
+        };
+        lifecycle.on("stateChange", onStateChange);
+        while (!aborted) {
+          await stream.sleep(3e4);
+          if (aborted) break;
+          await stream.writeSSE({
+            event: "ping",
+            data: ""
+          });
+        }
+        lifecycle.off("stateChange", onStateChange);
+      });
+    });
+    const webDist = findWebDist();
+    if (webDist) {
+      const indexHtml = readFileSync(join(webDist, "index.html"), "utf-8");
+      const mimeTypes = {
+        js: "application/javascript",
+        css: "text/css",
+        svg: "image/svg+xml",
+        png: "image/png",
+        jpg: "image/jpeg",
+        jpeg: "image/jpeg",
+        ico: "image/x-icon",
+        json: "application/json",
+        woff2: "font/woff2",
+        woff: "font/woff"
+      };
+      this.app.get("*", (c) => {
+        const filePath = resolve(join(webDist, c.req.path));
+        const rel = relative(webDist, filePath);
+        if (rel.startsWith("..") || resolve(filePath) !== filePath) {
+          return c.html(indexHtml);
+        }
+        try {
+          const content = readFileSync(filePath);
+          const ext = filePath.split(".").pop() || "";
+          if (mimeTypes[ext]) {
+            const immutable = c.req.path.startsWith("/assets/");
+            return c.body(content, 200, {
+              "Content-Type": mimeTypes[ext],
+              "Cache-Control": immutable ? "public, max-age=31536000, immutable" : "public, max-age=3600"
+            });
+          }
+        } catch {
+        }
+        return c.html(indexHtml);
+      });
+    }
+    this.app.onError((err, c) => {
+      log.error({ err }, "WebUI error");
+      return c.json(
+        {
+          success: false,
+          error: err.message || "Internal server error"
+        },
+        500
+      );
+    });
+  }
+  async start() {
+    return new Promise((resolve2, reject) => {
+      try {
+        logInterceptor.install();
+        this.server = serve(
+          {
+            fetch: this.app.fetch,
+            hostname: this.deps.config.host,
+            port: this.deps.config.port
+          },
+          (info) => {
+            const url = `http://${info.address}:${info.port}`;
+            log.info(`WebUI server running`);
+            log.info(`URL: ${url}/auth/exchange?token=${this.authToken}`);
+            log.info(`Token: ${maskToken(this.authToken)} (use Bearer header for API access)`);
+            resolve2();
+          }
+        );
+      } catch (error) {
+        logInterceptor.uninstall();
+        reject(error);
+      }
+    });
+  }
+  async stop() {
+    if (this.server) {
+      return new Promise((resolve2) => {
+        this.server.closeAllConnections();
+        this.server?.close(() => {
+          logInterceptor.uninstall();
+          log.info("WebUI server stopped");
+          resolve2();
+        });
+      });
+    }
+  }
+  getToken() {
+    return this.authToken;
+  }
+};
+export {
+  WebUIServer
+};

package/dist/setup-server-IZBUOJRU.js

@@ -0,0 +1,215 @@
+import {
+  createSetupRoutes
+} from "./chunk-57URFK6M.js";
+import "./chunk-WFTC3JJW.js";
+import "./chunk-7YKSXOQQ.js";
+import "./chunk-YOSUPUAJ.js";
+import "./chunk-VFA7QMCZ.js";
+import "./chunk-C4NKJT2Z.js";
+import "./chunk-XQUHC3JZ.js";
+import "./chunk-R4YSJ4EY.js";
+import {
+  TELETON_ROOT
+} from "./chunk-EYWNOHMJ.js";
+import {
+  createLogger
+} from "./chunk-NQ6FZKCE.js";
+import "./chunk-3RG5ZIWI.js";
+
+// src/webui/setup-server.ts
+import { Hono } from "hono";
+import { serve } from "@hono/node-server";
+import { cors } from "hono/cors";
+import { bodyLimit } from "hono/body-limit";
+import { existsSync, readFileSync } from "fs";
+import { join, dirname, resolve, relative } from "path";
+import { fileURLToPath } from "url";
+import { exec } from "child_process";
+import { platform } from "os";
+import { randomBytes } from "crypto";
+import { readFileSync as readYaml, writeFileSync } from "fs";
+import YAML from "yaml";
+var log = createLogger("Setup");
+function findWebDist() {
+  const candidates = [resolve("dist/web"), resolve("web")];
+  const __dirname = dirname(fileURLToPath(import.meta.url));
+  candidates.push(resolve(__dirname, "web"), resolve(__dirname, "../dist/web"));
+  for (const candidate of candidates) {
+    if (existsSync(join(candidate, "index.html"))) {
+      return candidate;
+    }
+  }
+  return null;
+}
+function autoOpenBrowser(url) {
+  const os = platform();
+  let cmd;
+  if (os === "darwin") {
+    cmd = `open "${url}"`;
+  } else if (os === "win32") {
+    cmd = `start "${url}"`;
+  } else {
+    cmd = `xdg-open "${url}"`;
+  }
+  exec(cmd, (err) => {
+    if (err) {
+      log.info(`Open this URL in your browser: ${url}`);
+    }
+  });
+}
+var SetupServer = class {
+  constructor(port = 7777) {
+    this.port = port;
+    this.app = new Hono();
+    this.launchPromise = new Promise((resolve2) => {
+      this.launchResolve = resolve2;
+    });
+    this.setupMiddleware();
+    this.setupRoutes();
+    this.setupStaticServing();
+  }
+  app;
+  server = null;
+  launchResolve = null;
+  launchPromise;
+  /** Returns a promise that resolves with the auth token when the user clicks "Start Agent" */
+  waitForLaunch() {
+    return this.launchPromise;
+  }
+  setupMiddleware() {
+    this.app.use(
+      "*",
+      cors({
+        origin: [
+          "http://localhost:5173",
+          `http://localhost:${this.port}`,
+          "http://127.0.0.1:5173",
+          `http://127.0.0.1:${this.port}`
+        ],
+        credentials: true,
+        allowMethods: ["GET", "HEAD", "PUT", "POST", "DELETE", "PATCH"],
+        allowHeaders: ["Content-Type"],
+        maxAge: 3600
+      })
+    );
+    this.app.use(
+      "*",
+      bodyLimit({
+        maxSize: 2 * 1024 * 1024,
+        onError: (c) => c.json({ success: false, error: "Request body too large (max 2MB)" }, 413)
+      })
+    );
+    this.app.use("*", async (c, next) => {
+      await next();
+      c.res.headers.set("X-Content-Type-Options", "nosniff");
+      c.res.headers.set("X-Frame-Options", "DENY");
+      c.res.headers.set("Referrer-Policy", "strict-origin-when-cross-origin");
+    });
+  }
+  setupRoutes() {
+    this.app.get("/health", (c) => c.json({ status: "ok" }));
+    this.app.route("/api/setup", createSetupRoutes());
+    this.app.get(
+      "/auth/check",
+      (c) => c.json({ success: true, data: { authenticated: false, setup: true } })
+    );
+    this.app.post("/api/setup/launch", async (c) => {
+      try {
+        const token = randomBytes(32).toString("hex");
+        const configPath = join(TELETON_ROOT, "config.yaml");
+        const raw = readYaml(configPath, "utf-8");
+        const config = YAML.parse(raw);
+        config.webui = { ...config.webui || {}, enabled: true, auth_token: token };
+        writeFileSync(configPath, YAML.stringify(config), { encoding: "utf-8", mode: 384 });
+        log.info("Launch requested \u2014 auth token generated");
+        const resolve2 = this.launchResolve;
+        this.launchResolve = null;
+        if (resolve2) {
+          setTimeout(() => resolve2(token), 500);
+        }
+        return c.json({ success: true, data: { token } });
+      } catch (err) {
+        return c.json(
+          { success: false, error: err instanceof Error ? err.message : String(err) },
+          500
+        );
+      }
+    });
+    this.app.onError((err, c) => {
+      log.error({ err }, "Setup server error");
+      return c.json({ success: false, error: err.message || "Internal server error" }, 500);
+    });
+  }
+  setupStaticServing() {
+    const webDist = findWebDist();
+    if (!webDist) return;
+    const indexHtml = readFileSync(join(webDist, "index.html"), "utf-8");
+    const mimeTypes = {
+      js: "application/javascript",
+      css: "text/css",
+      svg: "image/svg+xml",
+      png: "image/png",
+      jpg: "image/jpeg",
+      jpeg: "image/jpeg",
+      ico: "image/x-icon",
+      json: "application/json",
+      woff2: "font/woff2",
+      woff: "font/woff"
+    };
+    this.app.get("*", (c) => {
+      const filePath = resolve(join(webDist, c.req.path));
+      const rel = relative(webDist, filePath);
+      if (rel.startsWith("..") || resolve(filePath) !== filePath) {
+        return c.html(indexHtml);
+      }
+      try {
+        const content = readFileSync(filePath);
+        const ext = filePath.split(".").pop() || "";
+        if (mimeTypes[ext]) {
+          const immutable = c.req.path.startsWith("/assets/");
+          return c.body(content, 200, {
+            "Content-Type": mimeTypes[ext],
+            "Cache-Control": immutable ? "public, max-age=31536000, immutable" : "public, max-age=3600"
+          });
+        }
+      } catch {
+      }
+      return c.html(indexHtml);
+    });
+  }
+  async start() {
+    return new Promise((resolve2, reject) => {
+      try {
+        this.server = serve(
+          {
+            fetch: this.app.fetch,
+            hostname: "127.0.0.1",
+            port: this.port
+          },
+          () => {
+            const url = `http://localhost:${this.port}/setup`;
+            log.info(`Setup wizard: ${url}`);
+            autoOpenBrowser(url);
+            resolve2();
+          }
+        );
+      } catch (error) {
+        reject(error);
+      }
+    });
+  }
+  async stop() {
+    if (this.server) {
+      return new Promise((resolve2) => {
+        this.server.closeAllConnections();
+        this.server?.close(() => {
+          log.info("Setup server stopped");
+          resolve2();
+        });
+      });
+    }
+  }
+};
+export {
+  SetupServer
+};

package/dist/{store-GAFULOOX.js → store-7M4XV6M5.js}

@@ -9,16 +9,16 @@ import {
   saveSessionStore,
   shouldResetSession,
   updateSession
-} from "./chunk-TVRZJIZX.js";
-import "./chunk-SD4NLLYG.js";
-import "./chunk-U56QTM46.js";
+} from "./chunk-55SKE6YH.js";
+import "./chunk-VYKW7FMV.js";
+import "./chunk-HEDJCLA6.js";
 import "./chunk-VFA7QMCZ.js";
-import "./chunk-IJBWWQE4.js";
+import "./chunk-C4NKJT2Z.js";
 import "./chunk-XQUHC3JZ.js";
 import "./chunk-R4YSJ4EY.js";
 import "./chunk-EYWNOHMJ.js";
-import "./chunk-RCMD3U65.js";
-import "./chunk-NUGDTPE4.js";
+import "./chunk-NQ6FZKCE.js";
+import "./chunk-4L66JHQE.js";
 import "./chunk-3RG5ZIWI.js";
 export {
   getOrCreateSession,

package/dist/{task-dependency-resolver-3FIKQ7Z6.js → task-dependency-resolver-L6UUMTHK.js}

@@ -1,12 +1,12 @@
 import {
   MAX_DEPENDENTS_PER_TASK
-} from "./chunk-IJBWWQE4.js";
+} from "./chunk-C4NKJT2Z.js";
 import {
   BATCH_TRIGGER_DELAY_MS
 } from "./chunk-R4YSJ4EY.js";
 import {
   createLogger
-} from "./chunk-RCMD3U65.js";
+} from "./chunk-NQ6FZKCE.js";
 import "./chunk-3RG5ZIWI.js";
 
 // src/telegram/task-dependency-resolver.ts
@@ -104,7 +104,7 @@ var TaskDependencyResolver = class {
           try {
             const payload = JSON.parse(task.payload);
             skipOnFailure = payload.skipOnParentFailure !== false;
-          } catch (e) {
+          } catch {
           }
         }
         if (skipOnFailure) {

package/dist/{task-executor-RUTFG6VG.js → task-executor-XBNJLUCS.js}

@@ -1,12 +1,12 @@
 import {
   getErrorMessage
-} from "./chunk-XBE4JB7C.js";
+} from "./chunk-3UFPFWYP.js";
 import {
   MAX_JSON_FIELD_CHARS,
   MAX_TOTAL_PROMPT_CHARS,
   SECONDS_PER_DAY,
   SECONDS_PER_HOUR
-} from "./chunk-IJBWWQE4.js";
+} from "./chunk-C4NKJT2Z.js";
 import "./chunk-3RG5ZIWI.js";
 
 // src/telegram/task-executor.ts
@@ -17,7 +17,7 @@ function truncateJson(data, maxChars = MAX_JSON_FIELD_CHARS) {
       return str;
     }
     return str.slice(0, maxChars - 50) + "\n... [TRUNCATED - " + (str.length - maxChars + 50) + " chars omitted]";
-  } catch (e) {
+  } catch {
     return "[Error serializing data]";
   }
 }

package/dist/{tasks-BEZ4QRI2.js → tasks-WQIKXDX5.js}

@@ -1,7 +1,7 @@
 import {
   TaskStore,
   getTaskStore
-} from "./chunk-NUGDTPE4.js";
+} from "./chunk-4L66JHQE.js";
 import "./chunk-3RG5ZIWI.js";
 export {
   TaskStore,

package/dist/{tool-adapter-IH5VGBOO.js → tool-adapter-IVX2XQJE.js}

@@ -1,6 +1,6 @@
 import {
   createLogger
-} from "./chunk-RCMD3U65.js";
+} from "./chunk-NQ6FZKCE.js";
 import "./chunk-3RG5ZIWI.js";
 
 // src/cocoon/tool-adapter.ts