teleton 0.8.1 → 0.8.3

package/dist/bootstrap-DDFVEMYI.js

@@ -0,0 +1,128 @@
+import {
+  AgentLifecycle
+} from "./chunk-NVKBBTI6.js";
+import {
+  configExists,
+  getDefaultConfigPath
+} from "./chunk-AEHTQI3H.js";
+import {
+  ensureWorkspace
+} from "./chunk-AERHOXGC.js";
+import "./chunk-C4NKJT2Z.js";
+import "./chunk-6OOHHJ4N.js";
+import {
+  SHUTDOWN_TIMEOUT_MS
+} from "./chunk-R4YSJ4EY.js";
+import "./chunk-EYWNOHMJ.js";
+import {
+  createLogger
+} from "./chunk-NQ6FZKCE.js";
+import "./chunk-3RG5ZIWI.js";
+
+// src/api/bootstrap.ts
+var log = createLogger("Bootstrap");
+async function startApiOnly(options) {
+  await ensureWorkspace({ ensureTemplates: false, silent: false });
+  const configPath = options.config ?? getDefaultConfigPath();
+  const lifecycle = new AgentLifecycle();
+  const deps = {
+    agent: null,
+    bridge: null,
+    memory: null,
+    toolRegistry: null,
+    plugins: null,
+    mcpServers: null,
+    config: {
+      enabled: false,
+      port: 7777,
+      host: "127.0.0.1",
+      cors_origins: [],
+      log_requests: false
+    },
+    configPath,
+    lifecycle,
+    marketplace: null,
+    userHookEvaluator: null
+  };
+  const { ApiServer } = await import("./server-JF6FX772.js");
+  const apiConfig = {
+    enabled: true,
+    port: parseInt(options.apiPort || process.env.TELETON_API_PORT || "7778"),
+    key_hash: "",
+    allowed_ips: []
+  };
+  const server = new ApiServer(deps, apiConfig);
+  let appInstance = null;
+  lifecycle.registerCallbacks(
+    // startFn — called when POST /v1/agent/start fires
+    async () => {
+      if (!configExists(configPath)) {
+        throw new Error("Configuration not found. Complete setup via /v1/setup endpoints first.");
+      }
+      const { TeletonApp } = await import("./index.js");
+      appInstance = new TeletonApp(configPath);
+      await appInstance.startAgentSubsystems();
+      server.updateDeps({
+        agent: appInstance.getAgent(),
+        bridge: appInstance.getBridge(),
+        memory: appInstance.getMemory(),
+        toolRegistry: appInstance.getToolRegistry(),
+        plugins: appInstance.getPlugins(),
+        config: appInstance.getWebuiConfig()
+      });
+    },
+    // stopFn — called when POST /v1/agent/stop fires
+    async () => {
+      if (appInstance) {
+        await appInstance.stopAgentSubsystems();
+        appInstance = null;
+        server.updateDeps({
+          agent: null,
+          bridge: null,
+          memory: null,
+          toolRegistry: null,
+          plugins: null
+        });
+      }
+    }
+  );
+  await server.start();
+  if (process.env.TELETON_JSON_CREDENTIALS === "true") {
+    const creds = server.getCredentials();
+    process.stdout.write(JSON.stringify(creds) + "\n");
+  }
+  log.info("API-only mode: complete setup via /v1/setup endpoints, then POST /v1/agent/start");
+  let shutdownInProgress = false;
+  const gracefulShutdown = async () => {
+    if (shutdownInProgress) return;
+    shutdownInProgress = true;
+    const forceExit = setTimeout(() => {
+      log.error("Shutdown timed out, forcing exit");
+      process.exit(1);
+    }, SHUTDOWN_TIMEOUT_MS);
+    forceExit.unref();
+    try {
+      if (lifecycle.getState() === "running") {
+        await lifecycle.stop();
+      }
+      await server.stop();
+    } finally {
+      clearTimeout(forceExit);
+      process.exit(0);
+    }
+  };
+  process.on("SIGINT", gracefulShutdown);
+  process.on("SIGTERM", gracefulShutdown);
+  process.on("unhandledRejection", (reason) => {
+    log.error({ err: reason }, "Unhandled rejection");
+  });
+  process.on("uncaughtException", (error) => {
+    log.error({ err: error }, "Uncaught exception");
+    process.exit(1);
+  });
+  await new Promise(() => {
+  });
+}
+export {
+  startApiOnly
+};

package/dist/{server-3FHI2SEB.js → chunk-2ERTYRHA.js}

@@ -1,6 +1,6 @@
 import {
   getModelsForProvider
-} from "./chunk-OJCLKU5Z.js";
+} from "./chunk-WFTC3JJW.js";
 import {
   CONFIGURABLE_KEYS,
   TonProxyManager,
@@ -30,31 +30,22 @@ import {
   validateWritePath,
   writePluginSecret,
   writeRawConfig
-} from "./chunk-CGOXE4WP.js";
+} from "./chunk-7MWKT67G.js";
 import {
   invalidateEndpointCache,
   invalidateTonClientCache,
   setToncenterApiKey
-} from "./chunk-S6PHGKOC.js";
-import "./chunk-KVXV7EF7.js";
-import "./chunk-7TECSLJ4.js";
+} from "./chunk-FUNF6H4W.js";
 import {
   getErrorMessage
-} from "./chunk-XBE4JB7C.js";
-import "./chunk-AYWEJCDB.js";
-import {
-  getProviderMetadata,
-  validateApiKeyFormat
-} from "./chunk-PHSAHTK4.js";
-import "./chunk-QV2GLOTK.js";
-import "./chunk-7U7BOHCL.js";
-import "./chunk-3S4GGLLR.js";
+} from "./chunk-3UFPFWYP.js";
 import {
   setTonapiKey
 } from "./chunk-VFA7QMCZ.js";
