dsclaw 0.1.0

package/dist/cli/index.js

@@ -0,0 +1,1901 @@
+#!/usr/bin/env node
+
+// src/cli/index.ts
+import { Command } from "commander";
+
+// src/cli/init.ts
+import inquirer from "inquirer";
+
+// src/gateway/config.ts
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+import { z } from "zod";
+
+// src/shared/logger.ts
+import pino from "pino";
+
+// src/shared/tracer.ts
+import { AsyncLocalStorage } from "async_hooks";
+import { nanoid } from "nanoid";
+var storage = new AsyncLocalStorage();
+function runWithTrace(ctx, fn) {
+  const traceId = ctx.traceId ?? nanoid(12);
+  return storage.run({ traceId, ...ctx }, fn);
+}
+function getTraceContext() {
+  return storage.getStore() ?? { traceId: nanoid(12) };
+}
+function getTraceId() {
+  return getTraceContext().traceId;
+}
+
+// src/shared/logger.ts
+var rootLogger = pino({
+  level: process.env["LOG_LEVEL"] ?? "info",
+  transport: process.env["NODE_ENV"] !== "production" ? { target: "pino-pretty", options: { colorize: true } } : void 0,
+  mixin() {
+    const ctx = getTraceContext();
+    return {
+      traceId: ctx.traceId,
+      ...ctx.userId ? { userId: ctx.userId } : {},
+      ...ctx.channelId ? { channelId: ctx.channelId } : {},
+      ...ctx.agentId ? { agentId: ctx.agentId } : {}
+    };
+  }
+});
+function createLogger(module) {
+  return rootLogger.child({ module });
+}
+
+// src/gateway/config.ts
+var log = createLogger("config");
+var CONFIG_DIR = join(homedir(), ".dropclaw");
+var CONFIG_PATH = join(CONFIG_DIR, "config.json");
+var ConfigSchema = z.object({
+  port: z.number().default(3e3),
+  telegramBotToken: z.string().optional()
+});
+var DEFAULT_CONFIG = { port: 3e3 };
+function ensureConfigDir() {
+  if (!existsSync(CONFIG_DIR)) {
+    mkdirSync(CONFIG_DIR, { recursive: true, mode: 448 });
+  }
+}
+function loadConfig(path) {
+  const configPath = path ?? CONFIG_PATH;
+  if (!existsSync(configPath)) {
+    log.info("No config file found \u2014 using defaults (web chat on port 3000)");
+    return DEFAULT_CONFIG;
+  }
+  const raw = readFileSync(configPath, "utf-8");
+  const parsed = JSON.parse(raw);
+  const result = ConfigSchema.safeParse(parsed);
+  if (!result.success) {
+    log.warn("Config validation failed \u2014 using defaults");
+    return DEFAULT_CONFIG;
+  }
+  log.info("Configuration loaded");
+  return result.data;
+}
+function saveConfig(config) {
+  ensureConfigDir();
+  writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2), { mode: 384 });
+  log.info({ path: CONFIG_PATH }, "Configuration saved");
+}
+function configExists() {
+  return existsSync(CONFIG_PATH);
+}
+
+// src/cli/init.ts
+async function initCommand() {
+  console.log("\n  DropClaw Setup (optional)\n");
+  console.log("  Web chat works out of the box \u2014 this is for extra settings.\n");
+  if (configExists()) {
+    const { overwrite } = await inquirer.prompt([
+      {
+        type: "confirm",
+        name: "overwrite",
+        message: `Config already exists at ${CONFIG_PATH}. Overwrite?`,
+        default: false
+      }
+    ]);
+    if (!overwrite) {
+      console.log("  Cancelled.");
+      return;
+    }
+  }
+  const { port } = await inquirer.prompt({
+    type: "number",
+    name: "port",
+    message: "Web chat port (default 3000):",
+    default: 3e3
+  });
+  const { addTelegram } = await inquirer.prompt({
+    type: "confirm",
+    name: "addTelegram",
+    message: "Add Telegram bot?",
+    default: false
+  });
+  const config = { port };
+  if (addTelegram) {
+    const { botToken } = await inquirer.prompt({
+      type: "password",
+      name: "botToken",
+      message: "Telegram Bot Token (from @BotFather):",
+      mask: "*",
+      validate: (v) => v.includes(":") ? true : "Token format: 123456:ABC-DEF..."
+    });
+    config.telegramBotToken = botToken;
+  }
+  saveConfig(config);
+  console.log(`
+  Config saved to ${CONFIG_PATH}`);
+  console.log("  Run 'dropclaw start' to launch.\n");
+}
+
+// src/gateway/user-session.ts
+import {
+  randomBytes,
+  createCipheriv,
+  createDecipheriv,
+  createHash
+} from "crypto";
+import {
+  readFileSync as readFileSync2,
+  writeFileSync as writeFileSync2,
+  mkdirSync as mkdirSync2,
+  existsSync as existsSync2,
+  unlinkSync
+} from "fs";
+import { join as join2 } from "path";
+import { hostname, userInfo } from "os";
+var log2 = createLogger("user-session");
+var ALG = "aes-256-gcm";
+var IV_LEN = 12;
+var TAG_LEN = 16;
+var KEY_SEED = "dropclaw-v1";
+var SESSIONS_DIR = join2(CONFIG_DIR, "sessions");
+function deriveKey() {
+  let user = "";
+  try {
+    user = userInfo().username;
+  } catch {
+    user = process.env["USER"] ?? process.env["USERNAME"] ?? "default";
+  }
+  return createHash("sha256").update(`${KEY_SEED}:${hostname()}:${user}`).digest();
+}
+function encrypt(data) {
+  const key = deriveKey();
+  const iv = randomBytes(IV_LEN);
+  const cipher = createCipheriv(ALG, key, iv, { authTagLength: TAG_LEN });
+  const ct = Buffer.concat([cipher.update(data, "utf8"), cipher.final()]);
+  const tag = cipher.getAuthTag();
+  return Buffer.concat([iv, tag, ct]).toString("base64");
+}
+function decrypt(encoded) {
+  try {
+    const key = deriveKey();
+    const buf = Buffer.from(encoded, "base64");
+    if (buf.length < IV_LEN + TAG_LEN + 1) return null;
+    const iv = buf.subarray(0, IV_LEN);
+    const tag = buf.subarray(IV_LEN, IV_LEN + TAG_LEN);
+    const ct = buf.subarray(IV_LEN + TAG_LEN);
+    const decipher = createDecipheriv(ALG, key, iv, { authTagLength: TAG_LEN });
+    decipher.setAuthTag(tag);
+    return Buffer.concat([decipher.update(ct), decipher.final()]).toString(
+      "utf8"
+    );
+  } catch {
+    return null;
+  }
+}
+function ensureSessionsDir() {
+  if (!existsSync2(SESSIONS_DIR)) {
+    mkdirSync2(SESSIONS_DIR, { recursive: true, mode: 448 });
+  }
+}
+function sessionPath(userId) {
+  const safe = userId.replace(/[^a-zA-Z0-9_-]/g, "_");
+  return join2(SESSIONS_DIR, `${safe}.enc`);
+}
+function loadSession(userId) {
+  const p = sessionPath(userId);
+  if (!existsSync2(p)) {
+    return { state: "new" };
+  }
+  try {
+    const encrypted = readFileSync2(p, "utf-8").trim();
+    const json = decrypt(encrypted);
+    if (!json) {
+      log2.warn({ userId }, "Failed to decrypt session \u2014 starting fresh");
+      return { state: "new" };
+    }
+    return JSON.parse(json);
+  } catch {
+    return { state: "new" };
+  }
+}
+function saveSession(userId, session) {
+  ensureSessionsDir();
+  const json = JSON.stringify(session);
+  const encrypted = encrypt(json);
+  writeFileSync2(sessionPath(userId), encrypted, { mode: 384 });
+  log2.debug({ userId, state: session.state }, "Session saved");
+}
+function isOnboarding(state) {
+  return state !== "ready";
+}
+
+// src/dsers/auth.ts
+import { readFileSync as readFileSync3, writeFileSync as writeFileSync3, mkdirSync as mkdirSync3, existsSync as existsSync3, chmodSync } from "fs";
+import { dirname } from "path";
+
+// src/shared/errors.ts
+var ErrorCategory = {
+  RETRYABLE: "RETRYABLE",
+  NEEDS_HUMAN: "NEEDS_HUMAN",
+  NEEDS_DATA: "NEEDS_DATA",
+  FATAL: "FATAL",
+  DEGRADED: "DEGRADED"
+};
+var DropClawError = class extends Error {
+  category;
+  code;
+  retryable;
+  details;
+  constructor(opts) {
+    super(opts.message);
+    this.name = "DropClawError";
+    this.category = opts.category;
+    this.code = opts.code;
+    this.retryable = opts.retryable;
+    this.details = opts.details;
+    if (opts.cause) this.cause = opts.cause;
+  }
+  toJSON() {
+    return {
+      category: this.category,
+      code: this.code,
+      message: this.message,
+      retryable: this.retryable,
+      details: this.details
+    };
+  }
+};
+function classifyHttpError(status, body) {
+  if (status === 429) return ErrorCategory.RETRYABLE;
+  if (status >= 500) return ErrorCategory.RETRYABLE;
+  if (status === 401 || status === 403) return ErrorCategory.NEEDS_HUMAN;
+  if (status === 404 || status === 422) return ErrorCategory.NEEDS_DATA;
+  if (status === 400) return ErrorCategory.NEEDS_DATA;
+  return ErrorCategory.FATAL;
+}
+
+// src/dsers/auth.ts
+var log3 = createLogger("dsers:auth");
+var SESSION_TTL = 3600 * 6 * 1e3;
+var DSersAuth = class {
+  config;
+  sessionId = null;
+  state = null;
+  fetchedAt = 0;
+  constructor(config) {
+    this.config = config;
+    if (config.sessionId) {
+      this.sessionId = config.sessionId;
+      this.state = config.sessionState ?? "";
+      this.fetchedAt = Date.now();
+    }
+  }
+  async getSession() {
+    if (this.sessionId && Date.now() - this.fetchedAt < SESSION_TTL) {
+      return [this.sessionId, this.state ?? ""];
+    }
+    const cached = this.readCache();
+    if (cached) {
+      [this.sessionId, this.state, this.fetchedAt] = cached;
+      return [this.sessionId, this.state];
+    }
+    return this.login();
+  }
+  async login() {
+    if (!this.config.email || !this.config.password) {
+      throw new DropClawError({
+        category: ErrorCategory.NEEDS_HUMAN,
+        code: "DSERS_NO_CREDENTIALS",
+        message: "DSers email and password not configured.",
+        retryable: false
+      });
+    }
+    log3.info("Authenticating with DSers...");
+    const resp = await fetch(
+      `${this.config.baseUrl}/account-user-bff/v1/users/login`,
+      {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          email: this.config.email,
+          password: this.config.password
+        })
+      }
+    );
+    if (!resp.ok) {
+      const body = await resp.text();
+      throw new DropClawError({
+        category: resp.status === 401 || resp.status === 403 ? ErrorCategory.NEEDS_HUMAN : ErrorCategory.RETRYABLE,
+        code: `DSERS_LOGIN_${resp.status}`,
+        message: `DSers login failed (HTTP ${resp.status}): ${body.slice(0, 200)}`,
+        retryable: resp.status >= 500
+      });
+    }
+    const data = await resp.json();
+    const inner = data["data"];
+    if (!inner?.["sessionId"]) {
+      throw new DropClawError({
+        category: ErrorCategory.NEEDS_HUMAN,
+        code: "DSERS_LOGIN_NO_SESSION",
+        message: "DSers login succeeded but no session returned.",
+        retryable: false,
+        details: { response: data }
+      });
+    }
+    this.sessionId = inner["sessionId"];
+    this.state = inner["state"] ?? "";
+    this.fetchedAt = Date.now();
+    this.writeCache();
+    log3.info("DSers authentication successful");
+    return [this.sessionId, this.state];
+  }
+  invalidate() {
+    this.sessionId = null;
+    this.state = null;
+    this.fetchedAt = 0;
+    log3.debug("Session invalidated");
+  }
+  readCache() {
+    try {
+      const p = this.config.sessionFile;
+      if (!existsSync3(p)) return null;
+      const obj = JSON.parse(readFileSync3(p, "utf-8"));
+      if (Date.now() - obj.ts > SESSION_TTL) return null;
+      return [obj.session_id, obj.state ?? "", obj.ts];
+    } catch {
+      return null;
+    }
+  }
+  writeCache() {
+    if (this.config.sessionId) return;
+    try {
+      const p = this.config.sessionFile;
+      mkdirSync3(dirname(p), { recursive: true });
+      const payload = {
+        session_id: this.sessionId,
+        state: this.state ?? "",
+        ts: this.fetchedAt
+      };
+      writeFileSync3(p, JSON.stringify(payload), { encoding: "utf-8", mode: 384 });
+      try {
+        chmodSync(p, 384);
+      } catch {
+      }
+    } catch {
+      log3.warn("Failed to write session cache");
+    }
+  }
+};
+
+// src/shared/utils.ts
+import { createHash as createHash2 } from "crypto";
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function parseRetryAfter(value) {
+  if (!value) return null;
+  const seconds = Number(value);
+  if (!Number.isNaN(seconds)) return seconds * 1e3;
+  const date = Date.parse(value);
+  if (!Number.isNaN(date)) return Math.max(0, date - Date.now());
+  return null;
+}
+
+// src/resilience/rate-limiter.ts
+import pLimit from "p-limit";
+var log4 = createLogger("rate-limiter");
+var DEFAULT_OUTBOUND_LIMITS = {
+  dsers: 20,
+  llm: 5,
+  mem0: 10
+};
+var outboundLimiters = /* @__PURE__ */ new Map();
+function getOutboundLimiter(service, customLimits) {
+  if (!outboundLimiters.has(service)) {
+    const limits = { ...DEFAULT_OUTBOUND_LIMITS, ...customLimits };
+    const limiter = pLimit(limits[service]);
+    outboundLimiters.set(service, limiter);
+    log4.info({ service, concurrency: limits[service] }, "Outbound limiter created");
+  }
+  return outboundLimiters.get(service);
+}
+var userQueues = /* @__PURE__ */ new Map();
+var debounceTimers = /* @__PURE__ */ new Map();
+async function acquireUserLock(userId) {
+  while (userQueues.has(userId)) {
+    await userQueues.get(userId);
+  }
+  let release;
+  const lock = new Promise((resolve) => {
+    release = () => {
+      userQueues.delete(userId);
+      resolve();
+    };
+  });
+  userQueues.set(userId, lock);
+  return release;
+}
+function debounceUser(userId, delayMs = 500) {
+  return new Promise((resolve) => {
+    const existing = debounceTimers.get(userId);
+    if (existing) clearTimeout(existing);
+    debounceTimers.set(
+      userId,
+      setTimeout(() => {
+        debounceTimers.delete(userId);
+        resolve();
+      }, delayMs)
+    );
+  });
+}
+var inboundWindows = /* @__PURE__ */ new Map();
+function checkInboundLimit(sourceId, maxRequests = 30, windowMs = 6e4) {
+  const now = Date.now();
+  const entry = inboundWindows.get(sourceId) ?? { timestamps: [] };
+  entry.timestamps = entry.timestamps.filter((t) => now - t < windowMs);
+  if (entry.timestamps.length >= maxRequests) {
+    log4.warn({ sourceId, count: entry.timestamps.length }, "Inbound rate limit hit");
+    return false;
+  }
+  entry.timestamps.push(now);
+  inboundWindows.set(sourceId, entry);
+  return true;
+}
+
+// src/dsers/client.ts
+var log5 = createLogger("dsers:client");
+var RETRYABLE_REASONS = /* @__PURE__ */ new Set([
+  "TOKEN_NOT_FOUND",
+  "TOKEN_EXPIRED",
+  "UNAUTHORIZED",
+  "INVALID_TOKEN"
+]);
+var MAX_RETRIES = 2;
+var DSersClient = class {
+  config;
+  auth;
+  limiter;
+  constructor(config) {
+    this.config = config;
+    this.auth = new DSersAuth(config);
+    this.limiter = getOutboundLimiter("dsers");
+  }
+  async request(method, path, opts, attempt = 0) {
+    return this.limiter(async () => {
+      const [sessionId, state] = await this.auth.getSession();
+      const traceId = getTraceId();
+      const url = new URL(`${this.config.baseUrl}${path}`);
+      if (opts?.params) {
+        for (const [k, v] of Object.entries(opts.params)) {
+          if (v != null) url.searchParams.set(k, String(v));
+        }
+      }
+      const headers = {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${sessionId}`,
+        Cookie: `session_id=${sessionId}; state=${state}`,
+        "X-Trace-Id": traceId
+      };
+      log5.debug({ method, path, traceId, attempt }, "DSers API request");
+      const resp = await fetch(url.toString(), {
+        method,
+        headers,
+        body: opts?.json ? JSON.stringify(opts.json) : void 0
+      });
+      const bodyText = await resp.text();
+      if (resp.status === 400 && attempt === 0) {
+        try {
+          const body = JSON.parse(bodyText);
+          if (RETRYABLE_REASONS.has(body["reason"])) {
+            log5.info({ reason: body["reason"] }, "Session expired, re-authenticating");
+            this.auth.invalidate();
+            return this.request(method, path, opts, 1);
+          }
+        } catch {
+        }
+      }
+      if (resp.status === 429) {
+        const retryAfterMs = parseRetryAfter(resp.headers.get("Retry-After")) ?? 5e3;
+        if (attempt < MAX_RETRIES) {
+          log5.warn({ retryAfterMs, attempt }, "Rate limited by DSers");
+          await sleep(retryAfterMs);
+          return this.request(method, path, opts, attempt + 1);
+        }
+      }
+      if (resp.status >= 500 && attempt < MAX_RETRIES) {
+        const delay = Math.min(1e3 * Math.pow(2, attempt) + Math.random() * 500, 15e3);
+        log5.warn({ status: resp.status, attempt }, "DSers server error, retrying");
+        await sleep(delay);
+        return this.request(method, path, opts, attempt + 1);
+      }
+      if (resp.status >= 400) {
+        const category = classifyHttpError(resp.status, bodyText);
+        throw new DropClawError({
+          category,
+          code: `DSERS_API_${resp.status}`,
+          message: `DSers API ${method} ${path} returned ${resp.status}: ${bodyText.slice(0, 300)}`,
+          retryable: category === ErrorCategory.RETRYABLE,
+          details: { status: resp.status, path, method }
+        });
+      }
+      return JSON.parse(bodyText);
+    });
+  }
+  async get(path, params) {
+    return this.request("GET", path, { params });
+  }
+  async post(path, json, params) {
+    return this.request("POST", path, { json, params });
+  }
+  async put(path, json, params) {
+    return this.request("PUT", path, { json, params });
+  }
+  async del(path, params) {
+    return this.request("DELETE", path, { params });
+  }
+};
+
+// src/dsers/config.ts
+import { join as join3 } from "path";
+var PROD_URL = "https://bff-api-gw.dsers.com";
+function createDSersConfig(email, password, baseUrl) {
+  const safeEmail = email.replace(/[^a-zA-Z0-9_@.-]/g, "_");
+  return {
+    baseUrl: baseUrl ?? PROD_URL,
+    email,
+    password,
+    sessionFile: join3(CONFIG_DIR, `session-${safeEmail}.json`)
+  };
+}
+
+// src/agents/core-agent.ts
+import { generateText, streamText, tool as aiTool, stepCountIs } from "ai";
+import { createOpenAI } from "@ai-sdk/openai";
+import { createAnthropic } from "@ai-sdk/anthropic";
+import { createGoogleGenerativeAI } from "@ai-sdk/google";
+import { z as z2 } from "zod";
+
+// src/shared/audit.ts
+import { appendFileSync, mkdirSync as mkdirSync4, existsSync as existsSync4 } from "fs";
+import { join as join4 } from "path";
+var AUDIT_DIR = join4(CONFIG_DIR, "audit");
+function ensureAuditDir() {
+  if (!existsSync4(AUDIT_DIR)) {
+    mkdirSync4(AUDIT_DIR, { recursive: true });
+  }
+}
+function writeAuditLog(entry) {
+  ensureAuditDir();
+  const full = {
+    ...entry,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    traceId: getTraceId()
+  };
+  const date = full.timestamp.slice(0, 10);
+  const file = join4(AUDIT_DIR, `${date}.jsonl`);
+  try {
+    appendFileSync(file, JSON.stringify(full) + "\n");
+  } catch {
+  }
+}
+
+// src/dsers/product.ts
+async function getImportList(client, params) {
+  const filtered = params ? Object.fromEntries(Object.entries(params).filter(([, v]) => v != null)) : {};
+  return client.get("/dsers-product-bff/import-list", filtered);
+}
+async function importByProductId(client, body) {
+  return client.post("/dsers-product-bff/import-list/product-id", body);
+}
+async function pushToStore(client, payload) {
+  return client.post("/dsers-product-bff/import-list/push", {
+    data: payload
+  });
+}
+async function getMyProducts(client, params) {
+  return client.get("/dsers-product-bff/my-product", params);
+}
+
+// src/dsers/account.ts
+async function listStores(client) {
+  return client.post("/account-user-bff/v1/stores/user/list");
+}
+async function getUserInfo(client) {
+  return client.get("/account-user-bff/v1/users/info");
+}
+
+// src/dsers/settings.ts
+async function getGlobalSettings(client) {
+  return client.get("/infra-setting-bff/setting/list");
+}
+async function getPricingRules(client, storeId) {
+  return client.get("/dsers-settings-bff/product/pricing-rule", { storeId });
+}
+async function getCurrentPlan(client) {
+  return client.get("/dsers-plan-bff/plan");
+}
+
+// src/agents/core-agent.ts
+var log6 = createLogger("agent:core");
+function buildModel(llm) {
+  switch (llm.provider) {
+    case "openai":
+      return createOpenAI({ apiKey: llm.apiKey })(llm.model);
+    case "anthropic":
+      return createAnthropic({ apiKey: llm.apiKey })(llm.model);
+    case "google":
+      return createGoogleGenerativeAI({ apiKey: llm.apiKey })(llm.model);
+    default:
+      return createOpenAI({ apiKey: llm.apiKey })(llm.model);
+  }
+}
+function getDefaultModel(provider) {
+  switch (provider) {
+    case "openai":
+      return "gpt-4o";
+    case "anthropic":
+      return "claude-sonnet-4-20250514";
+    case "google":
+      return "gemini-2.0-flash";
+    default:
+      return "gpt-4o";
+  }
+}
+var SYSTEM_PROMPT = `You are DropClaw, a friendly AI assistant that manages dropshipping stores through DSers.
+Your user has ZERO technical background \u2014 they are a small business owner or solo entrepreneur.
+
+COMMUNICATION RULES:
+- Always respond in the SAME LANGUAGE the user writes in
+- Use simple, warm, conversational language \u2014 no jargon
+- When showing data (products, stores, orders), format it clearly with bullet points or numbered lists
+- Always confirm before executing write operations (push, delete, update pricing)
+- If something fails, explain what happened in plain language and suggest what to do next
+- Proactively offer helpful next steps after completing a task
+
+YOUR CAPABILITIES:
+- View connected stores and store details
+- Search and browse the import list (products from suppliers)
+- Import new products from AliExpress, Temu, or 1688
+- Push products to connected stores (Shopify, WooCommerce, etc.)
+- View products already in stores ("My Products")
+- Check and update pricing rules
+- View account plan and billing info
+- Check global settings and shipping configuration
+
+GUIDELINES:
+- When users describe products vaguely, search first and present options
+- For bulk operations, show a preview and ask for confirmation
+- Use simple summaries: "You have 15 products waiting to be pushed" instead of raw JSON
+- If the user seems confused, offer guided suggestions like "Would you like me to show your stores first?"`;
+var DropClawCoreAgent = class {
+  id = "dropclaw-core";
+  name = "DropClaw Core Agent";
+  dsers;
+  memory;
+  llm;
+  customTools = /* @__PURE__ */ new Map();
+  constructor(dsers, memory, llm) {
+    this.dsers = dsers;
+    this.memory = memory;
+    this.llm = llm;
+  }
+  registerTool(t) {
+    this.customTools.set(t.name, t);
+  }
+  removeTool(name) {
+    this.customTools.delete(name);
+  }
+  getTools() {
+    return Array.from(this.customTools.values());
+  }
+  async process(message, context) {
+    const model = buildModel(this.llm);
+    const memories = await this.memory.search(message, { userId: context.userId, limit: 5 }).catch(() => []);
+    const memoryContext = memories.length > 0 ? `
+
+Relevant memories:
+${memories.map((m) => `- ${m.content}`).join("\n")}` : "";
+    const messages = [
+      { role: "system", content: SYSTEM_PROMPT + memoryContext },
+      ...context.history.map(
+        (h) => ({
+          role: h.role,
+          content: h.content
+        })
+      ),
+      { role: "user", content: message }
+    ];
+    const tools = this.buildAITools(context);
+    log6.info(
+      { userId: context.userId, messageLen: message.length, toolCount: Object.keys(tools).length },
+      "Processing message"
+    );
+    try {
+      const result = await generateText({
+        model,
+        messages,
+        tools,
+        stopWhen: stepCountIs(5)
+      });
+      const toolCalls = result.steps?.flatMap(
+        (step) => step.toolCalls?.map((tc) => ({
+          tool: tc.toolName,
+          params: "input" in tc ? tc.input : {},
+          result: {
+            success: true,
+            data: step.toolResults?.find(
+              (tr) => tr.toolCallId === tc.toolCallId
+            )?.output
+          }
+        }))
+      ).filter(Boolean) ?? [];
+      if (result.text.length > 20) {
+        this.memory.add(`User: "${message.slice(0, 100)}" -> ${toolCalls.length} tools used`, {
+          userId: context.userId,
+          category: "pattern",
+          agentId: this.id
+        }).catch(() => {
+        });
+      }
+      return {
+        text: result.text,
+        toolCalls
+      };
+    } catch (error) {
+      log6.error({ error, userId: context.userId }, "Agent processing failed");
+      writeAuditLog({
+        userId: context.userId,
+        agentId: this.id,
+        action: "process_message",
+        target: "llm",
+        result: "failed",
+        error: error instanceof Error ? error.message : String(error)
+      });
+      throw error;
+    }
+  }
+  /**
+   * Streaming version of process() — yields text chunks for real-time display.
+   * Returns textStream (async iterable) + response promise (resolves after completion).
+   */
+  processStream(message, context) {
+    const model = buildModel(this.llm);
+    const memories = this.memory.search(message, { userId: context.userId, limit: 5 }).catch(() => []);
+    const tools = this.buildAITools(context);
+    const self = this;
+    const streamPromise = memories.then((mems) => {
+      const memoryContext = mems.length > 0 ? `
+
+Relevant memories:
+${mems.map((m) => `- ${m.content}`).join("\n")}` : "";
+      const messages = [
+        { role: "system", content: SYSTEM_PROMPT + memoryContext },
+        ...context.history.map(
+          (h) => ({
+            role: h.role,
+            content: h.content
+          })
+        ),
+        { role: "user", content: message }
+      ];
+      log6.info(
+        { userId: context.userId, messageLen: message.length, streaming: true },
+        "Processing message (stream)"
+      );
+      return streamText({
+        model,
+        messages,
+        tools,
+        stopWhen: stepCountIs(5)
+      });
+    });
+    const textStream = {
+      [Symbol.asyncIterator]() {
+        let innerIterator = null;
+        return {
+          async next() {
+            if (!innerIterator) {
+              const result = await streamPromise;
+              innerIterator = result.textStream[Symbol.asyncIterator]();
+            }
+            return innerIterator.next();
+          }
+        };
+      }
+    };
+    const response = streamPromise.then(async (result) => {
+      const text = await result.text;
+      const steps = await result.steps;
+      const toolCalls = steps?.flatMap(
+        (step) => step.toolCalls?.map((tc) => ({
+          tool: tc.toolName,
+          params: "input" in tc ? tc.input : {},
+          result: {
+            success: true,
+            data: step.toolResults?.find(
+              (tr) => tr.toolCallId === tc.toolCallId
+            )?.output
+          }
+        }))
+      ).filter(Boolean) ?? [];
+      if (text.length > 20) {
+        self.memory.add(`User: "${message.slice(0, 100)}" -> ${toolCalls.length} tools used`, {
+          userId: context.userId,
+          category: "pattern",
+          agentId: self.id
+        }).catch(() => {
+        });
+      }
+      return {
+        text,
+        toolCalls
+      };
+    });
+    return { textStream, response };
+  }
+  buildAITools(context) {
+    const dsers = this.dsers;
+    const audit = (action, target, params, result = "pending") => writeAuditLog({ userId: context.userId, agentId: this.id, action, target, params, result });
+    return {
+      listStores: aiTool({
+        description: "List all connected stores (Shopify, WooCommerce, etc.) with their IDs and status.",
+        inputSchema: z2.object({}),
+        execute: async () => {
+          audit("listStores", "dsers:account");
+          const result = await listStores(dsers);
+          audit("listStores", "dsers:account", void 0, "success");
+          return result;
+        }
+      }),
+      getUserInfo: aiTool({
+        description: "Get the user's DSers account info (email, name, plan).",
+        inputSchema: z2.object({}),
+        execute: async () => {
+          audit("getUserInfo", "dsers:account");
+          const result = await getUserInfo(dsers);
+          audit("getUserInfo", "dsers:account", void 0, "success");
+          return result;
+        }
+      }),
+      searchImportList: aiTool({
+        description: "Search the import list \u2014 products imported from suppliers but not yet pushed to stores.",
+        inputSchema: z2.object({
+          page: z2.number().optional().describe("Page number (default 1)"),
+          pageSize: z2.number().optional().describe("Items per page (default 20)"),
+          keyword: z2.string().optional().describe("Search keyword")
+        }),
+        execute: async (input) => {
+          audit("searchImportList", "dsers:product", input);
+          const result = await getImportList(dsers, input);
+          audit("searchImportList", "dsers:product", void 0, "success");
+          return result;
+        }
+      }),
+      importProduct: aiTool({
+        description: "Import a product from a supplier (AliExpress/Temu/1688) into the import list. Needs the supplier product ID and platform (1=AliExpress, 2=Temu, 3=1688).",
+        inputSchema: z2.object({
+          supplyProductId: z2.string().describe("Supplier product ID"),
+          supplyAppId: z2.number().describe("1=AliExpress, 2=Temu, 3=1688"),
+          country: z2.string().default("US").describe("Target country")
+        }),
+        execute: async (input) => {
+          audit("importProduct", "dsers:product", input);
+          const result = await importByProductId(dsers, input);
+          audit("importProduct", "dsers:product", void 0, "success");
+          return result;
+        }
+      }),
+      pushToStore: aiTool({
+        description: "Push products from import list to a connected store. ALWAYS confirm with user first.",
+        inputSchema: z2.object({
+          importListIds: z2.array(z2.string()).describe("Import list item IDs"),
+          storeIds: z2.array(z2.string()).describe("Target store IDs"),
+          pushStatus: z2.enum(["ACTIVE", "DRAFT"]).default("DRAFT")
+        }),
+        execute: async (input) => {
+          audit("pushToStore", "dsers:product", input);
+          const result = await pushToStore(dsers, input);
+          audit("pushToStore", "dsers:product", void 0, "success");
+          return result;
+        }
+      }),
+      getMyProducts: aiTool({
+        description: "Get products already pushed to stores. Check status, inventory, or find products to update.",
+        inputSchema: z2.object({
+          page: z2.number().optional(),
+          pageSize: z2.number().optional(),
+          keyword: z2.string().optional(),
+          storeId: z2.string().optional()
+        }),
+        execute: async (input) => {
+          audit("getMyProducts", "dsers:product", input);
+          const result = await getMyProducts(dsers, input);
+          audit("getMyProducts", "dsers:product", void 0, "success");
+          return result;
+        }
+      }),
+      getPricingRules: aiTool({
+        description: "Get pricing rules for a store (markup, rounding, etc.).",
+        inputSchema: z2.object({
+          storeId: z2.string().describe("Store ID to get pricing rules for")
+        }),
+        execute: async (input) => {
+          audit("getPricingRules", "dsers:settings", input);
+          const result = await getPricingRules(dsers, input.storeId);
+          audit("getPricingRules", "dsers:settings", void 0, "success");
+          return result;
+        }
+      }),
+      getGlobalSettings: aiTool({
+        description: "Get global DSers settings (notifications, sync preferences, etc.).",
+        inputSchema: z2.object({}),
+        execute: async () => {
+          audit("getGlobalSettings", "dsers:settings");
+          const result = await getGlobalSettings(dsers);
+          audit("getGlobalSettings", "dsers:settings", void 0, "success");
+          return result;
+        }
+      }),
+      getCurrentPlan: aiTool({
+        description: "Check the user's current DSers subscription plan and limits.",
+        inputSchema: z2.object({}),
+        execute: async () => {
+          audit("getCurrentPlan", "dsers:settings");
+          const result = await getCurrentPlan(dsers);
+          audit("getCurrentPlan", "dsers:settings", void 0, "success");
+          return result;
+        }
+      })
+    };
+  }
+};
+
+// src/web/server.ts
+import { createServer } from "http";
+import { readFileSync as readFileSync4, existsSync as existsSync5 } from "fs";
+import { join as join5, dirname as dirname2 } from "path";
+import { fileURLToPath } from "url";
+import { WebSocketServer, WebSocket } from "ws";
+import { v4 as uuid } from "uuid";
+var log7 = createLogger("channel:web");
+function findChatHtml() {
+  const thisDir = dirname2(fileURLToPath(import.meta.url));
+  const candidates = [
+    join5(thisDir, "chat.html"),
+    join5(thisDir, "web", "chat.html"),
+    join5(thisDir, "..", "web", "chat.html"),
+    join5(thisDir, "..", "src", "web", "chat.html"),
+    join5(thisDir, "..", "..", "src", "web", "chat.html")
+  ];
+  for (const p of candidates) {
+    if (existsSync5(p)) {
+      return readFileSync4(p, "utf-8");
+    }
+  }
+  throw new Error(
+    "chat.html not found. Looked in:\n" + candidates.join("\n")
+  );
+}
+var WebChatServer = class {
+  name = "web";
+  server = null;
+  wss = null;
+  handler = null;
+  connections = /* @__PURE__ */ new Map();
+  _connected = false;
+  port = 3e3;
+  get connected() {
+    return this._connected;
+  }
+  async connect(config) {
+    this.port = config["port"] ?? 3e3;
+    const chatHtml = findChatHtml();
+    this.server = createServer((req, res) => {
+      if (req.url === "/" || req.url === "/index.html") {
+        res.writeHead(200, {
+          "Content-Type": "text/html; charset=utf-8",
+          "Cache-Control": "no-cache"
+        });
+        res.end(chatHtml);
+        return;
+      }
+      if (req.url === "/health") {
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ ok: true, clients: this.connections.size }));
+        return;
+      }
+      res.writeHead(404);
+      res.end("Not Found");
+    });
+    this.wss = new WebSocketServer({ server: this.server, path: "/ws" });
+    this.wss.on("connection", (ws, req) => {
+      const url = new URL(req.url ?? "/", `http://localhost:${this.port}`);
+      let clientId = url.searchParams.get("userId") || uuid();
+      this.wsSend(ws, { type: "session", userId: clientId });
+      this.connections.set(clientId, ws);
+      log7.info({ userId: clientId }, "Web client connected");
+      ws.on("message", async (raw) => {
+        try {
+          const msg = JSON.parse(raw.toString());
+          if (msg["userId"]) clientId = msg["userId"];
+          this.connections.set(clientId, ws);
+          if (!this.handler) return;
+          const msgType = msg["type"];
+          if (msgType === "message" || msgType === "callback") {
+            const normalized = {
+              traceId: uuid(),
+              channelId: "web",
+              channelName: "Web Chat",
+              userId: clientId,
+              text: msgType === "callback" ? msg["data"] : msg["text"],
+              timestamp: /* @__PURE__ */ new Date(),
+              metadata: {
+                isCallback: msgType === "callback"
+              }
+            };
+            await this.handler(normalized);
+          }
+        } catch (error) {
+          log7.error({ error }, "WS message handler failed");
+        }
+      });
+      ws.on("close", () => {
+        this.connections.delete(clientId);
+        log7.debug({ userId: clientId }, "Web client disconnected");
+      });
+      ws.on("error", (err) => {
+        log7.warn({ error: err.message, userId: clientId }, "WS error");
+      });
+    });
+    return new Promise((resolve, reject) => {
+      this.server.listen(this.port, () => {
+        this._connected = true;
+        log7.info({ port: this.port }, "Web chat server started");
+        resolve();
+      });
+      this.server.on("error", reject);
+    });
+  }
+  async disconnect() {
+    for (const ws of this.connections.values()) {
+      ws.close();
+    }
+    this.connections.clear();
+    this.wss?.close();
+    await new Promise((resolve) => {
+      if (this.server) this.server.close(() => resolve());
+      else resolve();
+    });
+    this._connected = false;
+    log7.info("Web chat server stopped");
+  }
+  async reconnect() {
+    await this.disconnect();
+    await this.connect({ port: this.port });
+  }
+  onMessage(handler) {
+    this.handler = handler;
+  }
+  async send(targetUserId, message) {
+    if (message.card) {
+      await this.sendCard(targetUserId, message.card);
+      return;
+    }
+    if (message.text) {
+      this.wsSendTo(targetUserId, { type: "message", text: message.text });
+    }
+  }
+  async sendCard(targetUserId, card) {
+    this.wsSendTo(targetUserId, {
+      type: "card",
+      title: card.title,
+      summary: card.summary,
+      actions: card.actions
+    });
+  }
+  async deleteMessage() {
+  }
+  // ─── Streaming Methods ─────────────────────────────────────
+  sendStreamStart(userId) {
+    this.wsSendTo(userId, { type: "stream_start" });
+  }
+  sendStreamDelta(userId, delta) {
+    this.wsSendTo(userId, { type: "stream_delta", delta });
+  }
+  sendStreamEnd(userId) {
+    this.wsSendTo(userId, { type: "stream_end" });
+  }
+  // ─── Web-Specific Methods ──────────────────────────────────
+  sendTyping(userId, active) {
+    this.wsSendTo(userId, { type: "typing", active });
+  }
+  sendClearInput(userId) {
+    this.wsSendTo(userId, { type: "clear_input" });
+  }
+  sendSetInputType(userId, inputType) {
+    this.wsSendTo(userId, { type: "set_input_type", inputType });
+  }
+  // ─── Internal ──────────────────────────────────────────────
+  wsSendTo(userId, data) {
+    const ws = this.connections.get(userId);
+    if (ws && ws.readyState === WebSocket.OPEN) {
+      this.wsSend(ws, data);
+    }
+  }
+  wsSend(ws, data) {
+    ws.send(JSON.stringify(data));
+  }
+};
+
+// src/channels/telegram.ts
+import { Bot, InlineKeyboard } from "grammy";
+import { v4 as uuid2 } from "uuid";
+var log8 = createLogger("channel:telegram");
+var TelegramAdapter = class {
+  name = "telegram";
+  bot = null;
+  handler = null;
+  _connected = false;
+  botToken = "";
+  get connected() {
+    return this._connected;
+  }
+  async connect(config) {
+    this.botToken = config["botToken"];
+    if (!this.botToken) throw new Error("Telegram botToken is required");
+    this.bot = new Bot(this.botToken);
+    this.bot.on("message:text", async (ctx) => {
+      if (!this.handler) return;
+      const normalized = {
+        traceId: uuid2(),
+        channelId: "telegram",
+        channelName: "Telegram",
+        userId: String(ctx.from.id),
+        userName: ctx.from.username ?? [ctx.from.first_name, ctx.from.last_name].filter(Boolean).join(" "),
+        text: ctx.message.text,
+        timestamp: new Date(ctx.message.date * 1e3),
+        metadata: {
+          chatId: ctx.chat.id,
+          messageId: ctx.message.message_id
+        }
+      };
+      try {
+        await this.handler(normalized);
+      } catch (error) {
+        log8.error({ error, userId: normalized.userId }, "Message handler error");
+        await ctx.reply("Sorry, something went wrong. Please try again.");
+      }
+    });
+    this.bot.on("callback_query:data", async (ctx) => {
+      if (!this.handler) return;
+      await ctx.answerCallbackQuery();
+      const normalized = {
+        traceId: uuid2(),
+        channelId: "telegram",
+        channelName: "Telegram",
+        userId: String(ctx.from.id),
+        userName: ctx.from.username ?? ctx.from.first_name,
+        text: ctx.callbackQuery.data,
+        timestamp: /* @__PURE__ */ new Date(),
+        metadata: {
+          chatId: ctx.chat?.id,
+          isCallback: true
+        }
+      };
+      try {
+        await this.handler(normalized);
+      } catch (error) {
+        log8.error({ error }, "Callback handler error");
+      }
+    });
+    this.bot.catch((err) => {
+      log8.error({ error: err.message }, "Bot error \u2014 reconnecting...");
+      this._connected = false;
+      setTimeout(() => this.reconnect(), 5e3);
+    });
+    await this.bot.init();
+    log8.info({ botName: this.bot.botInfo.username }, "Telegram bot initialized");
+    this.bot.start({
+      onStart: () => {
+        this._connected = true;
+        log8.info("Telegram bot polling started");
+      }
+    });
+  }
+  async disconnect() {
+    this.bot?.stop();
+    this._connected = false;
+    log8.info("Telegram bot disconnected");
+  }
+  async reconnect() {
+    log8.info("Reconnecting Telegram bot...");
+    await this.disconnect();
+    await this.connect({ botToken: this.botToken });
+  }
+  onMessage(handler) {
+    this.handler = handler;
+  }
+  async send(targetUserId, message) {
+    if (!this.bot) throw new Error("Bot not connected");
+    if (message.card) {
+      await this.sendCard(targetUserId, message.card);
+      return;
+    }
+    if (message.text) {
+      await this.bot.api.sendMessage(targetUserId, message.text, {
+        parse_mode: "Markdown"
+      });
+    }
+  }
+  async sendCard(targetUserId, card) {
+    if (!this.bot) throw new Error("Bot not connected");
+    const keyboard = new InlineKeyboard();
+    for (const action of card.actions) {
+      keyboard.text(action.label, action.callbackData).row();
+    }
+    const text = `*${card.title}*
+
+${card.summary}`;
+    await this.bot.api.sendMessage(targetUserId, text, {
+      parse_mode: "Markdown",
+      reply_markup: keyboard
+    });
+  }
+  async deleteMessage(chatId, messageId) {
+    if (!this.bot) return;
+    try {
+      await this.bot.api.deleteMessage(chatId, messageId);
+    } catch (error) {
+      log8.warn({ chatId, messageId, error }, "Failed to delete message");
+    }
+  }
+};
+
+// src/memory/file-provider.ts
+import {
+  readFileSync as readFileSync5,
+  writeFileSync as writeFileSync4,
+  appendFileSync as appendFileSync2,
+  existsSync as existsSync6,
+  mkdirSync as mkdirSync5,
+  readdirSync
+} from "fs";
+import { join as join6 } from "path";
+import { randomUUID } from "crypto";
+var log9 = createLogger("memory:file");
+var MEMORY_DIR = join6(CONFIG_DIR, "memories");
+var FileMemoryProvider = class {
+  name = "file";
+  degraded = false;
+  constructor() {
+    if (!existsSync6(MEMORY_DIR)) {
+      mkdirSync5(MEMORY_DIR, { recursive: true });
+    }
+  }
+  async add(content, metadata) {
+    const id = randomUUID();
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const entry = {
+      id,
+      content,
+      metadata,
+      createdAt: now,
+      updatedAt: now
+    };
+    const file = this.userFile(metadata.userId);
+    appendFileSync2(file, JSON.stringify(entry) + "\n");
+    log9.debug({ id, userId: metadata.userId }, "Memory added");
+    return id;
+  }
+  async search(query, filters) {
+    const all = await this.getAll(filters);
+    const keywords = query.toLowerCase().split(/\s+/).filter((w) => w.length > 2);
+    if (keywords.length === 0) {
+      return all.slice(0, filters.limit ?? 10);
+    }
+    const scored = all.map((m) => {
+      const text = m.content.toLowerCase();
+      const matchCount = keywords.filter((k) => text.includes(k)).length;
+      return { memory: m, score: matchCount / keywords.length };
+    }).filter((s) => s.score > 0).sort((a, b) => b.score - a.score).slice(0, filters.limit ?? 10);
+    return scored.map((s) => ({ ...s.memory, score: s.score }));
+  }
+  async getAll(filters) {
+    const files = filters.userId ? [this.userFile(filters.userId)] : readdirSync(MEMORY_DIR).filter((f) => f.endsWith(".jsonl")).map((f) => join6(MEMORY_DIR, f));
+    const results = [];
+    for (const file of files) {
+      if (!existsSync6(file)) continue;
+      const lines = readFileSync5(file, "utf-8").split("\n").filter((l) => l.trim());
+      for (const line of lines) {
+        try {
+          const stored = JSON.parse(line);
+          if (filters.category && stored.metadata.category !== filters.category) continue;
+          if (filters.sessionId && stored.metadata.sessionId !== filters.sessionId) continue;
+          if (filters.tags && filters.tags.length > 0 && !filters.tags.some((t) => stored.metadata.tags?.includes(t))) continue;
+          results.push({
+            id: stored.id,
+            content: stored.content,
+            metadata: stored.metadata,
+            createdAt: new Date(stored.createdAt),
+            updatedAt: new Date(stored.updatedAt)
+          });
+        } catch {
+        }
+      }
+    }
+    return results.slice(0, filters.limit ?? 100);
+  }
+  async update(id, content) {
+    const files = readdirSync(MEMORY_DIR).filter((f) => f.endsWith(".jsonl")).map((f) => join6(MEMORY_DIR, f));
+    for (const file of files) {
+      if (!existsSync6(file)) continue;
+      const lines = readFileSync5(file, "utf-8").split("\n").filter((l) => l.trim());
+      const updated = lines.map((line) => {
+        try {
+          const stored = JSON.parse(line);
+          if (stored.id === id) {
+            stored.content = content;
+            stored.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+          }
+          return JSON.stringify(stored);
+        } catch {
+          return line;
+        }
+      });
+      writeFileSync4(file, updated.join("\n") + "\n");
+    }
+  }
+  async delete(id) {
+    const files = readdirSync(MEMORY_DIR).filter((f) => f.endsWith(".jsonl")).map((f) => join6(MEMORY_DIR, f));
+    for (const file of files) {
+      if (!existsSync6(file)) continue;
+      const lines = readFileSync5(file, "utf-8").split("\n").filter((l) => l.trim());
+      const filtered = lines.filter((line) => {
+        try {
+          const stored = JSON.parse(line);
+          return stored.id !== id;
+        } catch {
+          return true;
+        }
+      });
+      writeFileSync4(file, filtered.join("\n") + (filtered.length > 0 ? "\n" : ""));
+    }
+  }
+  userFile(userId) {
+    const safe = userId.replace(/[^a-zA-Z0-9_-]/g, "_");
+    return join6(MEMORY_DIR, `${safe}.jsonl`);
+  }
+};
+
+// src/resilience/degradation.ts
+var log10 = createLogger("degradation");
+var states = /* @__PURE__ */ new Map();
+function isDegraded(service) {
+  return states.get(service)?.degraded ?? false;
+}
+function degradationMessage(service) {
+  switch (service) {
+    case "dsers":
+      return "DSers service is temporarily unavailable. Your request has been queued and will be processed when the service recovers.";
+    case "llm":
+      return "AI service is experiencing issues. Using simplified responses until it recovers.";
+    case "mem0":
+      return "Memory service is temporarily offline. I can still help but won't remember preferences from this conversation.";
+  }
+}
+
+// src/gateway/gateway.ts
+var log11 = createLogger("gateway");
+var sessionHistories = /* @__PURE__ */ new Map();
+var MAX_HISTORY = 20;
+var DropClawGateway = class {
+  config;
+  channels = [];
+  webChannel = null;
+  memory;
+  agents = /* @__PURE__ */ new Map();
+  dsersClients = /* @__PURE__ */ new Map();
+  running = false;
+  constructor(config) {
+    this.config = config;
+    this.memory = new FileMemoryProvider();
+  }
+  async start() {
+    log11.info("Starting DropClaw Gateway...");
+    const web = new WebChatServer();
+    web.onMessage((msg) => this.handleMessage(web, msg));
+    await web.connect({ port: this.config.port });
+    this.webChannel = web;
+    this.channels.push(web);
+    log11.info({ port: this.config.port }, "Web chat channel connected");
+    if (this.config.telegramBotToken) {
+      try {
+        const tg = new TelegramAdapter();
+        tg.onMessage((msg) => this.handleMessage(tg, msg));
+        await tg.connect({ botToken: this.config.telegramBotToken });
+        this.channels.push(tg);
+        log11.info("Telegram channel connected");
+      } catch (error) {
+        log11.warn({ error }, "Telegram failed to connect \u2014 web chat still available");
+      }
+    }
+    this.running = true;
+    log11.info("DropClaw Gateway started");
+  }
+  async handleMessage(channel, message) {
+    await runWithTrace(
+      {
+        traceId: message.traceId,
+        userId: message.userId,
+        channelId: message.channelId
+      },
+      async () => {
+        const userId = message.userId;
+        if (!checkInboundLimit(userId)) {
+          log11.warn({ userId }, "Rate limit exceeded");
+          await channel.send(userId, { text: "Too many messages. Please wait a moment." });
+          return;
+        }
+        await debounceUser(userId);
+        const release = await acquireUserLock(userId);
+        try {
+          const session = loadSession(userId);
+          if (isOnboarding(session.state)) {
+            await this.handleOnboarding(channel, message, session);
+          } else {
+            if (isDegraded("llm")) {
+              await channel.send(userId, { text: degradationMessage("llm") });
+              return;
+            }
+            await this.handleReady(channel, message, session);
+          }
+        } catch (error) {
+          log11.error({ error, userId }, "Failed to handle message");
+          await channel.send(userId, {
+            text: "Something went wrong. Please try again."
+          });
+        } finally {
+          release();
+        }
+      }
+    );
+  }
+  // ─── Onboarding State Machine ─────────────────────────────────────
+  async handleOnboarding(channel, message, session) {
+    const userId = message.userId;
+    const text = message.text.trim();
+    const isCallback = message.metadata["isCallback"] === true;
+    const isWeb = channel instanceof WebChatServer;
+    switch (session.state) {
+      case "new":
+      case "onboard_demo":
+        await this.onboardWelcome(channel, userId, session);
+        break;
+      case "onboard_dsers_email":
+        await this.onboardEmail(channel, userId, text, session);
+        break;
+      case "onboard_dsers_password":
+        await this.onboardPassword(channel, message, session, isWeb);
+        break;
+      case "onboard_llm":
+        await this.onboardLLM(channel, message, session, isCallback, isWeb);
+        break;
+    }
+  }
+  async onboardWelcome(channel, userId, session) {
+    const welcome = "Welcome to *DropClaw*! I'm your AI assistant for dropshipping.\n\nI can help you:\n- Import products from AliExpress, Temu, 1688\n- Push products to your Shopify/WooCommerce store\n- Check inventory, pricing rules, and orders\n- ...all through this chat!\n\nLet's get you set up. It takes about 1 minute.\n\n*Step 1/3:* What is your DSers account email?";
+    await channel.send(userId, { text: welcome });
+    session.state = "onboard_dsers_email";
+    saveSession(userId, session);
+  }
+  async onboardEmail(channel, userId, text, session) {
+    if (!text.includes("@") || !text.includes(".")) {
+      await channel.send(userId, {
+        text: "That doesn't look like an email address. Please enter your DSers login email:"
+      });
+      return;
+    }
+    session.dspiEmail = text;
+    session.state = "onboard_dsers_password";
+    saveSession(userId, session);
+    if (channel instanceof WebChatServer) {
+      channel.sendSetInputType(userId, "password");
+    }
+    await channel.send(userId, {
+      text: "Got it!\n\n*Step 2/3:* Now enter your DSers password." + (channel instanceof WebChatServer ? "" : "\n_I will delete your message immediately for security._")
+    });
+  }
+  async onboardPassword(channel, message, session, isWeb) {
+    const userId = message.userId;
+    const password = message.text.trim();
+    if (isWeb) {
+      channel.sendClearInput(userId);
+      channel.sendSetInputType(userId, "text");
+    } else {
+      await channel.deleteMessage(
+        message.metadata["chatId"],
+        message.metadata["messageId"]
+      );
+    }
+    if (password.length < 1) {
+      await channel.send(userId, { text: "Password cannot be empty. Please try again:" });
+      if (isWeb) channel.sendSetInputType(userId, "password");
+      return;
+    }
+    session.dspiPassword = password;
+    saveSession(userId, session);
+    await channel.send(userId, { text: "Verifying with DSers..." });
+    try {
+      const dsersConfig = createDSersConfig(session.dspiEmail, password);
+      const client = new DSersClient(dsersConfig);
+      await client.get("/account-user-bff/v1/users/info");
+      this.dsersClients.set(userId, client);
+      session.state = "onboard_llm";
+      saveSession(userId, session);
+      await channel.send(userId, {
+        card: {
+          title: "DSers Connected!",
+          summary: "Your DSers account is verified.\n\n*Step 3/3:* Choose your AI provider.\nThis powers my intelligence. You can get a free API key from any provider.",
+          actions: [
+            { label: "OpenAI (GPT-4o)", callbackData: "llm:openai" },
+            { label: "Anthropic (Claude)", callbackData: "llm:anthropic" },
+            { label: "Google (Gemini)", callbackData: "llm:google" }
+          ]
+        }
+      });
+    } catch (error) {
+      session.dspiPassword = void 0;
+      session.state = "onboard_dsers_password";
+      saveSession(userId, session);
+      if (isWeb) channel.sendSetInputType(userId, "password");
+      const msg = error instanceof Error && error.message.includes("401") ? "Wrong email or password. Please re-enter your password:" : `Login failed: ${error instanceof Error ? error.message : "unknown error"}. Please try again:`;
+      await channel.send(userId, { text: msg });
+    }
+  }
+  async onboardLLM(channel, message, session, isCallback, isWeb) {
+    const userId = message.userId;
+    const text = message.text.trim();
+    if (isCallback && text.startsWith("llm:")) {
+      const provider = text.replace("llm:", "");
+      session.llmProvider = provider;
+      saveSession(userId, session);
+      const providerName = provider === "openai" ? "OpenAI" : provider === "anthropic" ? "Anthropic" : "Google";
+      if (isWeb) channel.sendSetInputType(userId, "password");
+      await channel.send(userId, {
+        text: `You chose *${providerName}*. Now paste your API key below.` + (isWeb ? "" : "\n_I will delete your message immediately._")
+      });
+      return;
+    }
+    if (!session.llmProvider) {
+      await channel.send(userId, {
+        card: {
+          title: "Choose AI Provider",
+          summary: "Please select your AI provider first:",
+          actions: [
+            { label: "OpenAI (GPT-4o)", callbackData: "llm:openai" },
+            { label: "Anthropic (Claude)", callbackData: "llm:anthropic" },
+            { label: "Google (Gemini)", callbackData: "llm:google" }
+          ]
+        }
+      });
+      return;
+    }
+    if (isWeb) {
+      channel.sendClearInput(userId);
+      channel.sendSetInputType(userId, "text");
+    } else {
+      await channel.deleteMessage(
+        message.metadata["chatId"],
+        message.metadata["messageId"]
+      );
+    }
+    if (text.length < 10) {
+      await channel.send(userId, { text: "That doesn't look like a valid API key. Please paste your key:" });
+      if (isWeb) channel.sendSetInputType(userId, "password");
+      return;
+    }
+    session.llmApiKey = text;
+    session.llmModel = getDefaultModel(session.llmProvider);
+    session.state = "ready";
+    saveSession(userId, session);
+    await channel.send(userId, {
+      text: `All set! DropClaw is ready.
+
+Try these:
+- "Show me my stores"
+- "What's in my import list?"
+- "Search for phone cases on AliExpress"
+- "Check my pricing rules"
+
+Just type naturally \u2014 I understand everyday language!`
+    });
+    writeAuditLog({
+      userId,
+      agentId: "gateway",
+      action: "onboarding_complete",
+      target: "user-session",
+      result: "success"
+    });
+  }
+  // ─── Ready State: Route to AI Agent ───────────────────────────────
+  async handleReady(channel, message, session) {
+    const userId = message.userId;
+    if (message.text.trim().toLowerCase() === "/reset") {
+      this.agents.delete(userId);
+      this.dsersClients.delete(userId);
+      sessionHistories.delete(userId);
+      saveSession(userId, { state: "new" });
+      await channel.send(userId, { text: "Account reset. Send any message to start over." });
+      return;
+    }
+    const agent = this.getOrCreateAgent(userId, session);
+    const sessionKey = `${channel.name}:${userId}`;
+    const history = sessionHistories.get(sessionKey) ?? [];
+    const context = {
+      userId,
+      sessionId: sessionKey,
+      channelId: channel.name,
+      history: history.slice(-MAX_HISTORY)
+    };
+    writeAuditLog({
+      userId,
+      agentId: agent.id,
+      action: "receive_message",
+      target: channel.name,
+      params: { text: message.text.slice(0, 100) },
+      result: "success"
+    });
+    try {
+      if (channel instanceof WebChatServer) {
+        await this.handleReadyStreaming(channel, userId, message.text, agent, context, history, sessionKey);
+      } else {
+        await this.handleReadyBatch(channel, userId, message.text, agent, context, history, sessionKey);
+      }
+    } catch (error) {
+      log11.error({ error, userId }, "Agent processing failed");
+      writeAuditLog({
+        userId,
+        agentId: agent.id,
+        action: "process_failed",
+        target: channel.name,
+        result: "failed",
+        error: error instanceof Error ? error.message : String(error)
+      });
+      const errMsg = error instanceof Error ? error.message : "";
+      if (errMsg.includes("401") || errMsg.includes("API key")) {
+        await channel.send(userId, {
+          text: "Your API key may be invalid or expired. Send /reset to reconfigure."
+        });
+      } else {
+        await channel.send(userId, {
+          text: "I'm having trouble right now. Please try again in a moment."
+        });
+      }
+    }
+  }
+  async handleReadyStreaming(channel, userId, text, agent, context, history, sessionKey) {
+    channel.sendTyping(userId, true);
+    const { textStream, response } = agent.processStream(text, context);
+    channel.sendTyping(userId, false);
+    channel.sendStreamStart(userId);
+    for await (const delta of textStream) {
+      channel.sendStreamDelta(userId, delta);
+    }
+    channel.sendStreamEnd(userId);
+    const result = await response;
+    history.push({ role: "user", content: text });
+    history.push({ role: "assistant", content: result.text });
+    sessionHistories.set(sessionKey, history.slice(-MAX_HISTORY * 2));
+    writeAuditLog({
+      userId,
+      agentId: agent.id,
+      action: "send_response",
+      target: "web",
+      params: {
+        responseLen: result.text.length,
+        toolCalls: result.toolCalls?.length ?? 0,
+        streaming: true
+      },
+      result: "success"
+    });
+  }
+  async handleReadyBatch(channel, userId, text, agent, context, history, sessionKey) {
+    const result = await agent.process(text, context);
+    history.push({ role: "user", content: text });
+    history.push({ role: "assistant", content: result.text });
+    sessionHistories.set(sessionKey, history.slice(-MAX_HISTORY * 2));
+    if (result.text) {
+      await channel.send(userId, { text: result.text });
+    }
+    writeAuditLog({
+      userId,
+      agentId: agent.id,
+      action: "send_response",
+      target: channel.name,
+      params: {
+        responseLen: result.text.length,
+        toolCalls: result.toolCalls?.length ?? 0
+      },
+      result: "success"
+    });
+  }
+  getOrCreateAgent(userId, session) {
+    let agent = this.agents.get(userId);
+    if (agent) return agent;
+    const dsersConfig = createDSersConfig(
+      session.dspiEmail,
+      session.dspiPassword
+    );
+    const dsersClient = new DSersClient(dsersConfig);
+    this.dsersClients.set(userId, dsersClient);
+    const llm = {
+      provider: session.llmProvider,
+      apiKey: session.llmApiKey,
+      model: session.llmModel ?? getDefaultModel(session.llmProvider)
+    };
+    agent = new DropClawCoreAgent(dsersClient, this.memory, llm);
+    this.agents.set(userId, agent);
+    return agent;
+  }
+  async stop() {
+    log11.info("Stopping DropClaw Gateway...");
+    for (const ch of this.channels) {
+      await ch.disconnect();
+    }
+    this.running = false;
+    log11.info("DropClaw Gateway stopped");
+  }
+  isRunning() {
+    return this.running;
+  }
+};
+
+// src/cli/start.ts
+var log12 = createLogger("cli:start");
+async function openBrowser(url) {
+  const { exec } = await import("child_process");
+  const cmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
+  exec(`${cmd} ${url}`, () => {
+  });
+}
+async function startCommand(opts) {
+  try {
+    const config = loadConfig(opts.config);
+    const url = `http://localhost:${config.port}`;
+    console.log("\n  DropClaw");
+    console.log(`  Web Chat:  ${url}`);
+    if (config.telegramBotToken) {
+      console.log("  Telegram:  enabled");
+    }
+    console.log();
+    const gateway = new DropClawGateway(config);
+    await gateway.start();
+    if (opts.open !== false) {
+      await openBrowser(url);
+    }
+    console.log(`  DropClaw is running. Chat at ${url}
+`);
+    const shutdown = async () => {
+      log12.info("Shutting down gracefully...");
+      await gateway.stop();
+      process.exit(0);
+    };
+    process.on("SIGINT", shutdown);
+    process.on("SIGTERM", shutdown);
+  } catch (error) {
+    log12.fatal({ error }, "Failed to start");
+    console.error(
+      `
+  Failed to start: ${error instanceof Error ? error.message : error}`
+    );
+    process.exit(1);
+  }
+}
+
+// src/cli/doctor.ts
+async function doctorCommand() {
+  console.log("\n  DropClaw Doctor\n");
+  const results = [];
+  if (configExists()) {
+    try {
+      const config = loadConfig();
+      results.push({ name: "Config file", status: "ok", message: CONFIG_PATH });
+      results.push({
+        name: "Web chat",
+        status: "ok",
+        message: `Port ${config.port}`
+      });
+      if (config.telegramBotToken) {
+        const tokenValid = config.telegramBotToken.includes(":");
+        results.push({
+          name: "Telegram token",
+          status: tokenValid ? "ok" : "warn",
+          message: tokenValid ? "Format valid" : "Format suspicious"
+        });
+      }
+    } catch (e) {
+      results.push({
+        name: "Config file",
+        status: "fail",
+        message: e instanceof Error ? e.message : String(e)
+      });
+    }
+  } else {
+    results.push({
+      name: "Config file",
+      status: "fail",
+      message: "Not found. Run 'dropclaw init' first."
+    });
+  }
+  try {
+    const resp = await fetch("https://bff-api-gw.dsers.com/", {
+      method: "HEAD",
+      signal: AbortSignal.timeout(5e3)
+    });
+    results.push({
+      name: "DSers API",
+      status: resp.status < 500 ? "ok" : "warn",
+      message: `Reachable (HTTP ${resp.status})`
+    });
+  } catch (e) {
+    results.push({
+      name: "DSers API",
+      status: "warn",
+      message: e instanceof Error ? e.message : "Unreachable"
+    });
+  }
+  for (const r of results) {
+    const icon = r.status === "ok" ? "  [OK]" : r.status === "warn" ? " [!!]" : "[FAIL]";
+    console.log(`  ${icon} ${r.name}: ${r.message}`);
+  }
+  const failed = results.filter((r) => r.status === "fail").length;
+  console.log(
+    failed === 0 ? "\n  All checks passed.\n" : `
+  ${failed} check(s) failed. Fix issues above.
+`
+  );
+}
+
+// src/cli/index.ts
+var program = new Command();
+program.name("dsclaw").description("AI-powered dropshipping agent \u2014 chat with your DSers store.").version("0.1.0");
+program.action(() => startCommand({}));
+program.command("init").description("Setup wizard \u2014 configure Telegram (optional)").action(initCommand);
+program.command("start").description("Start the DropClaw bot").option("-c, --config <path>", "Path to config file").option("--no-open", "Don't auto-open browser").action(startCommand);
+program.command("stop").description("Stop the DropClaw bot (PM2)").action(async () => {
+  const { execSync } = await import("child_process");
+  try {
+    execSync("pm2 stop dsclaw", { stdio: "inherit" });
+  } catch {
+    console.log("  Bot is not running or PM2 is not installed.");
+  }
+});
+program.command("status").description("Show bot status").action(async () => {
+  const { execSync } = await import("child_process");
+  try {
+    execSync("pm2 describe dsclaw", { stdio: "inherit" });
+  } catch {
+    console.log("  Bot is not running. Start with: dsclaw start");
+  }
+});
+program.command("doctor").description("Verify configuration").action(doctorCommand);
+program.parse();
+//# sourceMappingURL=index.js.map