teleton 0.6.0 → 0.7.1

package/dist/setup-server-C7ZTPHD5.js

@@ -0,0 +1,934 @@
+import {
+  ConfigSchema,
+  DealsConfigSchema,
+  ensureWorkspace,
+  generateWallet,
+  getWalletAddress,
+  importWallet,
+  isNewWorkspace,
+  saveWallet,
+  walletExists
+} from "./chunk-NERLQY2H.js";
+import "./chunk-QUAPFI2N.js";
+import {
+  getProviderMetadata,
+  getSupportedProviders,
+  validateApiKeyFormat
+} from "./chunk-LRCPA7SC.js";
+import "./chunk-XBKSS6DM.js";
+import {
+  TELEGRAM_MAX_MESSAGE_LENGTH
+} from "./chunk-RO62LO6Z.js";
+import {
+  fetchWithTimeout
+} from "./chunk-VAUJSSD3.js";
+import "./chunk-4DU3C27M.js";
+import {
+  TELETON_ROOT
+} from "./chunk-EYWNOHMJ.js";
+import {
+  createLogger
+} from "./chunk-RCMD3U65.js";
+import "./chunk-QGM4M3NI.js";
+
+// src/webui/setup-server.ts
+import { Hono as Hono2 } from "hono";
+import { serve } from "@hono/node-server";
+import { cors } from "hono/cors";
+import { bodyLimit } from "hono/body-limit";
+import { existsSync as existsSync3, readFileSync as readFileSync2 } from "fs";
+import { join as join3, dirname as dirname2, resolve, relative } from "path";
+import { fileURLToPath } from "url";
+import { exec } from "child_process";
+import { platform } from "os";
+
+// src/webui/routes/setup.ts
+import { Hono } from "hono";
+import { existsSync as existsSync2, readFileSync, writeFileSync as writeFileSync2 } from "fs";
+import { join as join2 } from "path";
+import YAML from "yaml";
+
+// src/webui/setup-auth.ts
+import { TelegramClient, Api } from "telegram";
+import { StringSession } from "telegram/sessions/index.js";
+import { computeCheck } from "telegram/Password.js";
+import { Logger, LogLevel } from "telegram/extensions/Logger.js";
+import { writeFileSync, mkdirSync, existsSync } from "fs";
+import { dirname, join } from "path";
+import { randomBytes } from "crypto";
+var log = createLogger("Setup");
+var SESSION_TTL_MS = 5 * 60 * 1e3;
+var MAX_CODE_ATTEMPTS = 5;
+var MAX_PASSWORD_ATTEMPTS = 3;
+var TelegramAuthManager = class {
+  session = null;
+  /**
+   * Send verification code to phone number
+   */
+  async sendCode(apiId, apiHash, phone) {
+    await this.cleanup();
+    const gramLogger = new Logger(LogLevel.NONE);
+    const client = new TelegramClient(new StringSession(""), apiId, apiHash, {
+      connectionRetries: 3,
+      floodSleepThreshold: 0,
+      baseLogger: gramLogger
+    });
+    await client.connect();
+    const result = await client.sendCode({ apiId, apiHash }, phone);
+    const id = randomBytes(16).toString("hex");
+    const expiresAt = Date.now() + SESSION_TTL_MS;
+    this.session = {
+      id,
+      client,
+      phone,
+      phoneCodeHash: result.phoneCodeHash,
+      state: "code_sent",
+      codeAttempts: 0,
+      passwordAttempts: 0,
+      createdAt: Date.now(),
+      apiId,
+      apiHash,
+      timer: setTimeout(() => this.cleanup(), SESSION_TTL_MS)
+    };
+    log.info("Telegram verification code sent");
+    return { authSessionId: id, codeViaApp: result.isCodeViaApp, expiresAt };
+  }
+  /**
+   * Verify the code entered by the user
+   */
+  async verifyCode(authSessionId, code) {
+    const session = this.getSession(authSessionId);
+    if (!session) return { status: "expired" };
+    if (session.codeAttempts >= MAX_CODE_ATTEMPTS) {
+      return { status: "too_many_attempts" };
+    }
+    session.codeAttempts++;
+    try {
+      const result = await session.client.invoke(
+        new Api.auth.SignIn({
+          phoneNumber: session.phone,
+          phoneCodeHash: session.phoneCodeHash,
+          phoneCode: code
+        })
+      );
+      session.state = "authenticated";
+      const user = this.extractUser(result);
+      await this.saveSession(session);
+      log.info("Telegram authentication successful");
+      return { status: "authenticated", user };
+    } catch (err) {
+      const error = err;
+      if (error.errorMessage === "SESSION_PASSWORD_NEEDED") {
+        session.state = "2fa_required";
+        try {
+          const passwordResult = await session.client.invoke(new Api.account.GetPassword());
+          session.passwordHint = passwordResult.hint ?? void 0;
+        } catch {
+        }
+        return { status: "2fa_required", passwordHint: session.passwordHint };
+      }
+      if (error.errorMessage === "PHONE_CODE_INVALID") {
+        return { status: "invalid_code" };
+      }
+      if (error.errorMessage === "PHONE_CODE_EXPIRED") {
+        session.state = "failed";
+        return { status: "expired" };
+      }
+      throw err;
+    }
+  }
+  /**
+   * Verify 2FA password
+   */
+  async verifyPassword(authSessionId, password) {
+    const session = this.getSession(authSessionId);
+    if (!session) return { status: "expired" };
+    if (session.state !== "2fa_required") return { status: "expired" };
+    if (session.passwordAttempts >= MAX_PASSWORD_ATTEMPTS) {
+      return { status: "too_many_attempts" };
+    }
+    session.passwordAttempts++;
+    try {
+      const srpResult = await session.client.invoke(new Api.account.GetPassword());
+      const srpCheck = await computeCheck(srpResult, password);
+      const result = await session.client.invoke(
+        new Api.auth.CheckPassword({ password: srpCheck })
+      );
+      session.state = "authenticated";
+      const user = this.extractUser(result);
+      await this.saveSession(session);
+      log.info("Telegram 2FA authentication successful");
+      return { status: "authenticated", user };
+    } catch (err) {
+      const error = err;
+      if (error.errorMessage === "PASSWORD_HASH_INVALID") {
+        return { status: "invalid_password" };
+      }
+      throw err;
+    }
+  }
+  /**
+   * Resend verification code
+   */
+  async resendCode(authSessionId) {
+    const session = this.getSession(authSessionId);
+    if (!session || session.state !== "code_sent") return null;
+    const result = await session.client.invoke(
+      new Api.auth.ResendCode({
+        phoneNumber: session.phone,
+        phoneCodeHash: session.phoneCodeHash
+      })
+    );
+    if (result instanceof Api.auth.SentCode) {
+      session.phoneCodeHash = result.phoneCodeHash;
+      session.codeAttempts = 0;
+      const codeViaApp = result.type instanceof Api.auth.SentCodeTypeApp;
+      return { codeViaApp };
+    }
+    return { codeViaApp: false };
+  }
+  /**
+   * Cancel and clean up session
+   */
+  async cancelSession(authSessionId) {
+    if (this.session?.id === authSessionId) {
+      await this.cleanup();
+    }
+  }
+  /**
+   * Clean up: disconnect client, clear timer, remove session
+   */
+  async cleanup() {
+    if (!this.session) return;
+    clearTimeout(this.session.timer);
+    try {
+      if (this.session.client.connected) {
+        await this.session.client.disconnect();
+      }
+    } catch (err) {
+      log.warn({ err }, "Error disconnecting auth client");
+    }
+    this.session = null;
+  }
+  getSession(id) {
+    if (!this.session || this.session.id !== id) return null;
+    if (Date.now() - this.session.createdAt > SESSION_TTL_MS) {
+      this.cleanup();
+      return null;
+    }
+    return this.session;
+  }
+  extractUser(result) {
+    if (result instanceof Api.auth.Authorization && result.user instanceof Api.User) {
+      return {
+        id: Number(result.user.id),
+        firstName: result.user.firstName ?? "",
+        username: result.user.username ?? void 0
+      };
+    }
+    return void 0;
+  }
+  async saveSession(session) {
+    const sessionString = session.client.session.save();
+    const sessionPath = join(TELETON_ROOT, "telegram_session.txt");
+    const dir = dirname(sessionPath);
+    if (!existsSync(dir)) {
+      mkdirSync(dir, { recursive: true });
+    }
+    writeFileSync(sessionPath, sessionString, { mode: 384 });
+    log.info("Telegram session saved");
+  }
+};
+
+// src/webui/routes/setup.ts
+var log2 = createLogger("Setup");
+var MODEL_OPTIONS = {
+  anthropic: [
+    {
+      value: "claude-opus-4-5-20251101",
+      name: "Claude Opus 4.5",
+      description: "Most capable, $5/M"
+    },
+    { value: "claude-sonnet-4-0", name: "Claude Sonnet 4", description: "Balanced, $3/M" },
+    {
+      value: "claude-haiku-4-5-20251001",
+      name: "Claude Haiku 4.5",
+      description: "Fast & cheap, $1/M"
+    },
+    {
+      value: "claude-3-5-haiku-20241022",
+      name: "Claude 3.5 Haiku",
+      description: "Cheapest, $0.80/M"
+    }
+  ],
+  openai: [
+    { value: "gpt-5", name: "GPT-5", description: "Most capable, 400K ctx, $1.25/M" },
+    { value: "gpt-4o", name: "GPT-4o", description: "Balanced, 128K ctx, $2.50/M" },
+    { value: "gpt-4.1", name: "GPT-4.1", description: "1M ctx, $2/M" },
+    { value: "gpt-4.1-mini", name: "GPT-4.1 Mini", description: "1M ctx, cheap, $0.40/M" },
+    { value: "o3", name: "o3", description: "Reasoning, 200K ctx, $2/M" }
+  ],
+  google: [
+    { value: "gemini-2.5-flash", name: "Gemini 2.5 Flash", description: "Fast, 1M ctx, $0.30/M" },
+    {
+      value: "gemini-2.5-pro",
+      name: "Gemini 2.5 Pro",
+      description: "Most capable, 1M ctx, $1.25/M"
+    },
+    { value: "gemini-2.0-flash", name: "Gemini 2.0 Flash", description: "Cheap, 1M ctx, $0.10/M" }
+  ],
+  xai: [
+    { value: "grok-4-fast", name: "Grok 4 Fast", description: "Vision, 2M ctx, $0.20/M" },
+    { value: "grok-4", name: "Grok 4", description: "Reasoning, 256K ctx, $3/M" },
+    { value: "grok-3", name: "Grok 3", description: "Stable, 131K ctx, $3/M" }
+  ],
+  groq: [
+    {
+      value: "meta-llama/llama-4-maverick-17b-128e-instruct",
+      name: "Llama 4 Maverick",
+      description: "Vision, 131K ctx, $0.20/M"
+    },
+    { value: "qwen/qwen3-32b", name: "Qwen3 32B", description: "Reasoning, 131K ctx, $0.29/M" },
+    {
+      value: "deepseek-r1-distill-llama-70b",
+      name: "DeepSeek R1 70B",
+      description: "Reasoning, 131K ctx, $0.75/M"
+    },
+    {
+      value: "llama-3.3-70b-versatile",
+      name: "Llama 3.3 70B",
+      description: "General purpose, 131K ctx, $0.59/M"
+    }
+  ],
+  openrouter: [
+    { value: "anthropic/claude-opus-4.5", name: "Claude Opus 4.5", description: "200K ctx, $5/M" },
+    { value: "openai/gpt-5", name: "GPT-5", description: "400K ctx, $1.25/M" },
+    { value: "google/gemini-2.5-flash", name: "Gemini 2.5 Flash", description: "1M ctx, $0.30/M" },
+    {
+      value: "deepseek/deepseek-r1",
+      name: "DeepSeek R1",
+      description: "Reasoning, 64K ctx, $0.70/M"
+    },
+    { value: "x-ai/grok-4", name: "Grok 4", description: "256K ctx, $3/M" }
+  ],
+  moonshot: [
+    { value: "kimi-k2.5", name: "Kimi K2.5", description: "Free, 256K ctx, multimodal" },
+    {
+      value: "kimi-k2-thinking",
+      name: "Kimi K2 Thinking",
+      description: "Free, 256K ctx, reasoning"
+    }
+  ],
+  mistral: [
+    {
+      value: "devstral-small-2507",
+      name: "Devstral Small",
+      description: "Coding, 128K ctx, $0.10/M"
+    },
+    {
+      value: "devstral-medium-latest",
+      name: "Devstral Medium",
+      description: "Coding, 262K ctx, $0.40/M"
+    },
+    {
+      value: "mistral-large-latest",
+      name: "Mistral Large",
+      description: "General, 128K ctx, $2/M"
+    },
+    {
+      value: "magistral-small",
+      name: "Magistral Small",
+      description: "Reasoning, 128K ctx, $0.50/M"
+    }
+  ]
+};
+function maskKey(key) {
+  if (key.length <= 10) return "***";
+  return key.slice(0, 6) + "..." + key.slice(-4);
+}
+function createSetupRoutes() {
+  const app = new Hono();
+  const authManager = new TelegramAuthManager();
+  app.get("/status", async (c) => {
+    try {
+      const configPath = join2(TELETON_ROOT, "config.yaml");
+      const sessionPath = join2(TELETON_ROOT, "telegram_session.txt");
+      const envApiKey = process.env.TELETON_API_KEY;
+      const envApiId = process.env.TELETON_TG_API_ID;
+      const envApiHash = process.env.TELETON_TG_API_HASH;
+      const envPhone = process.env.TELETON_TG_PHONE;
+      return c.json({
+        success: true,
+        data: {
+          workspaceExists: existsSync2(join2(TELETON_ROOT, "workspace")),
+          configExists: existsSync2(configPath),
+          walletExists: walletExists(),
+          walletAddress: getWalletAddress(),
+          sessionExists: existsSync2(sessionPath),
+          envVars: {
+            apiKey: envApiKey ? maskKey(envApiKey) : null,
+            apiKeyRaw: !!envApiKey,
+            telegramApiId: envApiId ?? null,
+            telegramApiHash: envApiHash ? maskKey(envApiHash) : null,
+            telegramPhone: envPhone ?? null
+          }
+        }
+      });
+    } catch (err) {
+      return c.json(
+        { success: false, error: err instanceof Error ? err.message : String(err) },
+        500
+      );
+    }
+  });
+  app.get("/providers", (c) => {
+    const providers = getSupportedProviders().map((p) => ({
+      id: p.id,
+      displayName: p.displayName,
+      defaultModel: p.defaultModel,
+      utilityModel: p.utilityModel,
+      toolLimit: p.toolLimit,
+      keyPrefix: p.keyPrefix,
+      consoleUrl: p.consoleUrl,
+      requiresApiKey: p.id !== "cocoon" && p.id !== "local",
+      requiresBaseUrl: p.id === "local"
+    }));
+    return c.json({ success: true, data: providers });
+  });
+  app.get("/models/:provider", (c) => {
+    const provider = c.req.param("provider");
+    const models = MODEL_OPTIONS[provider] || [];
+    const result = [
+      ...models,
+      {
+        value: "__custom__",
+        name: "Custom",
+        description: "Enter a model ID manually",
+        isCustom: true
+      }
+    ];
+    return c.json({ success: true, data: result });
+  });
+  app.post("/validate/api-key", async (c) => {
+    try {
+      const body = await c.req.json();
+      const error = validateApiKeyFormat(body.provider, body.apiKey);
+      return c.json({ success: true, data: { valid: !error, error } });
+    } catch (err) {
+      return c.json(
+        { success: false, error: err instanceof Error ? err.message : String(err) },
+        400
+      );
+    }
+  });
+  app.post("/validate/bot-token", async (c) => {
+    try {
+      const body = await c.req.json();
+      if (!body.token || !body.token.includes(":")) {
+        return c.json({
+          success: true,
+          data: { valid: false, networkError: false, error: "Invalid format (expected id:hash)" }
+        });
+      }
+      try {
+        const res = await fetchWithTimeout(`https://api.telegram.org/bot${body.token}/getMe`);
+        const data = await res.json();
+        if (!data.ok) {
+          return c.json({
+            success: true,
+            data: { valid: false, networkError: false, error: "Bot token is invalid" }
+          });
+        }
+        return c.json({
+          success: true,
+          data: {
+            valid: true,
+            networkError: false,
+            bot: { username: data.result.username, firstName: data.result.first_name }
+          }
+        });
+      } catch {
+        return c.json({
+          success: true,
+          data: { valid: false, networkError: true, error: "Could not reach Telegram API" }
+        });
+      }
+    } catch (err) {
+      return c.json(
+        { success: false, error: err instanceof Error ? err.message : String(err) },
+        400
+      );
+    }
+  });
+  app.post("/workspace/init", async (c) => {
+    try {
+      const body = await c.req.json().catch(() => ({ agentName: void 0, workspaceDir: void 0 }));
+      const workspace = await ensureWorkspace({
+        workspaceDir: body.workspaceDir,
+        ensureTemplates: true
+      });
+      if (body.agentName?.trim() && existsSync2(workspace.identityPath)) {
+        const identity = readFileSync(workspace.identityPath, "utf-8");
+        const updated = identity.replace(
+          "[Your name - pick one or ask your human]",
+          body.agentName.trim()
+        );
+        writeFileSync2(workspace.identityPath, updated, "utf-8");
+      }
+      return c.json({
+        success: true,
+        data: { created: !isNewWorkspace(workspace) === false, path: workspace.root }
+      });
+    } catch (err) {
+      return c.json(
+        { success: false, error: err instanceof Error ? err.message : String(err) },
+        500
+      );
+    }
+  });
+  app.get("/wallet/status", (c) => {
+    const exists = walletExists();
+    const address = exists ? getWalletAddress() : void 0;
+    return c.json({ success: true, data: { exists, address } });
+  });
+  app.post("/wallet/generate", async (c) => {
+    try {
+      const wallet = await generateWallet();
+      saveWallet(wallet);
+      log2.info("New TON wallet generated via setup UI");
+      return c.json({
+        success: true,
+        data: { address: wallet.address, mnemonic: wallet.mnemonic }
+      });
+    } catch (err) {
+      return c.json(
+        { success: false, error: err instanceof Error ? err.message : String(err) },
+        500
+      );
+    }
+  });
+  app.post("/wallet/import", async (c) => {
+    try {
+      const body = await c.req.json();
+      const words = body.mnemonic.trim().split(/\s+/);
+      if (words.length !== 24) {
+        return c.json({ success: false, error: `Expected 24 words, got ${words.length}` }, 400);
+      }
+      const wallet = await importWallet(words);
+      saveWallet(wallet);
+      log2.info("TON wallet imported via setup UI");
+      return c.json({ success: true, data: { address: wallet.address } });
+    } catch (err) {
+      return c.json(
+        { success: false, error: err instanceof Error ? err.message : String(err) },
+        400
+      );
+    }
+  });
+  app.post("/telegram/send-code", async (c) => {
+    try {
+      const body = await c.req.json();
+      if (!body.apiId || !body.apiHash || !body.phone) {
+        return c.json({ success: false, error: "Missing apiId, apiHash, or phone" }, 400);
+      }
+      const result = await authManager.sendCode(body.apiId, body.apiHash, body.phone);
+      return c.json({ success: true, data: result });
+    } catch (err) {
+      const error = err;
+      if (error.seconds) {
+        return c.json(
+          {
+            success: false,
+            error: `Rate limited. Please wait ${error.seconds} seconds.`
+          },
+          429
+        );
+      }
+      return c.json(
+        { success: false, error: error.errorMessage || error.message || String(err) },
+        500
+      );
+    }
+  });
+  app.post("/telegram/verify-code", async (c) => {
+    try {
+      const body = await c.req.json();
+      if (!body.authSessionId || !body.code) {
+        return c.json({ success: false, error: "Missing authSessionId or code" }, 400);
+      }
+      const result = await authManager.verifyCode(body.authSessionId, body.code);
+      return c.json({ success: true, data: result });
+    } catch (err) {
+      const error = err;
+      if (error.seconds) {
+        return c.json(
+          {
+            success: false,
+            error: `Rate limited. Please wait ${error.seconds} seconds.`
+          },
+          429
+        );
+      }
+      return c.json(
+        { success: false, error: error.errorMessage || error.message || String(err) },
+        500
+      );
+    }
+  });
+  app.post("/telegram/verify-password", async (c) => {
+    try {
+      const body = await c.req.json();
+      if (!body.authSessionId || !body.password) {
+        return c.json({ success: false, error: "Missing authSessionId or password" }, 400);
+      }
+      const result = await authManager.verifyPassword(body.authSessionId, body.password);
+      return c.json({ success: true, data: result });
+    } catch (err) {
+      const error = err;
+      if (error.seconds) {
+        return c.json(
+          {
+            success: false,
+            error: `Rate limited. Please wait ${error.seconds} seconds.`
+          },
+          429
+        );
+      }
+      return c.json(
+        { success: false, error: error.errorMessage || error.message || String(err) },
+        500
+      );
+    }
+  });
+  app.post("/telegram/resend-code", async (c) => {
+    try {
+      const body = await c.req.json();
+      if (!body.authSessionId) {
+        return c.json({ success: false, error: "Missing authSessionId" }, 400);
+      }
+      const result = await authManager.resendCode(body.authSessionId);
+      if (!result) {
+        return c.json({ success: false, error: "Session expired or invalid" }, 400);
+      }
+      return c.json({ success: true, data: result });
+    } catch (err) {
+      const error = err;
+      if (error.seconds) {
+        return c.json(
+          {
+            success: false,
+            error: `Rate limited. Please wait ${error.seconds} seconds.`
+          },
+          429
+        );
+      }
+      return c.json(
+        { success: false, error: error.errorMessage || error.message || String(err) },
+        500
+      );
+    }
+  });
+  app.delete("/telegram/session", async (c) => {
+    try {
+      const body = await c.req.json().catch(() => ({ authSessionId: "" }));
+      await authManager.cancelSession(body.authSessionId);
+      return c.json({ success: true });
+    } catch (err) {
+      return c.json(
+        { success: false, error: err instanceof Error ? err.message : String(err) },
+        500
+      );
+    }
+  });
+  app.post("/config/save", async (c) => {
+    try {
+      const input = await c.req.json();
+      const workspace = await ensureWorkspace({ ensureTemplates: true });
+      const providerMeta = getProviderMetadata(input.agent.provider);
+      const config = {
+        meta: {
+          version: "1.0.0",
+          created_at: (/* @__PURE__ */ new Date()).toISOString(),
+          onboard_command: "teleton setup --ui"
+        },
+        agent: {
+          provider: input.agent.provider,
+          api_key: input.agent.api_key ?? "",
+          ...input.agent.base_url ? { base_url: input.agent.base_url } : {},
+          model: input.agent.model || providerMeta.defaultModel,
+          max_tokens: 4096,
+          temperature: 0.7,
+          system_prompt: null,
+          max_agentic_iterations: input.agent.max_agentic_iterations ?? 5,
+          session_reset_policy: {
+            daily_reset_enabled: true,
+            daily_reset_hour: 4,
+            idle_expiry_enabled: true,
+            idle_expiry_minutes: 1440
+          }
+        },
+        telegram: {
+          api_id: input.telegram.api_id,
+          api_hash: input.telegram.api_hash,
+          phone: input.telegram.phone,
+          session_name: "teleton_session",
+          session_path: workspace.sessionPath,
+          dm_policy: input.telegram.dm_policy ?? "open",
+          allow_from: [],
+          group_policy: input.telegram.group_policy ?? "open",
+          group_allow_from: [],
+          require_mention: input.telegram.require_mention ?? true,
+          max_message_length: TELEGRAM_MAX_MESSAGE_LENGTH,
+          typing_simulation: true,
+          rate_limit_messages_per_second: 1,
+          rate_limit_groups_per_minute: 20,
+          admin_ids: [input.telegram.owner_id],
+          owner_id: input.telegram.owner_id,
+          agent_channel: null,
+          debounce_ms: 1500,
+          bot_token: input.telegram.bot_token,
+          bot_username: input.telegram.bot_username
+        },
+        storage: {
+          sessions_file: `${workspace.root}/sessions.json`,
+          pairing_file: `${workspace.root}/pairing.json`,
+          memory_file: `${workspace.root}/memory.json`,
+          history_limit: 100
+        },
+        embedding: { provider: "local" },
+        deals: DealsConfigSchema.parse({
+          enabled: true,
+          ...input.deals ?? {}
+        }),
+        webui: {
+          enabled: input.webui?.enabled ?? false,
+          port: 7777,
+          host: "127.0.0.1",
+          cors_origins: ["http://localhost:5173", "http://localhost:7777"],
+          log_requests: false
+        },
+        logging: { level: "info", pretty: true },
+        dev: { hot_reload: false },
+        tool_rag: {
+          enabled: true,
+          top_k: 25,
+          always_include: [
+            "telegram_send_message",
+            "telegram_reply_message",
+            "telegram_send_photo",
+            "telegram_send_document",
+            "journal_*",
+            "workspace_*",
+            "web_*"
+          ],
+          skip_unlimited_providers: false
+        },
+        mcp: { servers: {} },
+        plugins: {},
+        ...input.cocoon ? { cocoon: input.cocoon } : {},
+        ...input.tonapi_key ? { tonapi_key: input.tonapi_key } : {},
+        ...input.tavily_api_key ? { tavily_api_key: input.tavily_api_key } : {}
+      };
+      ConfigSchema.parse(config);
+      const configPath = workspace.configPath;
+      writeFileSync2(configPath, YAML.stringify(config), { encoding: "utf-8", mode: 384 });
+      log2.info(`Configuration saved: ${configPath}`);
+      return c.json({ success: true, data: { path: configPath } });
+    } catch (err) {
+      return c.json(
+        { success: false, error: err instanceof Error ? err.message : String(err) },
+        400
+      );
+    }
+  });
+  return app;
+}
+
+// src/webui/setup-server.ts
+import { randomBytes as randomBytes2 } from "crypto";
+import { readFileSync as readYaml, writeFileSync as writeFileSync3 } from "fs";
+import YAML2 from "yaml";
+var log3 = createLogger("Setup");
+function findWebDist() {
+  const candidates = [resolve("dist/web"), resolve("web")];
+  const __dirname = dirname2(fileURLToPath(import.meta.url));
+  candidates.push(resolve(__dirname, "web"), resolve(__dirname, "../dist/web"));
+  for (const candidate of candidates) {
+    if (existsSync3(join3(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) {
+      log3.info(`Open this URL in your browser: ${url}`);
+    }
+  });
+}
+var SetupServer = class {
+  constructor(port = 7777) {
+    this.port = port;
+    this.app = new Hono2();
+    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 = randomBytes2(32).toString("hex");
+        const configPath = join3(TELETON_ROOT, "config.yaml");
+        const raw = readYaml(configPath, "utf-8");
+        const config = YAML2.parse(raw);
+        config.webui = { ...config.webui || {}, enabled: true, auth_token: token };
+        writeFileSync3(configPath, YAML2.stringify(config), { encoding: "utf-8", mode: 384 });
+        log3.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) => {
+      log3.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 = readFileSync2(join3(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(join3(webDist, c.req.path));
+      const rel = relative(webDist, filePath);
+      if (rel.startsWith("..") || resolve(filePath) !== filePath) {
+        return c.html(indexHtml);
+      }
+      try {
+        const content = readFileSync2(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`;
+            log3.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(() => {
+          log3.info("Setup server stopped");
+          resolve2();
+        });
+      });
+    }
+  }
+};
+export {
+  SetupServer
+};