-import "./chunk-UP55PXFH.js";
-import "./chunk-XQUHC3JZ.js";
-import "./chunk-R4YSJ4EY.js";
+import {
+  getProviderMetadata,
+  validateApiKeyFormat
+} from "./chunk-6OOHHJ4N.js";
 import {
   WORKSPACE_PATHS,
   WORKSPACE_ROOT
@@ -63,41 +54,10 @@ import {
   addLogListener,
   clearLogListeners,
   createLogger
-} from "./chunk-RCMD3U65.js";
+} from "./chunk-NQ6FZKCE.js";
 import {
   getTaskStore
 } from "./chunk-4L66JHQE.js";
-import "./chunk-3RG5ZIWI.js";
-
-// src/webui/server.ts
-import { Hono as Hono14 } from "hono";
-import { serve } from "@hono/node-server";
-import { cors } from "hono/cors";
-import { streamSSE as streamSSE2 } from "hono/streaming";
-import { bodyLimit } from "hono/body-limit";
-import { setCookie, getCookie, deleteCookie } from "hono/cookie";
-import { existsSync as existsSync3, readFileSync as readFileSync3 } from "fs";
-import { join as join4, dirname, resolve as resolve2, relative as relative2 } 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/log-interceptor.ts
 var LogInterceptor = class {
@@ -444,9 +404,9 @@ function createLogsRoutes(_deps) {
         }),
         event: "log"
       });
-      await new Promise((resolve3) => {
-        if (aborted) return resolve3();
-        stream.onAbort(() => resolve3());
+      await new Promise((resolve2) => {
+        if (aborted) return resolve2();
+        stream.onAbort(() => resolve2());
       });
       if (cleanup) cleanup();
     });
@@ -2310,325 +2270,19 @@ function createTonProxyRoutes(deps) {
   return app;
 }
 
-// src/webui/server.ts
-var log3 = createLogger("WebUI");
-function findWebDist() {
-  const candidates = [
-    resolve2("dist/web"),
-    // npm start / teleton start (from project root)
-    resolve2("web")
-    // fallback
-  ];
-  const __dirname = dirname(fileURLToPath(import.meta.url));
-  candidates.push(
-    resolve2(__dirname, "web"),
-    // dist/web when __dirname = dist/
-    resolve2(__dirname, "../dist/web")
-    // when running with tsx from src/
-  );
-  for (const candidate of candidates) {
-    if (existsSync3(join4(candidate, "index.html"))) {
-      return candidate;
-    }
-  }
-  return null;
-}
-var WebUIServer = class {
-  app;
-  server = null;
-  deps;
-  authToken;
-  constructor(deps) {
-    this.deps = deps;
-    this.app = new Hono14();
-    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;
-        log3.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) => {
-        log3.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) => {
-        log3.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 streamSSE2(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 = readFileSync3(join4(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 = resolve2(join4(webDist, c.req.path));
-        const rel = relative2(webDist, filePath);
-        if (rel.startsWith("..") || resolve2(filePath) !== filePath) {
-          return c.html(indexHtml);
-        }
-        try {
-          const content = readFileSync3(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) => {
-      log3.error({ err }, "WebUI error");
-      return c.json(
-        {
-          success: false,
-          error: err.message || "Internal server error"
-        },
-        500
-      );
-    });
-  }
-  async start() {
-    return new Promise((resolve3, 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}`;
-            log3.info(`WebUI server running`);
-            log3.info(`URL: ${url}/auth/exchange?token=${this.authToken}`);
-            log3.info(`Token: ${maskToken(this.authToken)} (use Bearer header for API access)`);
-            resolve3();
-          }
-        );
-      } catch (error) {
-        logInterceptor.uninstall();
-        reject(error);
-      }
-    });
-  }
-  async stop() {
-    if (this.server) {
-      return new Promise((resolve3) => {
-        this.server?.close(() => {
-          logInterceptor.uninstall();
-          log3.info("WebUI server stopped");
-          resolve3();
-        });
-      });
-    }
-  }
-  getToken() {
-    return this.authToken;
-  }
-};
 export {
-  WebUIServer
+  logInterceptor,
+  createStatusRoutes,
+  createToolsRoutes,
+  createLogsRoutes,
+  createMemoryRoutes,
+  createSoulRoutes,
+  createPluginsRoutes,
+  createMcpRoutes,
+  createWorkspaceRoutes,
+  createTasksRoutes,
+  createConfigRoutes,
+  createMarketplaceRoutes,
+  createHooksRoutes,
+  createTonProxyRoutes
 };