teleton 0.8.1 → 0.8.2

package/dist/{server-3FHI2SEB.js → chunk-XBSCYMKM.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-GGXJLMOH.js";
 import {
   invalidateEndpointCache,
   invalidateTonClientCache,
   setToncenterApiKey
-} from "./chunk-S6PHGKOC.js";
-import "./chunk-KVXV7EF7.js";
-import "./chunk-7TECSLJ4.js";
+} from "./chunk-7YKSXOQQ.js";
 import {
   getErrorMessage
-} from "./chunk-XBE4JB7C.js";
-import "./chunk-AYWEJCDB.js";
+} from "./chunk-3UFPFWYP.js";
 import {
   getProviderMetadata,
   validateApiKeyFormat
-} from "./chunk-PHSAHTK4.js";
-import "./chunk-QV2GLOTK.js";
-import "./chunk-7U7BOHCL.js";
-import "./chunk-3S4GGLLR.js";
+} from "./chunk-YOSUPUAJ.js";
 import {
   setTonapiKey
 } from "./chunk-VFA7QMCZ.js";
-import "./chunk-UP55PXFH.js";
-import "./chunk-XQUHC3JZ.js";
-import "./chunk-R4YSJ4EY.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
 };

package/dist/{chunk-PHSAHTK4.js → chunk-YOSUPUAJ.js}

@@ -1,6 +1,6 @@
 import {
   createLogger
-} from "./chunk-RCMD3U65.js";
+} from "./chunk-NQ6FZKCE.js";
 
 // src/config/providers.ts
 var PROVIDER_REGISTRY = {
@@ -30,12 +30,12 @@ var PROVIDER_REGISTRY = {
   },
   openai: {
     id: "openai",
-    displayName: "OpenAI (GPT-4o)",
+    displayName: "OpenAI (GPT-5.4)",
     envVar: "OPENAI_API_KEY",
     keyPrefix: "sk-",
     keyHint: "sk-proj-...",
     consoleUrl: "https://platform.openai.com/api-keys",
-    defaultModel: "gpt-4o",
+    defaultModel: "gpt-5.4",
     utilityModel: "gpt-4o-mini",
     toolLimit: 128,
     piAiProvider: "openai"
@@ -207,13 +207,17 @@ function validateApiKeyFormat(provider, key) {
 }
 
 // src/providers/claude-code-credentials.ts
-import { readFileSync, existsSync } from "fs";
+import { readFileSync, writeFileSync, existsSync } from "fs";
 import { execSync } from "child_process";
 import { homedir } from "os";
 import { join } from "path";
 var log = createLogger("ClaudeCodeCreds");
+var OAUTH_TOKEN_URL = "https://platform.claude.com/v1/oauth/token";
+var OAUTH_CLIENT_ID = "9d1c250a-e61b-44d9-88ed-5944d1962f5e";
+var OAUTH_SCOPES = "user:profile user:inference user:sessions:claude_code user:mcp_servers";
 var cachedToken = null;
 var cachedExpiresAt = 0;
+var cachedRefreshToken = null;
 function getClaudeConfigDir() {
   return process.env.CLAUDE_CONFIG_DIR || join(homedir(), ".claude");
 }
@@ -261,7 +265,8 @@ function extractToken(creds) {
   }
   return {
     token: oauth.accessToken,
-    expiresAt: oauth.expiresAt ?? 0
+    expiresAt: oauth.expiresAt ?? 0,
+    refreshToken: oauth.refreshToken
   };
 }
 function getClaudeCodeApiKey(fallbackKey) {
@@ -274,6 +279,7 @@ function getClaudeCodeApiKey(fallbackKey) {
     if (extracted) {
       cachedToken = extracted.token;
       cachedExpiresAt = extracted.expiresAt;
+      cachedRefreshToken = extracted.refreshToken ?? null;
       log.debug("Claude Code credentials loaded successfully");
       return cachedToken;
     }
@@ -284,20 +290,82 @@ function getClaudeCodeApiKey(fallbackKey) {
   }
   throw new Error("No Claude Code credentials found. Run 'claude login' or set api_key in config.");
 }
-function refreshClaudeCodeApiKey() {
+async function performOAuthRefresh(refreshToken) {
+  try {
+    const res = await fetch(OAUTH_TOKEN_URL, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        grant_type: "refresh_token",
+        refresh_token: refreshToken,
+        client_id: OAUTH_CLIENT_ID,
+        scope: OAUTH_SCOPES
+      })
+    });
+    if (!res.ok) {
+      log.warn(`OAuth token refresh failed: ${res.status} ${res.statusText}`);
+      return null;
+    }
+    const data = await res.json();
+    if (!data.access_token || !data.expires_in) {
+      log.warn("OAuth token refresh: unexpected response shape");
+      return null;
+    }
+    const newExpiresAt = Date.now() + data.expires_in * 1e3;
+    const newRefreshToken = data.refresh_token ?? refreshToken;
+    const filePath = getCredentialsFilePath();
+    try {
+      const existing = existsSync(filePath) ? JSON.parse(readFileSync(filePath, "utf-8")) : {};
+      const updated = {
+        ...existing,
+        claudeAiOauth: {
+          ...existing.claudeAiOauth,
+          accessToken: data.access_token,
+          refreshToken: newRefreshToken,
+          expiresAt: newExpiresAt
+        }
+      };
+      writeFileSync(filePath, JSON.stringify(updated, null, 2), { mode: 384 });
+    } catch (e) {
+      log.warn({ err: e }, "Failed to persist refreshed OAuth credentials to disk");
+    }
+    cachedToken = data.access_token;
+    cachedExpiresAt = newExpiresAt;
+    cachedRefreshToken = newRefreshToken;
+    log.info("Claude Code OAuth token refreshed successfully");
+    return cachedToken;
+  } catch (e) {
+    log.warn({ err: e }, "OAuth token refresh request failed");
+    return null;
+  }
+}
+async function refreshClaudeCodeApiKey() {
   cachedToken = null;
   cachedExpiresAt = 0;
+  if (!cachedRefreshToken) {
+    const creds2 = readCredentials();
+    if (creds2) {
+      const extracted = extractToken(creds2);
+      cachedRefreshToken = extracted?.refreshToken ?? null;
+    }
+  }
+  if (cachedRefreshToken) {
+    const refreshed = await performOAuthRefresh(cachedRefreshToken);
+    if (refreshed) return refreshed;
+    log.warn("OAuth refresh failed, falling back to disk read");
+  }
   const creds = readCredentials();
   if (creds) {
     const extracted = extractToken(creds);
     if (extracted) {
       cachedToken = extracted.token;
       cachedExpiresAt = extracted.expiresAt;
+      cachedRefreshToken = extracted.refreshToken ?? null;
       log.info("Claude Code credentials refreshed from disk");
       return cachedToken;
     }
   }
-  log.warn("Failed to refresh Claude Code credentials from disk");
+  log.warn("Failed to refresh Claude Code credentials");
   return null;
 }
 function isClaudeCodeTokenValid() {