tabclaw 0.1.0

package/dist/cli/index.js

@@ -0,0 +1,1858 @@
+#!/usr/bin/env node
+
+// src/cli/index.ts
+import { Command as Command8 } from "commander";
+
+// src/cli/attach.ts
+import { Command } from "commander";
+
+// src/shared/settings-merge.ts
+function isTabclawHook(hook) {
+  return hook.type === "http" && hook.url.includes("/hook/");
+}
+function isTabclawEntry(entry) {
+  return entry.hooks.some((hook) => isTabclawHook(hook));
+}
+function removeTabclawHooks(settings) {
+  if (!settings.hooks) return settings;
+  const cleanedHooks = {};
+  for (const [eventName, entries] of Object.entries(settings.hooks)) {
+    const cleanedEntries = entries.filter((entry) => !isTabclawEntry(entry));
+    if (cleanedEntries.length > 0) {
+      cleanedHooks[eventName] = cleanedEntries;
+    }
+  }
+  return { ...settings, hooks: cleanedHooks };
+}
+function mergeHooks(existing, newHooks) {
+  const cleaned = removeTabclawHooks(existing);
+  const mergedHooks = {};
+  const allEvents = /* @__PURE__ */ new Set([
+    ...Object.keys(cleaned.hooks || {}),
+    ...Object.keys(newHooks)
+  ]);
+  for (const eventName of allEvents) {
+    const existingEntries = cleaned.hooks?.[eventName] || [];
+    const newEntries = newHooks[eventName] || [];
+    const existingUrls = new Set(
+      existingEntries.flatMap((e) => e.hooks.map((h) => h.url))
+    );
+    const uniqueNewEntries = newEntries.filter(
+      (entry) => !entry.hooks.some((h) => existingUrls.has(h.url))
+    );
+    const merged = [...uniqueNewEntries, ...existingEntries];
+    if (merged.length > 0) {
+      mergedHooks[eventName] = merged;
+    }
+  }
+  return { ...cleaned, hooks: mergedHooks };
+}
+
+// src/shared/credentials.ts
+import { readFileSync, writeFileSync, existsSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+import { randomBytes } from "crypto";
+var CREDENTIALS_VERSION = "1";
+var DEFAULT_TOKEN_LENGTH = 32;
+function getCredentialsPath() {
+  return join(homedir(), ".tabclaw", "credentials.json");
+}
+function generateToken() {
+  return randomBytes(DEFAULT_TOKEN_LENGTH).toString("hex");
+}
+function loadCredentials() {
+  const path = getCredentialsPath();
+  if (!existsSync(path)) {
+    return null;
+  }
+  try {
+    const content = readFileSync(path, "utf-8");
+    return JSON.parse(content);
+  } catch (error) {
+    console.error(`Failed to load credentials from ${path}:`, error);
+    return null;
+  }
+}
+function saveCredentials(credentials) {
+  const path = getCredentialsPath();
+  writeFileSync(path, JSON.stringify(credentials, null, 2), { mode: 384 });
+}
+function getOrCreateHookToken() {
+  const existing = loadCredentials();
+  if (existing?.hookToken) {
+    return existing.hookToken;
+  }
+  const newToken = generateToken();
+  const credentials = {
+    version: CREDENTIALS_VERSION,
+    hookToken: newToken,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  saveCredentials(credentials);
+  return newToken;
+}
+function getHookToken() {
+  return loadCredentials()?.hookToken ?? null;
+}
+
+// src/cli/attach.ts
+import { existsSync as existsSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync2, mkdirSync } from "fs";
+import { homedir as homedir3 } from "os";
+import { join as join3, dirname } from "path";
+
+// src/config.ts
+import { readFileSync as readFileSync2, existsSync as existsSync2 } from "fs";
+import { join as join2 } from "path";
+import { homedir as homedir2 } from "os";
+import TOML from "@iarna/toml";
+import dotenv from "dotenv";
+dotenv.config();
+var DEFAULT_CONFIG = {
+  general: {
+    default_agent: "claude",
+    log_level: "info",
+    hook_server_port: 9876
+  },
+  channel: {
+    logger: {
+      enabled: true
+    },
+    telegram: {
+      enabled: true,
+      bot_token: "",
+      allowed_users: []
+    },
+    feishu: {
+      enabled: false,
+      app_id: "",
+      app_secret: ""
+    },
+    permission: {
+      timeout_ms: 3e5,
+      // 5 minutes
+      default_on_timeout: "deny"
+    }
+  },
+  agent: {
+    claude: {
+      adapter: "hooks",
+      binary: "claude",
+      work_dir: "",
+      model: "",
+      permission_mode: "",
+      permission: {
+        lowRiskTools: ["Read", "Glob", "Grep", "List", "WebSearch", "codesearch"]
+      }
+    }
+  }
+};
+function getConfigPath() {
+  return join2(homedir2(), ".tabclaw", "config.toml");
+}
+function mergeWithDefaults(raw) {
+  return {
+    general: {
+      ...DEFAULT_CONFIG.general,
+      ...raw.general || {},
+      hook_server_port: parseInt(
+        process.env.TABCLAW_HOOK_SERVER_PORT || String(raw.general?.hook_server_port || DEFAULT_CONFIG.general.hook_server_port),
+        10
+      )
+    },
+    channel: {
+      logger: {
+        ...DEFAULT_CONFIG.channel.logger,
+        ...raw.channel?.logger || {},
+        notify_types: raw.channel?.logger?.notify_types
+      },
+      telegram: {
+        ...DEFAULT_CONFIG.channel.telegram,
+        ...raw.channel?.telegram || {},
+        allowed_users: (raw.channel?.telegram?.allowed_users || []).map(String),
+        bot_token: process.env.TABCLAW_TELEGRAM_BOT_TOKEN || raw.channel?.telegram?.bot_token || "",
+        notify_types: raw.channel?.telegram?.notify_types
+      },
+      feishu: {
+        ...DEFAULT_CONFIG.channel.feishu,
+        ...raw.channel?.feishu || {},
+        app_id: process.env.TABCLAW_FEISHU_APP_ID || raw.channel?.feishu?.app_id || "",
+        app_secret: process.env.TABCLAW_FEISHU_APP_SECRET || raw.channel?.feishu?.app_secret || ""
+      },
+      permission: {
+        ...DEFAULT_CONFIG.channel.permission,
+        ...raw.channel?.permission || {},
+        // Support env var override
+        timeout_ms: parseInt(
+          process.env.TABCLAW_PERMISSION_TIMEOUT_MS || String(
+            raw.channel?.permission?.timeout_ms || DEFAULT_CONFIG.channel.permission.timeout_ms
+          ),
+          10
+        ),
+        default_on_timeout: process.env.TABCLAW_PERMISSION_DEFAULT || raw.channel?.permission?.default_on_timeout || DEFAULT_CONFIG.channel.permission.default_on_timeout
+      }
+    },
+    agent: {
+      claude: {
+        ...DEFAULT_CONFIG.agent.claude,
+        ...raw.agent?.claude || {},
+        permission: {
+          ...DEFAULT_CONFIG.agent.claude.permission,
+          ...raw.agent?.claude?.permission || {}
+        }
+      }
+    }
+  };
+}
+function loadConfig() {
+  const configPath = getConfigPath();
+  if (!existsSync2(configPath)) {
+    return DEFAULT_CONFIG;
+  }
+  try {
+    const content = readFileSync2(configPath, "utf-8");
+    const raw = TOML.parse(content);
+    return mergeWithDefaults(raw);
+  } catch (error) {
+    console.error(`Failed to load config from ${configPath}:`, error);
+    return DEFAULT_CONFIG;
+  }
+}
+
+// src/i18n/index.ts
+import i18next from "i18next";
+
+// src/i18n/locales/en.ts
+var en_default = {
+  wizard: {
+    section: {
+      cli: "[ CLI Configuration ]",
+      channel: "[ Channel Configuration ]",
+      complete: "[ Setup Complete ]"
+    },
+    cli: {
+      runAgain: "Run init again when Claude Code is installed.",
+      detected: "Claude Code detected.",
+      hooksInstalled: "Hooks already installed.",
+      hooksNotInstalled: "Hooks not installed.",
+      actionQuestion: "Select action:",
+      injectAction: "Inject hooks configuration",
+      updateAction: "Update hooks configuration",
+      backAction: "Back",
+      hookCheckbox: "Select hooks:",
+      noHooksSelected: "No hooks selected, skipping injection.",
+      injecting: "Injecting hooks...",
+      injected: "Hooks injected",
+      failed: "Failed: {{error}}"
+    },
+    channel: {
+      configuring: "Configuring {{channel}}",
+      telegram: {
+        botToken: "Telegram bot token:",
+        allowedUsers: "Allowed Telegram user IDs (comma-separated):",
+        testing: "Testing Telegram connection...",
+        connected: "Connected to Telegram",
+        sendingTest: "Sending test message...",
+        testSent: "Test message sent",
+        testContent: "TabClaw test message",
+        testWarning: "Could not send test message (user may not have messaged bot yet)",
+        apiError: "API error: {{status}}",
+        connFailed: "Connection failed: {{error}}"
+      },
+      feishu: {
+        appId: "Feishu App ID:",
+        appSecret: "Feishu App Secret:",
+        required: "app_id and app_secret are required. Skipping."
+      }
+    },
+    notify: {
+      title: "Notification types for {{channel}}",
+      checkbox: "Notification types:",
+      saved: "Notification types saved for {{channel}}"
+    },
+    menu: {
+      select: "Select:",
+      next: "--- Next ---",
+      testFailed: "Test failed. Action:",
+      retry: "Retry",
+      reenter: "Re-enter",
+      backToMenu: "Back to menu",
+      restartQuestion: "Restart Gateway now?"
+    },
+    final: {
+      noItems: "No items configured.",
+      itemOk: "{{item}}: OK",
+      running: "Gateway is running",
+      runningChanges: "Gateway is running with pending changes",
+      configModified: "Configuration was modified. Restart required to apply changes.",
+      runningReady: "Gateway is already running and ready.",
+      notRunning: "Gateway is not running",
+      configModifiedStart: "Configuration was modified. Starting Gateway with new configuration.",
+      restarting: "Restarting...",
+      restarted: "Gateway restarted with new configuration",
+      starting: "Starting...",
+      started: "Gateway started",
+      startFailed: "Failed: {{error}}",
+      restartTip: "Run `tabclaw gateway start` to restart.",
+      startTip: "Run `tabclaw gateway start` to start.",
+      done: "Done."
+    }
+  },
+  gateway: {
+    stopping: "Gateway is running, stopping first...",
+    startedOnPort: "Gateway started on port {{port}}",
+    stopped: "Gateway stopped",
+    restartedOnPort: "Gateway restarted on port {{port}}",
+    startFailed: "Failed to start Gateway",
+    stopFailed: "Failed to stop Gateway",
+    restartFailed: "Failed to restart Gateway",
+    error: "  Error: {{error}}",
+    checkLogs: "Check logs at: {{path}}",
+    status: {
+      title: "Gateway Status:",
+      running: "Running: {{value}}",
+      sessions: "Sessions: {{count}}",
+      clients: "Connected clients: {{count}}",
+      activeSessions: "Active sessions:",
+      notResponding: "Gateway is not responding",
+      notRunning: "Gateway is not running"
+    }
+  },
+  daemon: {
+    alreadyRunning: "Daemon is already running",
+    startedOnPort: "Daemon started on port {{port}}",
+    startFailed: "Daemon failed to start. Check logs for details.",
+    checkLogs: "Check logs at: {{path}}",
+    portInUse: "Warning: Port {{port}} still in use after {{ms}}ms",
+    startError: "Failed to start daemon: {{error}}",
+    lackingToken: "Daemon is running but PID file lacks token, restarting...",
+    scriptNotFound: "Daemon script not found: {{path}}"
+  },
+  status: {
+    title: "=== Tabclaw Status ===",
+    daemon: {
+      running: "Daemon: \u2713 Running",
+      notRunning: "Daemon: \u2717 Not running"
+    },
+    port: "Port: {{port}}",
+    logLevel: "Log Level: {{level}}",
+    channels: "Channels:",
+    telegram: {
+      enabled: "Telegram: \u2713 Enabled",
+      disabled: "Telegram: \u2717 Disabled"
+    },
+    feishu: {
+      enabled: "Feishu: \u2713 Enabled",
+      disabled: "Feishu: \u2717 Disabled"
+    },
+    settingsBackup: "Settings: \u2713 Backup exists",
+    settingsNoBackup: "Settings: \u2717 No backup",
+    paths: "Paths:",
+    pathConfig: "Config: {{path}}",
+    pathLogs: "Logs: {{path}}",
+    pathBackup: "Backup: {{path}}"
+  },
+  cli: {
+    init: {
+      configExists: "Configuration exists. Continue?",
+      cancelled: "Cancelled."
+    },
+    stop: {
+      notRunning: "Tabclaw daemon is not running",
+      stopping: "Stopping tabclaw daemon...",
+      stopped: "Daemon stopped successfully",
+      failed: "Failed to stop daemon cleanly"
+    },
+    attach: {
+      checking: "Checking Gateway status...",
+      running: "Gateway is running",
+      notRunning: "Gateway is not running. Start it with: tabclaw gateway start",
+      tokenNotFound: 'Hook token not found. Please run "tabclaw init" first.',
+      attached: "Successfully attached {{agent}} to Gateway",
+      start: 'Start "claude" to begin a session.',
+      usingToken: "Using hook token: {{token}}",
+      settingsBacked: "Claude settings backed up to: {{path}}",
+      configuringHooks: "Configuring hooks in Claude settings...",
+      connected: "Your Claude Code is now connected to tabclaw Gateway.",
+      forwarding: "Events will be forwarded to connected clients.",
+      tipStatus: 'Use "tabclaw gateway status" to check status',
+      tipDetach: 'Use "tabclaw detach" to remove hooks and restore settings'
+    },
+    agent: {
+      alreadyRunning: "Tabclaw daemon is already running",
+      starting: "Starting tabclaw daemon...",
+      started: "Daemon started",
+      startFailed: "Failed to start daemon",
+      tokenNotFound: "Failed to get token from daemon",
+      hooksConfigured: "Claude hooks configured",
+      startingIn: "Starting Claude Code in {{dir}}...",
+      pressCtrlC: "Press Ctrl+C to stop (tabclaw daemon will keep running)",
+      configuring: "Configuring Claude Code...",
+      settingsBacked: "Claude settings backed up",
+      exited: "\nClaude Code exited with code {{code}}",
+      daemonRunning: "Tabclaw daemon is still running in the background",
+      tipStop: 'Use "tabclaw stop" to stop the daemon and restore settings',
+      detaching: "\nDetaching from Claude..."
+    },
+    debug: {
+      starting: "Starting hook debug server on port {{port}}",
+      capturing: "This will capture all incoming webhook requests...",
+      pressCtrlC: "Press Ctrl+C to stop.",
+      stopping: "\nStopping debug server..."
+    }
+  },
+  notifications: {
+    permission: {
+      title: "\u{1F510} Permission Request",
+      session: "Session: {{sessionId}}",
+      tool: "Tool: {{toolName}}",
+      args: "Args: {{args}}",
+      requestId: "Request ID: {{requestId}}",
+      allow: "\u2705 Allow",
+      deny: "\u274C Deny"
+    },
+    finished: {
+      titleTelegram: "\u2705 Task Completed",
+      titleLogger: "\u{1F3C1} Task Completed",
+      session: "Session: {{sessionId}}",
+      message: "Message: {{message}}",
+      eventType: "Type: {{eventType}}"
+    },
+    sessionStart: {
+      title: "\u{1F7E2} Session Started",
+      session: "Session: {{sessionId}}"
+    },
+    error: {
+      title: "\u274C Error",
+      session: "Session: {{sessionId}}",
+      tool: "Tool: {{toolName}}",
+      message: "Message: {{message}}"
+    },
+    unauthorized: "You are not authorized to use this bot.",
+    received: "Message received.",
+    processingError: "Error processing message."
+  }
+};
+
+// src/i18n/index.ts
+var lng = process.env.TABCLAW_LANG ?? "en";
+i18next.init({
+  initImmediate: false,
+  lng,
+  fallbackLng: "en",
+  resources: { en: { translation: en_default } },
+  interpolation: { escapeValue: false }
+});
+var t = i18next.t.bind(i18next);
+
+// src/cli/attach.ts
+function getSettingsPath() {
+  return join3(homedir3(), ".claude", "settings.json");
+}
+function backupSettings(settingsPath) {
+  const backupPath = settingsPath + ".tabclaw-backup";
+  if (existsSync3(settingsPath)) {
+    writeFileSync2(backupPath, readFileSync3(settingsPath, "utf-8"));
+  }
+}
+function writeSettings(settingsPath, settings) {
+  mkdirSync(dirname(settingsPath), { recursive: true });
+  writeFileSync2(settingsPath, JSON.stringify(settings, null, 2));
+}
+function getGatewayBaseUrl(port) {
+  return `http://localhost:${port}`;
+}
+async function checkGatewayHealth(port) {
+  try {
+    const response = await fetch(`${getGatewayBaseUrl(port)}/health`, {
+      method: "GET",
+      signal: AbortSignal.timeout(5e3)
+    });
+    return response.ok;
+  } catch {
+    return false;
+  }
+}
+function generateHooksConfig(token, port) {
+  const baseUrl = `${getGatewayBaseUrl(port)}/hook/${token}`;
+  const createHookEntry = (event) => ({
+    matcher: "",
+    hooks: [{ type: "http", url: `${baseUrl}/${event}` }]
+  });
+  return {
+    Stop: [createHookEntry("Stop")],
+    SessionStart: [createHookEntry("SessionStart")],
+    SessionEnd: [createHookEntry("SessionEnd")],
+    UserPromptSubmit: [createHookEntry("UserPromptSubmit")],
+    PermissionRequest: [createHookEntry("PermissionRequest")]
+  };
+}
+var attachCommand = new Command("attach").description("Attach an agent to the Gateway").argument("<agent-type>", "Agent type (e.g., claude)").action(async (agentType) => {
+  const config = loadConfig();
+  const gatewayPort = config.general.hook_server_port;
+  console.log(t("cli.attach.checking"));
+  const isHealthy = await checkGatewayHealth(gatewayPort);
+  if (!isHealthy) {
+    console.error(t("cli.attach.notRunning"));
+    process.exit(1);
+  }
+  console.log(t("cli.attach.running"));
+  const hookToken = getHookToken();
+  if (!hookToken) {
+    console.error(t("cli.attach.tokenNotFound"));
+    process.exit(1);
+  }
+  const token = hookToken.substring(0, 8) + "...";
+  console.log(t("cli.attach.usingToken", { token }));
+  const settingsPath = getSettingsPath();
+  const backupPath = settingsPath + ".tabclaw-backup";
+  if (!existsSync3(backupPath)) {
+    backupSettings(settingsPath);
+    console.log(t("cli.attach.settingsBacked", { path: backupPath }));
+  }
+  console.log(t("cli.attach.configuringHooks"));
+  let currentSettings = {};
+  if (existsSync3(settingsPath)) {
+    currentSettings = JSON.parse(readFileSync3(settingsPath, "utf-8"));
+  }
+  const hooksConfig = generateHooksConfig(hookToken, gatewayPort);
+  const mergedSettings = mergeHooks(currentSettings, hooksConfig);
+  writeSettings(settingsPath, mergedSettings);
+  console.log("");
+  console.log(t("cli.attach.attached", { agent: agentType }));
+  console.log("");
+  console.log(t("cli.attach.connected"));
+  console.log(t("cli.attach.start"));
+  console.log("");
+  console.log(t("cli.attach.forwarding"));
+  console.log(t("cli.attach.tipStatus"));
+  console.log(t("cli.attach.tipDetach"));
+});
+
+// src/cli/init.ts
+import { Command as Command2 } from "commander";
+import { existsSync as existsSync9 } from "fs";
+import { join as join9 } from "path";
+import { homedir as homedir8 } from "os";
+import { confirm as confirm2 } from "@inquirer/prompts";
+
+// src/cli/wizard/engine.ts
+import { existsSync as existsSync8 } from "fs";
+import { join as join8 } from "path";
+import { homedir as homedir7 } from "os";
+
+// src/cli/wizard/state.ts
+function createInitialState(hasExistingConfig) {
+  return {
+    current: "cli-menu",
+    hasExistingConfig,
+    pendingChanges: {},
+    itemStatus: /* @__PURE__ */ new Map(),
+    sessionConfigured: /* @__PURE__ */ new Set(),
+    validationResults: /* @__PURE__ */ new Map()
+  };
+}
+
+// src/cli/wizard/applicator.ts
+import { writeFileSync as writeFileSync3, mkdirSync as mkdirSync2 } from "fs";
+import { join as join4 } from "path";
+import { homedir as homedir4 } from "os";
+import TOML2 from "@iarna/toml";
+var ConfigApplicator = class {
+  apply(pending) {
+    const current = loadConfig();
+    const merged = {
+      ...current,
+      general: { ...current.general },
+      channel: {
+        ...current.channel,
+        ...pending.channel || {}
+      },
+      agent: {
+        ...current.agent,
+        ...pending.agent ? { claude: { ...current.agent?.claude ?? {}, ...pending.agent } } : {}
+      }
+    };
+    const configDir = join4(homedir4(), ".tabclaw");
+    mkdirSync2(configDir, { recursive: true });
+    const configPath = join4(configDir, "config.toml");
+    const content = TOML2.stringify(merged);
+    writeFileSync3(configPath, content);
+  }
+};
+
+// src/cli/wizard/detectors/claude.ts
+import { execSync } from "child_process";
+import { readFileSync as readFileSync4, existsSync as existsSync4 } from "fs";
+import { join as join5 } from "path";
+import { homedir as homedir5 } from "os";
+function detectClaude() {
+  const settingsPath = join5(homedir5(), ".claude", "settings.json");
+  let binaryPath;
+  let supported = false;
+  try {
+    binaryPath = execSync("which claude", { encoding: "utf-8" }).trim();
+    supported = !!binaryPath;
+  } catch {
+  }
+  if (!supported) {
+    return {
+      supported: false,
+      hooked: false,
+      message: "Claude Code not found in PATH. Please install Claude Code first.",
+      settingsPath
+    };
+  }
+  let hooked = false;
+  if (existsSync4(settingsPath)) {
+    try {
+      const settings = JSON.parse(readFileSync4(settingsPath, "utf-8"));
+      hooked = isTabclawHooked(settings);
+    } catch {
+    }
+  }
+  return {
+    supported: true,
+    hooked,
+    message: hooked ? "Claude Code hooks already configured." : "Claude Code detected.",
+    binaryPath,
+    settingsPath
+  };
+}
+function isTabclawHooked(settings) {
+  const hooks = settings.hooks;
+  if (!hooks) return false;
+  for (const key of Object.keys(hooks)) {
+    const entries = hooks[key];
+    for (const entry of entries) {
+      if (!entry || typeof entry !== "object") continue;
+      const e = entry;
+      const inner = e.hooks;
+      if (Array.isArray(inner) && inner.some((h) => isHttpHookWithTabclawUrl(h))) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+function isHttpHookWithTabclawUrl(entry) {
+  if (!entry || typeof entry !== "object") return false;
+  const e = entry;
+  if (e.type !== "http") return false;
+  const url = e.url;
+  return typeof url === "string" && url.includes("localhost") && url.includes("/hook/");
+}
+
+// src/cli/wizard/prompts.ts
+import { confirm, input, checkbox, select } from "@inquirer/prompts";
+var prompts = {
+  feishuAppId: (current) => input({
+    message: t("wizard.channel.feishu.appId"),
+    default: current || ""
+  }),
+  feishuAppSecret: (current) => input({
+    message: t("wizard.channel.feishu.appSecret"),
+    default: current || ""
+  }),
+  cliActionSelect: (hooked) => select({
+    message: t("wizard.cli.actionQuestion"),
+    choices: hooked ? [
+      { name: t("wizard.cli.updateAction"), value: "update" },
+      { name: t("wizard.cli.backAction"), value: "back" }
+    ] : [
+      { name: t("wizard.cli.injectAction"), value: "inject" },
+      { name: t("wizard.cli.backAction"), value: "back" }
+    ]
+  }),
+  cliHookSelect: (selected) => checkbox({
+    message: t("wizard.cli.hookCheckbox"),
+    choices: [
+      { name: "Stop", value: "Stop", checked: selected?.includes("Stop") ?? true },
+      { name: "SessionStart", value: "SessionStart", checked: selected?.includes("SessionStart") ?? true },
+      { name: "SessionEnd", value: "SessionEnd", checked: selected?.includes("SessionEnd") ?? true },
+      { name: "PermissionRequest", value: "PermissionRequest", checked: selected?.includes("PermissionRequest") ?? true },
+      { name: "UserPromptSubmit", value: "UserPromptSubmit", checked: selected?.includes("UserPromptSubmit") ?? false },
+      { name: "PostToolUse", value: "PostToolUse", checked: selected?.includes("PostToolUse") ?? false },
+      { name: "PostToolUseFailure", value: "PostToolUseFailure", checked: selected?.includes("PostToolUseFailure") ?? false },
+      { name: "Notification", value: "Notification", checked: selected?.includes("Notification") ?? false },
+      { name: "SubagentStart", value: "SubagentStart", checked: selected?.includes("SubagentStart") ?? false },
+      { name: "SubagentStop", value: "SubagentStop", checked: selected?.includes("SubagentStop") ?? false }
+    ]
+  }),
+  botToken: (current) => input({
+    message: t("wizard.channel.telegram.botToken"),
+    default: current || ""
+  }),
+  allowedUsers: (current) => input({
+    message: t("wizard.channel.telegram.allowedUsers"),
+    default: current || ""
+  }),
+  channelMenuSelect: (channels) => select({
+    message: t("wizard.menu.select"),
+    choices: [
+      ...channels.map((c) => ({
+        name: `${c.name}  ${c.status}`,
+        value: c.name
+      })),
+      { name: t("wizard.menu.next"), value: "__next__" }
+    ]
+  }),
+  notifyTypes: (selected) => checkbox({
+    message: t("wizard.notify.checkbox"),
+    choices: [
+      { name: "permission_request", value: "permission_request", checked: selected?.includes("permission_request") },
+      { name: "finished", value: "finished", checked: selected?.includes("finished") },
+      { name: "session_start", value: "session_start", checked: selected?.includes("session_start") },
+      { name: "error", value: "error", checked: selected?.includes("error") }
+    ]
+  }),
+  channelConfigError: () => select({
+    message: t("wizard.menu.testFailed"),
+    choices: [
+      { name: t("wizard.menu.retry"), value: "retry" },
+      { name: t("wizard.menu.reenter"), value: "reinput" },
+      { name: t("wizard.menu.backToMenu"), value: "skip" }
+    ]
+  }),
+  restartGateway: () => confirm({
+    message: t("wizard.menu.restartQuestion"),
+    default: true
+  })
+};
+
+// src/cli/wizard/steps/cli.ts
+import { writeFileSync as writeFileSync4, existsSync as existsSync5, readFileSync as readFileSync5, mkdirSync as mkdirSync3 } from "fs";
+import { dirname as dirname2 } from "path";
+import pc from "picocolors";
+import ora from "ora";
+async function stepCli(state) {
+  const cliName = state.currentCliName || "claude";
+  console.log(pc.bold(`
+${t("wizard.section.cli")}
+`));
+  if (cliName === "claude") {
+    const detection = state.claudeDetection ?? detectClaude();
+    if (!detection.supported) {
+      console.log(pc.yellow(`! ${detection.message}`));
+      console.log(pc.gray(`  ${t("wizard.cli.runAgain")}
+`));
+      return { action: "next", next: "cli-menu" };
+    }
+    console.log(pc.green(`* ${t("wizard.cli.detected")}`));
+    console.log(pc.gray(`  Settings: ${detection.settingsPath}`));
+    const port = loadConfig().general.hook_server_port;
+    const token = getHookToken();
+    console.log(pc.gray(`  Gateway: http://localhost:${port}/hook/${token ? token.substring(0, 8) + "..." : "unknown"}`));
+    if (detection.hooked) {
+      console.log(pc.green(`  ${t("wizard.cli.hooksInstalled")}`));
+    } else {
+      console.log(pc.yellow(`  ${t("wizard.cli.hooksNotInstalled")}`));
+    }
+    console.log("");
+    const action = await prompts.cliActionSelect(detection.hooked);
+    if (action === "back") {
+      console.log("");
+      return { action: "next", next: "cli-menu" };
+    }
+    const selectedHooks = await prompts.cliHookSelect();
+    if (selectedHooks.length === 0) {
+      console.log(pc.yellow(`! ${t("wizard.cli.noHooksSelected")}
+`));
+      return { action: "next", next: "cli-menu" };
+    }
+    const spinner = ora(t("wizard.cli.injecting")).start();
+    try {
+      injectClaudeHooks(detection.settingsPath, selectedHooks);
+      spinner.succeed(t("wizard.cli.injected"));
+      state.itemStatus.set("claude", "configured");
+      state.sessionConfigured.add("claude");
+      state.pendingChanges.agent = { adapter: "hooks" };
+      state.validationResults.set("claude", { ok: true });
+    } catch (err) {
+      spinner.fail(t("wizard.cli.failed", { error: String(err) }));
+      state.itemStatus.set("claude", "error");
+      state.validationResults.set("claude", { ok: false, message: String(err) });
+    }
+  }
+  return { action: "next", next: "cli-menu" };
+}
+function injectClaudeHooks(settingsPath, events) {
+  const port = loadConfig().general.hook_server_port;
+  const token = getOrCreateHookToken();
+  const baseUrl = `http://localhost:${port}/hook/${token}`;
+  const hooksConfig = generateHooksConfig2(baseUrl, events);
+  let currentSettings = {};
+  if (existsSync5(settingsPath)) {
+    try {
+      currentSettings = JSON.parse(readFileSync5(settingsPath, "utf-8"));
+    } catch {
+    }
+  }
+  const mergedSettings = mergeHooks(
+    currentSettings,
+    hooksConfig
+  );
+  mkdirSync3(dirname2(settingsPath), { recursive: true });
+  writeFileSync4(settingsPath, JSON.stringify(mergedSettings, null, 2));
+}
+function generateHooksConfig2(baseUrl, events) {
+  const createEntry = (event) => ({
+    matcher: "",
+    hooks: [{ type: "http", url: `${baseUrl}/${event}` }]
+  });
+  const config = {};
+  for (const event of events) {
+    config[event] = [createEntry(event)];
+  }
+  return config;
+}
+
+// src/cli/wizard/detectors/channel.ts
+async function detectChannel(name) {
+  const config = loadConfig();
+  switch (name) {
+    case "logger":
+      return { configured: config.channel.logger?.enabled === true };
+    case "telegram": {
+      const token = config.channel.telegram?.bot_token;
+      if (!token || token === "YOUR_BOT_TOKEN") {
+        return { configured: false };
+      }
+      try {
+        const response = await fetch(`https://api.telegram.org/bot${token}/getMe`, {
+          signal: AbortSignal.timeout(5e3)
+        });
+        if (!response.ok) {
+          return { configured: false, error: `Telegram API error: ${response.status}` };
+        }
+        return { configured: true };
+      } catch (err) {
+        return { configured: false, error: `Connection failed: ${err}` };
+      }
+    }
+    case "feishu":
+      return { configured: !!(config.channel.feishu?.enabled && config.channel.feishu?.app_id) };
+    default:
+      return { configured: false };
+  }
+}
+function getChannelStatusLabel(status, error) {
+  switch (status) {
+    case "configured":
+      return "[done]";
+    case "error":
+      return `[error]${error ? ` (${error})` : ""}`;
+    default:
+      return "";
+  }
+}
+
+// src/cli/wizard/steps/channel-menu.ts
+import pc2 from "picocolors";
+async function stepChannelMenu(state) {
+  console.log(pc2.bold(`
+${t("wizard.section.channel")}
+`));
+  const channelNames = ["logger", "telegram", "feishu"];
+  const channels = channelNames.map((name) => {
+    const status = state.itemStatus.get(name) || "unconfigured";
+    const validation = state.validationResults.get(name);
+    return {
+      name,
+      status: getChannelStatusLabel(status, validation?.message)
+    };
+  });
+  const choice = await prompts.channelMenuSelect(channels);
+  if (choice === "__next__") {
+    return { action: "next", next: "final" };
+  }
+  state.currentChannelName = choice;
+  return { action: "next", next: "channel-config" };
+}
+async function stepCliMenu(state) {
+  console.log(pc2.bold(`
+${t("wizard.section.cli")}
+`));
+  const cliStatus = state.itemStatus.get("claude") || "unconfigured";
+  const label = getChannelStatusLabel(cliStatus);
+  const choice = await prompts.channelMenuSelect([{
+    name: "claude",
+    status: label
+  }]);
+  if (choice === "__next__") {
+    return { action: "next", next: "channel-menu" };
+  }
+  state.currentCliName = choice;
+  return { action: "next", next: "cli" };
+}
+
+// src/cli/wizard/steps/channel-config.ts
+import pc3 from "picocolors";
+import ora2 from "ora";
+async function stepChannelConfig(state) {
+  const channelName = state.currentChannelName || "telegram";
+  console.log(pc3.bold(`
+${t("wizard.channel.configuring", { channel: channelName })}
+`));
+  while (true) {
+    const cfg = loadConfig();
+    const channelMap = cfg.channel;
+    const currentConfig = channelMap[channelName] ?? {};
+    if (channelName === "telegram") {
+      const botToken = await prompts.botToken(currentConfig.bot_token);
+      const allowedUsers = await prompts.allowedUsers(String(currentConfig.allowed_users || ""));
+      const userIds = allowedUsers.split(",").map((s) => parseInt(s.trim(), 10)).filter((n) => !isNaN(n));
+      const spinner = ora2(t("wizard.channel.telegram.testing")).start();
+      let connected = false;
+      try {
+        const response = await fetch(`https://api.telegram.org/bot${botToken}/getMe`, {
+          signal: AbortSignal.timeout(8e3)
+        });
+        if (!response.ok) {
+          spinner.fail(t("wizard.channel.telegram.apiError", { status: response.status }));
+        } else {
+          spinner.succeed(t("wizard.channel.telegram.connected"));
+          connected = true;
+        }
+      } catch (err) {
+        spinner.fail(t("wizard.channel.telegram.connFailed", { error: String(err) }));
+      }
+      if (!connected) {
+        state.itemStatus.set(channelName, "error");
+        const choice = await prompts.channelConfigError();
+        if (choice === "retry" || choice === "reinput") {
+          continue;
+        }
+        state.itemStatus.set(channelName, "unconfigured");
+        return { action: "next", next: "channel-menu" };
+      }
+      const msgSpinner = ora2(t("wizard.channel.telegram.sendingTest")).start();
+      try {
+        await fetch(`https://api.telegram.org/bot${botToken}/sendMessage`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ chat_id: userIds[0] || 0, text: t("wizard.channel.telegram.testContent") }),
+          signal: AbortSignal.timeout(8e3)
+        });
+        msgSpinner.succeed(t("wizard.channel.telegram.testSent"));
+      } catch {
+        msgSpinner.warn(t("wizard.channel.telegram.testWarning"));
+      }
+      state.pendingChanges.channel = {
+        ...state.pendingChanges.channel || {},
+        telegram: { enabled: true, bot_token: botToken, allowed_users: userIds }
+      };
+      state.itemStatus.set("telegram", "configured");
+      state.sessionConfigured.add("telegram");
+      state.validationResults.set("telegram", { ok: true });
+      return { action: "next", next: "channel-notify" };
+    }
+    if (channelName === "logger") {
+      state.pendingChanges.channel = {
+        ...state.pendingChanges.channel || {},
+        logger: { enabled: true }
+      };
+      state.itemStatus.set("logger", "configured");
+      state.sessionConfigured.add("logger");
+      return { action: "next", next: "channel-notify" };
+    }
+    if (channelName === "feishu") {
+      const appId = await prompts.feishuAppId();
+      const appSecret = await prompts.feishuAppSecret();
+      if (!appId || !appSecret) {
+        console.log(pc3.yellow(`! ${t("wizard.channel.feishu.required")}
+`));
+        state.itemStatus.set("feishu", "unconfigured");
+        return { action: "next", next: "channel-menu" };
+      }
+      state.pendingChanges.channel = {
+        ...state.pendingChanges.channel || {},
+        feishu: { enabled: true, app_id: appId, app_secret: appSecret }
+      };
+      state.itemStatus.set("feishu", "configured");
+      state.sessionConfigured.add("feishu");
+      return { action: "next", next: "channel-notify" };
+    }
+    return { action: "next", next: "channel-menu" };
+  }
+}
+
+// src/cli/wizard/steps/channel-notify.ts
+import pc4 from "picocolors";
+async function stepChannelNotify(state) {
+  const channelName = state.currentChannelName || "telegram";
+  console.log(pc4.bold(`
+${t("wizard.notify.title", { channel: channelName })}
+`));
+  const cfg = loadConfig();
+  const channelConfig = cfg.channel[channelName] || {};
+  const currentTypes = channelConfig.notify_types || [];
+  const selected = await prompts.notifyTypes(currentTypes);
+  if (!state.pendingChanges.channel) state.pendingChanges.channel = {};
+  if (!state.pendingChanges.channel[channelName]) state.pendingChanges.channel[channelName] = {};
+  state.pendingChanges.channel[channelName] = {
+    ...state.pendingChanges.channel[channelName],
+    notify_types: selected
+  };
+  console.log(pc4.green(`
+\u2713 ${t("wizard.notify.saved", { channel: channelName })}
+`));
+  return { action: "next", next: "channel-menu" };
+}
+
+// src/cli/daemon.ts
+import { spawn } from "child_process";
+import { exec } from "child_process";
+import { join as join6, dirname as dirname3 } from "path";
+import { fileURLToPath } from "url";
+import { mkdirSync as mkdirSync4, existsSync as existsSync7 } from "fs";
+
+// src/shared/pidfile.ts
+import { writeFileSync as writeFileSync5, readFileSync as readFileSync6, existsSync as existsSync6, unlinkSync } from "fs";
+function readPidFile(pidFilePath) {
+  if (!existsSync6(pidFilePath)) {
+    return null;
+  }
+  try {
+    const content = readFileSync6(pidFilePath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+function removePidFile(pidFilePath) {
+  if (existsSync6(pidFilePath)) {
+    unlinkSync(pidFilePath);
+  }
+}
+function isProcessRunning(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/cli/daemon.ts
+function isPortInUse(port) {
+  return new Promise((resolve) => {
+    exec(`lsof -i :${port}`, (err) => {
+      resolve(!err);
+    });
+  });
+}
+var DaemonManager = class {
+  pidFilePath;
+  port;
+  lastError;
+  constructor(pidFilePath, port) {
+    this.pidFilePath = pidFilePath;
+    this.port = port;
+  }
+  getPort() {
+    return this.port;
+  }
+  getPidFilePath() {
+    return this.pidFilePath;
+  }
+  getLastError() {
+    return this.lastError;
+  }
+  isRunning() {
+    const data = readPidFile(this.pidFilePath);
+    if (!data) return false;
+    if (!isProcessRunning(data.pid)) {
+      removePidFile(this.pidFilePath);
+      return false;
+    }
+    return true;
+  }
+  async start() {
+    this.lastError = void 0;
+    const existingPidData = readPidFile(this.pidFilePath);
+    if (existingPidData && isProcessRunning(existingPidData.pid)) {
+      if (!existingPidData.token) {
+        console.log(t("daemon.lackingToken"));
+        await this.stop();
+        await this.waitForPortFree();
+      } else {
+        console.log(t("daemon.alreadyRunning"));
+        return true;
+      }
+    }
+    try {
+      const homedir14 = process.env.HOME || process.env.USERPROFILE || "";
+      const logDir = join6(homedir14, ".tabclaw", "logs");
+      mkdirSync4(logDir, { recursive: true });
+      removePidFile(this.pidFilePath);
+      const __dirname3 = dirname3(fileURLToPath(import.meta.url));
+      let daemonScript = join6(__dirname3, "..", "daemon", "process.js");
+      if (!existsSync7(daemonScript)) {
+        daemonScript = join6(__dirname3, "..", "..", "src", "daemon", "process.ts");
+      }
+      if (!existsSync7(daemonScript)) {
+        this.lastError = t("daemon.scriptNotFound", { path: daemonScript });
+        console.error(this.lastError);
+        return false;
+      }
+      const logFile = join6(logDir, "gateway.log");
+      const isDev = daemonScript.endsWith(".ts");
+      const execPath = isDev ? join6(__dirname3, "..", "..", "node_modules", ".bin", "tsx") : process.execPath;
+      const child = spawn(execPath, [daemonScript], {
+        detached: true,
+        stdio: "ignore",
+        env: {
+          ...process.env,
+          TABCLAW_DAEMON: "true",
+          TABCLAW_PORT: String(this.port),
+          TABCLAW_PID_FILE: this.pidFilePath
+        }
+      });
+      child.unref();
+      let pidData = null;
+      for (let i = 0; i < 30; i++) {
+        await new Promise((resolve) => setTimeout(resolve, 1e3));
+        pidData = readPidFile(this.pidFilePath);
+        if (pidData) {
+          if (isProcessRunning(pidData.pid)) {
+            console.log(t("daemon.startedOnPort", { port: this.port }));
+            return true;
+          }
+        }
+      }
+      this.lastError = t("daemon.startFailed");
+      console.error(this.lastError);
+      console.error(t("daemon.checkLogs", { path: logFile }));
+      return false;
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : String(error);
+      this.lastError = t("daemon.startError", { error: errorMsg });
+      console.error(this.lastError);
+      return false;
+    }
+  }
+  async stop() {
+    const data = readPidFile(this.pidFilePath);
+    if (!data) {
+      return true;
+    }
+    try {
+      process.kill(data.pid, "SIGTERM");
+      let attempts = 0;
+      while (isProcessRunning(data.pid) && attempts < 10) {
+        await new Promise((resolve) => setTimeout(resolve, 200));
+        attempts++;
+      }
+      if (isProcessRunning(data.pid)) {
+        process.kill(data.pid, "SIGKILL");
+      }
+      removePidFile(this.pidFilePath);
+      return true;
+    } catch (error) {
+      return false;
+    }
+  }
+  async forceCleanup() {
+    removePidFile(this.pidFilePath);
+  }
+  async waitForPortFree(maxWaitMs = 5e3) {
+    const startTime = Date.now();
+    while (await isPortInUse(this.port)) {
+      if (Date.now() - startTime > maxWaitMs) {
+        console.log(t("daemon.portInUse", { port: this.port, ms: maxWaitMs }));
+        break;
+      }
+      await new Promise((resolve) => setTimeout(resolve, 200));
+    }
+  }
+};
+
+// src/cli/wizard/steps/final.ts
+import { join as join7 } from "path";
+import { homedir as homedir6 } from "os";
+import pc5 from "picocolors";
+import ora3 from "ora";
+async function stepFinal(state) {
+  console.log(pc5.bold(`
+${t("wizard.section.complete")}
+`));
+  if (state.sessionConfigured.size === 0) {
+    console.log(pc5.gray(`  ${t("wizard.final.noItems")}
+`));
+  } else {
+    for (const item of state.sessionConfigured) {
+      const result = state.validationResults.get(item);
+      if (result?.ok) {
+        console.log(pc5.green(`* ${t("wizard.final.itemOk", { item })}`));
+      }
+    }
+    console.log("");
+  }
+  const pidFilePath = join7(homedir6(), ".tabclaw", "tabclaw.pid");
+  const port = loadConfig().general.hook_server_port;
+  const daemon = new DaemonManager(pidFilePath, port);
+  const hasChanges = state.sessionConfigured.size > 0 || Object.keys(state.pendingChanges).length > 0;
+  if (daemon.isRunning()) {
+    if (hasChanges) {
+      console.log(pc5.blue(`i ${t("wizard.final.runningChanges")}
+`));
+      console.log(pc5.yellow(`  ${t("wizard.final.configModified")}
+`));
+      const shouldRestart = await prompts.restartGateway();
+      if (shouldRestart) {
+        const spinner = ora3(t("wizard.final.restarting")).start();
+        await daemon.stop();
+        const started = await daemon.start();
+        if (started) {
+          spinner.succeed(t("wizard.final.restarted"));
+        } else {
+          spinner.fail(t("wizard.final.startFailed", { error: daemon.getLastError() ?? "unknown" }));
+        }
+      } else {
+        console.log(pc5.gray(`  ${t("wizard.final.restartTip")}
+`));
+      }
+    } else {
+      console.log(pc5.blue(`i ${t("wizard.final.running")}
+`));
+      console.log(pc5.green(`  ${t("wizard.final.runningReady")}
+`));
+    }
+  } else {
+    console.log(pc5.blue(`i ${t("wizard.final.notRunning")}
+`));
+    if (hasChanges) {
+      console.log(pc5.yellow(`  ${t("wizard.final.configModifiedStart")}
+`));
+    }
+    const shouldStart = await prompts.restartGateway();
+    if (shouldStart) {
+      const spinner2 = ora3(t("wizard.final.starting")).start();
+      const started = await daemon.start();
+      if (started) {
+        spinner2.succeed(t("wizard.final.started"));
+      } else {
+        spinner2.fail(t("wizard.final.startFailed", { error: daemon.getLastError() ?? "unknown" }));
+      }
+    } else {
+      console.log(pc5.gray(`  ${t("wizard.final.startTip")}
+`));
+    }
+  }
+  console.log(pc5.green(`
+${t("wizard.final.done")}
+`));
+  return { action: "next", next: "done" };
+}
+
+// src/cli/wizard/engine.ts
+var WizardEngine = class {
+  state;
+  applicator;
+  constructor() {
+    const configPath = join8(homedir7(), ".tabclaw", "config.toml");
+    const hasExistingConfig = existsSync8(configPath);
+    this.state = createInitialState(hasExistingConfig);
+    this.applicator = new ConfigApplicator();
+  }
+  async run() {
+    await this.detectAllStatus();
+    while (this.state.current !== "done" && this.state.current !== "quit") {
+      if (this.state.current === "final" && this.hasChanges()) {
+        this.applicator.apply(this.state.pendingChanges);
+      }
+      const result = await this.runStep(this.state.current);
+      if (result.action === "next") {
+        this.state.previous = this.state.current;
+        this.state.current = result.next;
+      } else if (result.action === "back") {
+        this.state.current = this.state.previous || "channel-menu";
+      } else if (result.action === "quit") {
+        this.state.current = "quit";
+      }
+    }
+  }
+  async detectAllStatus() {
+    const claude = detectClaude();
+    this.state.claudeDetection = claude;
+    this.state.itemStatus.set("claude", claude.hooked ? "configured" : "unconfigured");
+    const channelNames = ["logger", "telegram", "feishu"];
+    for (const name of channelNames) {
+      const detection = await detectChannel(name);
+      if (detection.configured) {
+        this.state.itemStatus.set(name, "configured");
+      } else if (detection.error) {
+        this.state.itemStatus.set(name, "error");
+      }
+    }
+  }
+  async runStep(step) {
+    switch (step) {
+      case "cli":
+        return await stepCli(this.state);
+      case "cli-menu":
+        return await stepCliMenu(this.state);
+      case "channel-menu":
+        return await stepChannelMenu(this.state);
+      case "channel-config":
+        return await stepChannelConfig(this.state);
+      case "channel-notify":
+        return await stepChannelNotify(this.state);
+      case "final":
+        return await stepFinal(this.state);
+      default:
+        return { action: "next", next: "done" };
+    }
+  }
+  hasChanges() {
+    return this.state.sessionConfigured.size > 0 || Object.keys(this.state.pendingChanges).length > 0;
+  }
+};
+
+// src/cli/init.ts
+var initCommand = new Command2("init").description("Initialize tabclaw configuration").option("-f, --force", "Force reinitialize (regenerate token)").action(async (options) => {
+  const configPath = join9(homedir8(), ".tabclaw", "config.toml");
+  if (existsSync9(configPath) && !options.force) {
+    const overwrite = await confirm2({
+      message: t("cli.init.configExists"),
+      default: false
+    });
+    if (!overwrite) {
+      console.log(t("cli.init.cancelled"));
+      return;
+    }
+  }
+  const wizard = new WizardEngine();
+  await wizard.run();
+});
+
+// src/cli/logs.ts
+import { Command as Command3 } from "commander";
+import { createReadStream } from "fs";
+import { stat, readFile } from "fs/promises";
+import { homedir as homedir9 } from "os";
+import { join as join10 } from "path";
+import { readdirSync, statSync, existsSync as existsSync10 } from "fs";
+var SESSIONS_DIR = join10(homedir9(), ".tabclaw", "sessions");
+function formatSize(bytes) {
+  if (bytes === 0) return "0B";
+  const units = ["B", "KB", "MB", "GB"];
+  const i = Math.floor(Math.log(bytes) / Math.log(1024));
+  const size = bytes / Math.pow(1024, i);
+  return `${size.toFixed(i === 0 ? 0 : 1)}${units[i]}`;
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function listSessions() {
+  const sessions = [];
+  if (!existsSync10(SESSIONS_DIR)) {
+    return sessions;
+  }
+  const entries = readdirSync(SESSIONS_DIR, { withFileTypes: true });
+  for (const entry of entries) {
+    if (entry.isDirectory() && /^\d{4}-\d{2}-\d{2}$/.test(entry.name)) {
+      const date = entry.name;
+      const dateDir = join10(SESSIONS_DIR, date);
+      const files = readdirSync(dateDir);
+      for (const fileName of files) {
+        if (fileName.endsWith(".jsonl")) {
+          const filePath = join10(dateDir, fileName);
+          const stats = statSync(filePath);
+          const match = fileName.match(/^([^-]+)-(.+)\.jsonl$/);
+          if (match) {
+            const [, agentType, sessionId] = match;
+            sessions.push({
+              sessionId,
+              agentType,
+              date,
+              path: filePath,
+              size: stats.size
+            });
+          }
+        }
+      }
+    }
+  }
+  return sessions.sort((a, b) => {
+    if (a.date !== b.date) {
+      return b.date.localeCompare(a.date);
+    }
+    return a.sessionId.localeCompare(b.sessionId);
+  });
+}
+function findSessionFile(sessionId) {
+  const sessions = listSessions();
+  const match = sessions.find((s) => s.sessionId === sessionId);
+  if (match) return match;
+  const matches = sessions.filter((s) => s.sessionId.includes(sessionId));
+  if (matches.length === 1) {
+    return matches[0];
+  }
+  if (matches.length > 1) {
+    console.error(`Multiple sessions match "${sessionId}":`);
+    for (const s of matches) {
+      console.error(`  - ${s.sessionId} (${s.agentType}, ${s.date})`);
+    }
+    return void 0;
+  }
+  return void 0;
+}
+function printEvent(event) {
+  const timestamp = new Date(event.ts);
+  const timeStr = timestamp.toTimeString().split(" ")[0];
+  const type = event.type || "unknown";
+  const typeStr = type.padEnd(16);
+  let content = "";
+  if (event.tool?.name) {
+    content = `Tool: ${event.tool.name}`;
+  } else if (event.text) {
+    content = event.text;
+  } else if (typeof event.content === "string") {
+    content = event.content;
+  } else {
+    const { ...rest } = event;
+    const keys = Object.keys(rest);
+    if (keys.length > 0) {
+      content = `${keys[0]}: ${JSON.stringify(rest[keys[0]])}`;
+    }
+  }
+  if (content.length > 60) {
+    content = content.substring(0, 57) + "...";
+  }
+  console.log(`[${timeStr}] ${typeStr} ${content}`);
+}
+async function* readEvents(filePath) {
+  if (!existsSync10(filePath)) {
+    return;
+  }
+  const content = await readFile(filePath, "utf-8");
+  const lines = content.trim().split("\n").filter((line) => line.length > 0);
+  for (const line of lines) {
+    try {
+      const event = JSON.parse(line);
+      yield event;
+    } catch {
+      continue;
+    }
+  }
+}
+async function showSessionList() {
+  const sessions = listSessions();
+  if (sessions.length === 0) {
+    console.log("No sessions found.");
+    console.log(`Sessions directory: ${SESSIONS_DIR}`);
+    return;
+  }
+  console.log("Sessions:\n");
+  console.log(`  Agent      Session ID                Date        Size`);
+  console.log(`  ---------  ------------------------  ----------  ------`);
+  for (const session of sessions) {
+    const agentStr = session.agentType.padEnd(9);
+    const sessionStr = session.sessionId.padEnd(24).substring(0, 24);
+    const dateStr = session.date;
+    const sizeStr = formatSize(session.size).padStart(6);
+    console.log(`  ${agentStr}  ${sessionStr}  ${dateStr}  ${sizeStr}`);
+  }
+}
+async function tailSession(sessionId) {
+  const session = findSessionFile(sessionId);
+  if (!session) {
+    console.error(`Session not found: ${sessionId}`);
+    process.exit(1);
+  }
+  console.log(`Tailing session: ${session.sessionId} (${session.agentType})`);
+  console.log(`File: ${session.path}`);
+  console.log("Press Ctrl+C to exit\n");
+  for await (const event of readEvents(session.path)) {
+    printEvent(event);
+  }
+  let lastSize = (await stat(session.path)).size;
+  let running = true;
+  process.on("SIGINT", () => {
+    running = false;
+    console.log("\n");
+    process.exit(0);
+  });
+  while (running) {
+    await sleep(1e3);
+    try {
+      const stats = await stat(session.path);
+      if (stats.size > lastSize) {
+        const stream = createReadStream(session.path, {
+          start: lastSize,
+          encoding: "utf-8"
+        });
+        let newContent = "";
+        stream.on("data", (chunk) => {
+          newContent += chunk;
+        });
+        await new Promise((resolve) => {
+          stream.on("end", () => resolve());
+          stream.on("error", () => resolve());
+        });
+        const lines = newContent.split("\n").filter((line) => line.trim());
+        for (const line of lines) {
+          try {
+            const event = JSON.parse(line);
+            printEvent(event);
+          } catch {
+          }
+        }
+        lastSize = stats.size;
+      }
+    } catch (error) {
+      console.error("\nError reading session file:", error);
+      break;
+    }
+  }
+}
+async function replaySession(sessionId) {
+  const session = findSessionFile(sessionId);
+  if (!session) {
+    console.error(`Session not found: ${sessionId}`);
+    process.exit(1);
+  }
+  console.log(`Replaying session: ${session.sessionId} (${session.agentType})`);
+  console.log(`File: ${session.path}
+`);
+  const events = [];
+  for await (const event of readEvents(session.path)) {
+    events.push(event);
+  }
+  if (events.length === 0) {
+    console.log("No events in session.");
+    return;
+  }
+  let running = true;
+  process.on("SIGINT", () => {
+    running = false;
+    console.log("\nReplay interrupted.");
+    process.exit(0);
+  });
+  let lastTimestamp = null;
+  for (const event of events) {
+    if (!running) break;
+    const currentTimestamp = new Date(event.ts).getTime();
+    if (lastTimestamp !== null) {
+      const delay = currentTimestamp - lastTimestamp;
+      const replayDelay = Math.min(delay, 1e3);
+      if (replayDelay > 0) {
+        await sleep(replayDelay);
+      }
+    }
+    printEvent(event);
+    lastTimestamp = currentTimestamp;
+  }
+  console.log("\nReplay complete.");
+}
+var logsCommand = new Command3("logs").description("View session logs").option("-t, --tail <session>", "Tail a live session").option("-r, --replay <session>", "Replay session with original timing").action(async (options) => {
+  try {
+    if (options.tail) {
+      await tailSession(options.tail);
+    } else if (options.replay) {
+      await replaySession(options.replay);
+    } else {
+      await showSessionList();
+    }
+  } catch (error) {
+    console.error("Failed to read logs:", error);
+    process.exit(1);
+  }
+});
+
+// src/cli/status.ts
+import { Command as Command4 } from "commander";
+import { homedir as homedir10 } from "os";
+import { join as join11 } from "path";
+import { existsSync as existsSync11 } from "fs";
+function getSettingsPath2() {
+  return join11(homedir10(), ".claude", "settings.json");
+}
+var statusCommand = new Command4("status").description("Show current status").action(() => {
+  const config = loadConfig();
+  const pidFilePath = join11(homedir10(), ".tabclaw", "tabclaw.pid");
+  const daemon = new DaemonManager(pidFilePath, config.general.hook_server_port);
+  console.log(`
+${t("status.title")}
+`);
+  console.log(daemon.isRunning() ? t("status.daemon.running") : t("status.daemon.notRunning"));
+  console.log(t("status.port", { port: config.general.hook_server_port }));
+  console.log(`${t("status.logLevel", { level: config.general.log_level })}
+`);
+  console.log(t("status.channels"));
+  console.log(`  ${config.channel.telegram?.enabled ? t("status.telegram.enabled") : t("status.telegram.disabled")}`);
+  console.log(`  ${config.channel.feishu?.enabled ? t("status.feishu.enabled") : t("status.feishu.disabled")}
+`);
+  const settingsPath = getSettingsPath2();
+  const backupPath = settingsPath + ".tabclaw-backup";
+  if (existsSync11(backupPath)) {
+    console.log(t("status.settingsBackup"));
+  } else {
+    console.log(t("status.settingsNoBackup"));
+  }
+  const home = homedir10();
+  console.log(`
+${t("status.paths")}`);
+  console.log(`  ${t("status.pathConfig", { path: `${home}/.tabclaw/config.toml` })}`);
+  console.log(`  ${t("status.pathLogs", { path: `${home}/.tabclaw/logs/gateway.log` })}`);
+  console.log(`  ${t("status.pathBackup", { path: `${home}/.claude/settings.json.tabclaw-backup` })}
+`);
+});
+
+// src/cli/stop.ts
+import { Command as Command5 } from "commander";
+import { homedir as homedir11 } from "os";
+import { join as join12 } from "path";
+var stopCommand = new Command5("stop").description("Stop the tabclaw daemon and restore settings").action(async () => {
+  const config = loadConfig();
+  const pidFilePath = join12(homedir11(), ".tabclaw", "tabclaw.pid");
+  const daemon = new DaemonManager(pidFilePath, config.general.hook_server_port);
+  if (!daemon.isRunning()) {
+    console.log(t("cli.stop.notRunning"));
+  } else {
+    console.log(t("cli.stop.stopping"));
+    const stopped = await daemon.stop();
+    if (stopped) {
+      console.log(t("cli.stop.stopped"));
+    } else {
+      console.error(t("cli.stop.failed"));
+    }
+  }
+});
+
+// src/cli/gateway.ts
+import { Command as Command6 } from "commander";
+import { join as join13 } from "path";
+import { homedir as homedir12 } from "os";
+var PID_FILE = join13(homedir12(), ".tabclaw", "tabclaw.pid");
+var gatewayCommand = new Command6("gateway").description("Manage tabclaw Gateway daemon").addCommand(
+  new Command6("start").description("Start or restart the Gateway daemon").option("-p, --port <port>", "Port to listen on").action(async (options) => {
+    const config = loadConfig();
+    const port = options.port ? parseInt(options.port, 10) : config.general.hook_server_port;
+    const daemon = new DaemonManager(PID_FILE, port);
+    if (daemon.isRunning()) {
+      console.log(t("gateway.stopping"));
+      await daemon.stop();
+    }
+    const started = await daemon.start();
+    if (started) {
+      console.log(t("gateway.startedOnPort", { port }));
+    } else {
+      const error = daemon.getLastError();
+      console.error(t("gateway.startFailed"));
+      if (error) {
+        console.error(t("gateway.error", { error }));
+      }
+      const logPath = join13(homedir12(), ".tabclaw", "logs", "gateway.log");
+      console.error(`  ${t("gateway.checkLogs", { path: logPath })}`);
+      process.exit(1);
+    }
+  })
+).addCommand(
+  new Command6("stop").description("Stop the Gateway daemon").action(async () => {
+    const config = loadConfig();
+    const daemon = new DaemonManager(PID_FILE, config.general.hook_server_port);
+    const stopped = await daemon.stop();
+    if (stopped) {
+      console.log(t("gateway.stopped"));
+    } else {
+      console.error(t("gateway.stopFailed"));
+      process.exit(1);
+    }
+  })
+).addCommand(
+  new Command6("restart").description("Restart the Gateway daemon").option("-p, --port <port>", "Port to listen on").action(async (options) => {
+    const config = loadConfig();
+    const port = options.port ? parseInt(options.port, 10) : config.general.hook_server_port;
+    const daemon = new DaemonManager(PID_FILE, port);
+    await daemon.stop();
+    const started = await daemon.start();
+    if (started) {
+      console.log(t("gateway.restartedOnPort", { port }));
+    } else {
+      const error = daemon.getLastError();
+      console.error(t("gateway.restartFailed"));
+      if (error) {
+        console.error(t("gateway.error", { error }));
+      }
+      const logPath = join13(homedir12(), ".tabclaw", "logs", "gateway.log");
+      console.error(`  ${t("gateway.checkLogs", { path: logPath })}`);
+      process.exit(1);
+    }
+  })
+).addCommand(
+  new Command6("status").description("Check Gateway status").action(async () => {
+    const config = loadConfig();
+    try {
+      const response = await fetch(`http://localhost:${config.general.hook_server_port}/status`);
+      if (response.ok) {
+        const status = await response.json();
+        console.log(t("gateway.status.title"));
+        console.log(`  ${t("gateway.status.running", { value: status.running ?? true })}`);
+        console.log(`  ${t("gateway.status.sessions", { count: status.sessions?.length ?? (typeof status.sessions === "number" ? status.sessions : 0) })}`);
+        console.log(`  ${t("gateway.status.clients", { count: status.clients ?? 0 })}`);
+        if (status.sessions && status.sessions.length > 0) {
+          console.log(`
+  ${t("gateway.status.activeSessions")}`);
+          for (const session of status.sessions) {
+            const agentType = session.agentType || "unknown";
+            const sessionId = session.sessionId || session.id || "unknown";
+            console.log(`    - ${agentType}/${sessionId}`);
+          }
+        }
+      } else {
+        console.log(t("gateway.status.notResponding"));
+      }
+    } catch {
+      console.log(t("gateway.status.notRunning"));
+    }
+  })
+);
+
+// src/cli/debug/index.ts
+import { Command as Command7 } from "commander";
+import { spawn as spawn2 } from "child_process";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { dirname as dirname4, join as join14 } from "path";
+var __filename2 = fileURLToPath2(import.meta.url);
+var __dirname2 = dirname4(__filename2);
+var debugCommand = new Command7("debug").description("Debug tools for TabClaw").addCommand(
+  new Command7("hooks").description("Capture and log raw hook payloads for debugging").option("-p, --port <port>", "Port to listen on", "16792").action(async (options) => {
+    const port = parseInt(options.port, 10);
+    console.log(t("cli.debug.starting", { port }));
+    console.log(t("cli.debug.capturing"));
+    console.log(t("cli.debug.pressCtrlC"));
+    const captureScript = join14(__dirname2, "hook-capture.js");
+    const proc = spawn2("node", [captureScript], {
+      stdio: "inherit",
+      env: { ...process.env, TABCLAW_DEBUG_PORT: String(port) }
+    });
+    proc.on("exit", (code) => {
+      process.exit(code || 0);
+    });
+    process.on("SIGINT", () => {
+      console.log(t("cli.debug.stopping"));
+      proc.kill("SIGINT");
+    });
+  })
+);
+
+// src/cli/agent/claude.ts
+import { spawn as spawn3 } from "child_process";
+import { homedir as homedir13 } from "os";
+import { join as join15, dirname as dirname5 } from "path";
+import { readFileSync as readFileSync7, existsSync as existsSync12, writeFileSync as writeFileSync6, mkdirSync as mkdirSync5 } from "fs";
+function getSettingsPath3() {
+  return join15(homedir13(), ".claude", "settings.json");
+}
+function backupSettings2(settingsPath) {
+  const backupPath = settingsPath + ".tabclaw-backup";
+  if (existsSync12(settingsPath)) {
+    writeFileSync6(backupPath, readFileSync7(settingsPath, "utf-8"));
+  }
+}
+function writeSettings2(settingsPath, settings) {
+  mkdirSync5(dirname5(settingsPath), { recursive: true });
+  writeFileSync6(settingsPath, JSON.stringify(settings, null, 2));
+}
+function generateHooksConfig3(port, token) {
+  const baseUrl = `http://localhost:${port}/hook/${token}`;
+  const createHookEntry = (event) => ({
+    matcher: "",
+    hooks: [{ type: "http", url: `${baseUrl}/${event}` }]
+  });
+  return {
+    Stop: [createHookEntry("Stop")],
+    PostToolUse: [createHookEntry("PostToolUse")],
+    PostToolUseFailure: [createHookEntry("PostToolUseFailure")],
+    Notification: [createHookEntry("Notification")],
+    PreToolUse: [createHookEntry("PreToolUse")],
+    SubagentStart: [createHookEntry("SubagentStart")],
+    SubagentStop: [createHookEntry("SubagentStop")],
+    SessionStart: [createHookEntry("SessionStart")],
+    SessionEnd: [createHookEntry("SessionEnd")],
+    UserPromptSubmit: [createHookEntry("UserPromptSubmit")],
+    PermissionRequest: [createHookEntry("PermissionRequest")]
+  };
+}
+function registerClaudeCommand(program2) {
+  program2.command("claude").description("Start Claude Code with tabclaw integration").option("-d, --directory <dir>", "Working directory for Claude").action(async (options) => {
+    const config = loadConfig();
+    const port = config.general.hook_server_port;
+    const pidFilePath = join15(homedir13(), ".tabclaw", "tabclaw.pid");
+    const daemon = new DaemonManager(pidFilePath, port);
+    let daemonStarted = false;
+    if (daemon.isRunning()) {
+      console.log(t("cli.agent.alreadyRunning"));
+      daemonStarted = true;
+    } else {
+      console.log(t("cli.agent.starting"));
+      daemonStarted = await daemon.start();
+      if (!daemonStarted) {
+        console.error(t("cli.agent.startFailed"));
+        process.exit(1);
+      }
+      console.log(t("cli.agent.started"));
+    }
+    console.log(t("cli.agent.configuring"));
+    const settingsPath = getSettingsPath3();
+    const backupPath = settingsPath + ".tabclaw-backup";
+    if (!existsSync12(backupPath)) {
+      backupSettings2(settingsPath);
+      console.log(t("cli.agent.settingsBacked"));
+    }
+    const pidData = readPidFile(pidFilePath);
+    const token = pidData?.token;
+    if (!token) {
+      console.error(t("cli.agent.tokenNotFound"));
+      process.exit(1);
+    }
+    const hooksConfig = generateHooksConfig3(port, token);
+    let currentSettings = {};
+    if (existsSync12(settingsPath)) {
+      currentSettings = JSON.parse(readFileSync7(settingsPath, "utf-8"));
+    }
+    const mergedSettings = mergeHooks(currentSettings, hooksConfig);
+    writeSettings2(settingsPath, mergedSettings);
+    console.log(t("cli.agent.hooksConfigured"));
+    const workDir = options.directory || process.cwd();
+    console.log(t("cli.agent.startingIn", { dir: workDir }));
+    console.log(t("cli.agent.pressCtrlC") + "\n");
+    const claudeProcess = spawn3("claude", [], {
+      cwd: workDir,
+      stdio: "inherit",
+      shell: true
+    });
+    claudeProcess.on("exit", (code) => {
+      console.log(t("cli.agent.exited", { code }));
+      console.log(t("cli.agent.daemonRunning"));
+      console.log(t("cli.agent.tipStop"));
+      process.exit(code || 0);
+    });
+    process.on("SIGINT", () => {
+      console.log(t("cli.agent.detaching"));
+      claudeProcess.kill("SIGINT");
+    });
+  });
+}
+
+// src/cli/agent/index.ts
+function registerAgentCommands(program2) {
+  registerClaudeCommand(program2);
+}
+
+// src/cli/index.ts
+var program = new Command8();
+program.name("tabclaw").description("Bridge AI programming assistants with messaging platforms").version("0.1.0");
+program.addCommand(attachCommand);
+program.addCommand(debugCommand);
+program.addCommand(initCommand);
+program.addCommand(logsCommand);
+program.addCommand(statusCommand);
+program.addCommand(stopCommand);
+program.addCommand(gatewayCommand);
+registerAgentCommands(program);
+program.parse(process.argv);
+//# sourceMappingURL=index.js.map