handsoff 0.0.1-beta.2 → 0.1.0

package/dist/cli/index.js

@@ -160,8 +160,18 @@ var DEFAULT_CONFIG = {
       permission: {
         lowRiskTools: ["Read", "Glob", "Grep", "List", "WebSearch", "codesearch"]
       }
+    },
+    codex: {
+      enabled: false,
+      command: ["codex", "app-server", "--listen", "stdio://"],
+      work_dir: "",
+      model: "",
+      approval_policy: "",
+      sandbox_mode: ""
     }
-  }
+  },
+  channels: {},
+  bindings: {}
 };
 function getConfigPath() {
   return join2(homedir2(), ".handsoff", "config.toml");
@@ -218,7 +228,31 @@ function mergeWithDefaults(raw) {
           ...DEFAULT_CONFIG.agent.claude.permission,
           ...raw.agent?.claude?.permission || {}
         }
+      },
+      codex: {
+        ...DEFAULT_CONFIG.agent.codex,
+        ...raw.agent?.codex || {},
+        command: raw.agent?.codex?.command ? raw.agent.codex.command : DEFAULT_CONFIG.agent.codex.command,
+        work_dir: raw.agent?.codex?.work_dir || DEFAULT_CONFIG.agent.codex.work_dir,
+        model: raw.agent?.codex?.model || DEFAULT_CONFIG.agent.codex.model,
+        approval_policy: raw.agent?.codex?.approval_policy || DEFAULT_CONFIG.agent.codex.approval_policy,
+        sandbox_mode: raw.agent?.codex?.sandbox_mode || DEFAULT_CONFIG.agent.codex.sandbox_mode
       }
+    },
+    channels: {
+      ...DEFAULT_CONFIG.channels,
+      ...raw.channels || {},
+      app: raw.channels?.app ? {
+        enabled: raw.channels.app.enabled === true,
+        channel_id: String(raw.channels.app.channel_id || ""),
+        auth_token: String(raw.channels.app.auth_token || ""),
+        heartbeat_interval_ms: raw.channels.app.heartbeat_interval_ms ? parseInt(String(raw.channels.app.heartbeat_interval_ms), 10) : void 0,
+        notify_types: Array.isArray(raw.channels.app.notify_types) ? raw.channels.app.notify_types.map(String) : void 0
+      } : DEFAULT_CONFIG.channels?.app
+    },
+    bindings: {
+      ...DEFAULT_CONFIG.bindings,
+      ...raw.bindings || {}
     }
   };
 }
@@ -285,6 +319,17 @@ var en_default = {
         required: "app_id and app_secret are required. Skipping."
       }
     },
+    codex: {
+      enable: "Enable Codex agent integration?",
+      command: "Codex app-server command:",
+      workDir: "Default Codex working directory (optional):",
+      model: "Default Codex model (optional):",
+      approvalPolicy: "Default Codex approval policy (optional):",
+      detected: "Codex CLI detected.",
+      notDetected: "Codex CLI not found in PATH.",
+      enabled: "Codex integration enabled.",
+      disabled: "Codex integration disabled."
+    },
     notify: {
       title: "Notification types for {{channel}}",
       checkbox: "Notification types:",
@@ -415,6 +460,24 @@ var en_default = {
       tipStop: 'Use "handsoff stop" to stop the daemon and restore settings',
       detaching: "\nDetaching from Claude..."
     },
+    codex: {
+      notInstalled: "Codex CLI is not installed",
+      installMethods: "Please install Codex CLI using one of these methods:",
+      option1npm: "Option 1 - npm (recommended): npm install -g @openai/codex",
+      option2brew: "Option 2 - Homebrew (macOS): brew install --cask codex",
+      alternative: "Alternatively, use Claude Code: handsoff claude",
+      alreadyRunning: "Handsoff daemon is already running",
+      starting: "Starting handsoff daemon...",
+      started: "Daemon started",
+      startFailed: "Failed to start daemon",
+      notEnabled: "Codex adapter is not enabled in handsoff config.",
+      enableHint: 'Enable it with "handsoff init" or by setting agent.codex.enabled = true in ~/.handsoff/config.toml, then restart the daemon.',
+      startingIn: "Starting Codex CLI {{version}} in {{dir}}",
+      pressCtrlC: "Press Ctrl+C to stop (handsoff daemon will keep running)",
+      exited: "\nCodex CLI exited with code {{code}}",
+      daemonRunning: "Handsoff daemon is still running in the background",
+      detaching: "\nDetaching from Codex..."
+    },
     debug: {
       starting: "Starting hook debug server on port {{port}}",
       capturing: "This will capture all incoming webhook requests...",
@@ -565,9 +628,10 @@ import { homedir as homedir7 } from "os";
 // src/cli/wizard/state.ts
 function createInitialState(hasExistingConfig) {
   return {
-    current: "cli-menu",
+    current: "agent-select",
     hasExistingConfig,
     pendingChanges: {},
+    bindings: {},
     itemStatus: /* @__PURE__ */ new Map(),
     sessionConfigured: /* @__PURE__ */ new Set(),
     validationResults: /* @__PURE__ */ new Map()
@@ -580,24 +644,42 @@ import { join as join4 } from "path";
 import { homedir as homedir4 } from "os";
 import TOML2 from "@iarna/toml";
 var ConfigApplicator = class {
-  apply(pending) {
+  apply(pending, bindings) {
     const current = loadConfig();
     const merged = {
       ...current,
       general: { ...current.general },
       channel: {
         ...current.channel,
-        ...pending.channel || {}
+        logger: pending.channel?.logger ? { ...current.channel?.logger ?? {}, ...pending.channel.logger } : current.channel?.logger,
+        telegram: pending.channel?.telegram ? { ...current.channel?.telegram ?? {}, ...pending.channel.telegram } : current.channel?.telegram,
+        feishu: pending.channel?.feishu ? { ...current.channel?.feishu ?? {}, ...pending.channel.feishu } : current.channel?.feishu,
+        permission: pending.channel?.permission ? { ...current.channel?.permission ?? {}, ...pending.channel.permission } : current.channel?.permission
       },
       agent: {
         ...current.agent,
-        ...pending.agent ? { claude: { ...current.agent?.claude ?? {}, ...pending.agent } } : {}
+        ...pending.agent?.claude ? {
+          claude: { ...current.agent?.claude ?? {}, ...pending.agent.claude }
+        } : {},
+        ...pending.agent?.codex ? {
+          codex: { ...current.agent?.codex ?? {}, ...pending.agent.codex }
+        } : {}
       }
     };
+    let finalConfig = merged;
+    if (bindings && Object.keys(bindings).length > 0) {
+      finalConfig = {
+        ...merged,
+        bindings: {
+          ...merged.bindings || {},
+          ...bindings
+        }
+      };
+    }
     const configDir = join4(homedir4(), ".handsoff");
     mkdirSync3(configDir, { recursive: true });
     const configPath = join4(configDir, "config.toml");
-    const content = TOML2.stringify(merged);
+    const content = TOML2.stringify(finalConfig);
     writeFileSync3(configPath, content);
   }
 };
@@ -695,6 +777,34 @@ function extractHandsoffHookInfo(entry) {
   return { isHandsoff: false };
 }
 
+// src/cli/wizard/detectors/codex.ts
+import { execSync as execSync2 } from "child_process";
+function detectCodex() {
+  let binaryPath;
+  let installed = false;
+  let version;
+  try {
+    binaryPath = execSync2("which codex", { encoding: "utf-8" }).trim();
+    installed = !!binaryPath;
+    version = execSync2("codex --version", { encoding: "utf-8", stdio: "pipe" }).trim();
+  } catch {
+  }
+  if (!installed) {
+    return {
+      supported: false,
+      installed: false,
+      message: "Codex CLI not found in PATH. Please install Codex CLI first."
+    };
+  }
+  return {
+    supported: true,
+    installed: true,
+    message: `Codex CLI ${version} detected.`,
+    binaryPath,
+    version
+  };
+}
+
 // src/cli/wizard/prompts.ts
 import { confirm, input, checkbox, select } from "@inquirer/prompts";
 var prompts = {
@@ -710,6 +820,26 @@ var prompts = {
     message: t("wizard.channel.feishu.allowedUsers"),
     default: current || ""
   }),
+  codexEnable: (enabled) => confirm({
+    message: t("wizard.codex.enable"),
+    default: enabled
+  }),
+  codexCommand: (current) => input({
+    message: t("wizard.codex.command"),
+    default: current || "codex app-server --listen stdio://"
+  }),
+  codexWorkDir: (current) => input({
+    message: t("wizard.codex.workDir"),
+    default: current || ""
+  }),
+  codexModel: (current) => input({
+    message: t("wizard.codex.model"),
+    default: current || ""
+  }),
+  codexApprovalPolicy: (current) => input({
+    message: t("wizard.codex.approvalPolicy"),
+    default: current || ""
+  }),
   cliActionSelect: (hooked) => select({
     message: t("wizard.cli.actionQuestion"),
     choices: hooked ? [
@@ -774,6 +904,32 @@ var prompts = {
   restartGateway: () => confirm({
     message: t("wizard.menu.restartQuestion"),
     default: true
+  }),
+  bindingAgentSelect: (agents) => select({
+    message: "Select an agent to bind:",
+    choices: agents.map((a) => ({ name: a.name, value: a.value }))
+  }),
+  bindingConfirm: (agentName, channelName) => select({
+    message: `\u{1F916} Bind ${agentName} to ${channelName} \u2014 confirm?`,
+    choices: [
+      { name: "Confirm binding", value: "confirm" },
+      { name: "Cancel", value: "cancel" }
+    ]
+  }),
+  pairContinue: () => select({
+    message: "Add another pair?",
+    choices: [
+      { name: "Add another pair", value: "continue" },
+      { name: "Finish setup", value: "finish" }
+    ]
+  }),
+  agentSelect: (agents) => select({
+    message: "Select an agent to configure:",
+    choices: agents.map((a) => ({ name: `${a.name}  ${a.status}`, value: a.value }))
+  }),
+  channelSelect: (channels) => select({
+    message: "Select a channel to configure:",
+    choices: channels.map((c) => ({ name: `${c.name}  ${c.status}`, value: c.value }))
   })
 };
 
@@ -782,10 +938,13 @@ import { writeFileSync as writeFileSync4, existsSync as existsSync5, readFileSyn
 import { dirname as dirname3 } from "path";
 import pc from "picocolors";
 import ora from "ora";
+var STEP = "STEP 2";
 async function stepCli(state) {
   const cliName = state.currentCliName || "claude";
   console.log(pc.bold(`
-${t("wizard.section.cli")}
+${STEP} \u2014 Configure Agent
+`));
+  console.log(pc.gray(`${"\u2500".repeat(50)}
 `));
   if (cliName === "claude") {
     const detection = state.claudeDetection ?? detectClaude();
@@ -825,16 +984,77 @@ ${t("wizard.section.cli")}
       spinner.succeed(t("wizard.cli.injected"));
       state.itemStatus.set("claude", "configured");
       state.sessionConfigured.add("claude");
-      state.pendingChanges.agent = { adapter: "hooks" };
+      state.pendingChanges.agent = {
+        ...state.pendingChanges.agent || {},
+        claude: { adapter: "hooks" }
+      };
       state.validationResults.set("claude", { ok: true });
+      return { action: "next", next: "channel-select" };
     } 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) });
     }
   }
+  if (cliName === "codex") {
+    const detection = state.codexDetection ?? detectCodex();
+    const config = loadConfig();
+    const current = config.agent.codex;
+    if (!detection.installed) {
+      console.log(pc.yellow(`! ${t("wizard.codex.notDetected")}`));
+      console.log(pc.gray(`  ${detection.message}
+`));
+      state.itemStatus.set("codex", "not-found");
+      state.validationResults.set("codex", { ok: false, message: detection.message });
+      return { action: "next", next: "cli-menu" };
+    }
+    console.log(pc.green(`* ${t("wizard.codex.detected")}`));
+    console.log(pc.gray(`  Binary: ${detection.binaryPath}`));
+    console.log(pc.gray(`  Version: ${detection.version || "unknown"}`));
+    console.log("");
+    const enabled = await prompts.codexEnable(current?.enabled === true);
+    if (!enabled) {
+      state.pendingChanges.agent = {
+        ...state.pendingChanges.agent || {},
+        codex: {
+          ...current || {},
+          enabled: false
+        }
+      };
+      state.itemStatus.set("codex", "unconfigured");
+      state.validationResults.set("codex", { ok: true, message: t("wizard.codex.disabled") });
+      console.log(pc.gray(`  ${t("wizard.codex.disabled")}
+`));
+      return { action: "next", next: "cli-menu" };
+    }
+    const commandInput = await prompts.codexCommand((current?.command || []).join(" "));
+    const workDir = await prompts.codexWorkDir(current?.work_dir || "");
+    const model = await prompts.codexModel(current?.model || "");
+    const approvalPolicy = await prompts.codexApprovalPolicy(current?.approval_policy || "");
+    state.pendingChanges.agent = {
+      ...state.pendingChanges.agent || {},
+      codex: {
+        ...current || {},
+        enabled: true,
+        command: parseCommandInput(commandInput),
+        work_dir: workDir,
+        model,
+        approval_policy: approvalPolicy
+      }
+    };
+    state.itemStatus.set("codex", "configured");
+    state.sessionConfigured.add("codex");
+    state.validationResults.set("codex", { ok: true, message: t("wizard.codex.enabled") });
+    console.log(pc.green(`  ${t("wizard.codex.enabled")}
+`));
+    return { action: "next", next: "channel-select" };
+  }
   return { action: "next", next: "cli-menu" };
 }
+function parseCommandInput(input2) {
+  const tokens = input2.trim().split(/\s+/).filter(Boolean);
+  return tokens.length > 0 ? tokens : ["codex", "app-server", "--listen", "stdio://"];
+}
 function injectClaudeHooks(settingsPath, events) {
   const port = loadConfig().general.hook_server_port;
   const token = getOrCreateHookToken();
@@ -908,6 +1128,10 @@ function getChannelStatusLabel(status, error) {
   switch (status) {
     case "configured":
       return "[done]";
+    case "detected":
+      return "[detected]";
+    case "not-found":
+      return "[not found]";
     case "error":
       return `[error]${error ? ` (${error})` : ""}`;
     default:
@@ -917,39 +1141,22 @@ function getChannelStatusLabel(status, error) {
 
 // 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";
-  let label = getChannelStatusLabel(cliStatus);
+  const claudeStatus = state.itemStatus.get("claude") || "unconfigured";
+  let claudeLabel = getChannelStatusLabel(claudeStatus);
   if (state.claudeDetection?.tokenMismatch) {
-    label = pc2.yellow("[update needed]");
-  }
-  const choice = await prompts.channelMenuSelect([{
-    name: "claude",
-    status: label
-  }]);
+    claudeLabel = pc2.yellow("[update needed]");
+  }
+  const codexStatus = state.itemStatus.get("codex") || "not-found";
+  const codexLabel = getChannelStatusLabel(codexStatus, state.validationResults.get("codex")?.message);
+  const cliOptions = [
+    { name: "claude", status: claudeLabel },
+    { name: "codex", status: codexLabel }
+  ];
+  const choice = await prompts.channelMenuSelect(cliOptions);
   if (choice === "__next__") {
     return { action: "next", next: "channel-menu" };
   }
@@ -960,10 +1167,13 @@ ${t("wizard.section.cli")}
 // src/cli/wizard/steps/channel-config.ts
 import pc3 from "picocolors";
 import ora2 from "ora";
+var STEP2 = "STEP 4";
 async function stepChannelConfig(state) {
   const channelName = state.currentChannelName || "telegram";
   console.log(pc3.bold(`
-${t("wizard.channel.configuring", { channel: channelName })}
+${STEP2} \u2014 Configure Channel
+`));
+  console.log(pc3.gray(`${"\u2500".repeat(50)}
 `));
   while (true) {
     const cfg = loadConfig();
@@ -995,7 +1205,7 @@ ${t("wizard.channel.configuring", { channel: channelName })}
           continue;
         }
         state.itemStatus.set(channelName, "unconfigured");
-        return { action: "next", next: "channel-menu" };
+        return { action: "next", next: "channel-select" };
       }
       const msgSpinner = ora2(t("wizard.channel.telegram.sendingTest")).start();
       try {
@@ -1016,7 +1226,7 @@ ${t("wizard.channel.configuring", { channel: channelName })}
       state.itemStatus.set("telegram", "configured");
       state.sessionConfigured.add("telegram");
       state.validationResults.set("telegram", { ok: true });
-      return { action: "next", next: "channel-notify" };
+      return { action: "next", next: "binding-confirm" };
     }
     if (channelName === "logger") {
       state.pendingChanges.channel = {
@@ -1025,7 +1235,7 @@ ${t("wizard.channel.configuring", { channel: channelName })}
       };
       state.itemStatus.set("logger", "configured");
       state.sessionConfigured.add("logger");
-      return { action: "next", next: "channel-notify" };
+      return { action: "next", next: "binding-confirm" };
     }
     if (channelName === "feishu") {
       const appId = await prompts.feishuAppId(String(currentConfig.app_id || ""));
@@ -1035,7 +1245,7 @@ ${t("wizard.channel.configuring", { channel: channelName })}
         console.log(pc3.yellow(`! ${t("wizard.channel.feishu.required")}
 `));
         state.itemStatus.set("feishu", "unconfigured");
-        return { action: "next", next: "channel-menu" };
+        return { action: "next", next: "channel-select" };
       }
       const allowedUsers = allowedUsersInput.split(",").map((s) => s.trim()).filter((s) => s.length > 0);
       state.pendingChanges.channel = {
@@ -1044,9 +1254,9 @@ ${t("wizard.channel.configuring", { channel: channelName })}
       };
       state.itemStatus.set("feishu", "configured");
       state.sessionConfigured.add("feishu");
-      return { action: "next", next: "channel-notify" };
+      return { action: "next", next: "binding-confirm" };
     }
-    return { action: "next", next: "channel-menu" };
+    return { action: "next", next: "agent-select" };
   }
 }
 
@@ -1073,6 +1283,167 @@ ${t("wizard.notify.title", { channel: channelName })}
   return { action: "next", next: "channel-menu" };
 }
 
+// src/cli/wizard/steps/agent-select.ts
+import pc5 from "picocolors";
+var STEP3 = "STEP 1";
+async function stepAgentSelect(state) {
+  console.log(pc5.bold(`
+${STEP3} \u2014 Select Agent
+`));
+  console.log(pc5.gray(`${"\u2500".repeat(50)}
+`));
+  const config = loadConfig();
+  const currentBindings = config.bindings ?? {};
+  const agents = [];
+  const claudeConfigured = !!config.agent.claude;
+  const claudeBoundTo = currentBindings["claude"];
+  const claudeStatus = claudeBoundTo ? pc5.green(`[bound to ${claudeBoundTo}]`) : claudeConfigured ? pc5.green("[configured]") : pc5.gray("[not configured]");
+  agents.push({ name: "claude", value: "claude", status: claudeStatus });
+  const codexDetection = detectCodex();
+  const codexConfigured = !!config.agent.codex?.enabled;
+  const codexBoundTo = currentBindings["codex"];
+  const codexStatus = codexBoundTo ? pc5.green(`[bound to ${codexBoundTo}]`) : codexConfigured ? pc5.green("[configured]") : codexDetection.installed ? pc5.gray("[not configured]") : pc5.red("[not installed]");
+  agents.push({ name: "codex", value: "codex", status: codexStatus });
+  const choice = await prompts.agentSelect(agents);
+  state.currentAgentName = choice;
+  state.currentCliName = choice;
+  const result = await stepCli(state);
+  if (result.action === "back") {
+    return { action: "next", next: "pair-continue" };
+  }
+  if (result.next === "cli-menu") {
+    return { action: "next", next: "agent-select" };
+  }
+  return { action: "next", next: "channel-select" };
+}
+
+// src/shared/channelInstance.ts
+import { createHash } from "crypto";
+function getChannelInstanceId(channelType, credential) {
+  const hash = createHash("sha256").update(credential).digest("hex").slice(0, 12);
+  return `${channelType}:${hash}`;
+}
+
+// src/cli/wizard/steps/channel-select.ts
+import pc6 from "picocolors";
+var STEP4 = "STEP 3";
+async function stepChannelSelect(state) {
+  console.log(pc6.bold(`
+${STEP4} \u2014 Select Channel
+`));
+  console.log(pc6.gray(`${"\u2500".repeat(50)}
+`));
+  const config = loadConfig();
+  const currentBindings = config.bindings ?? {};
+  const pendingChannels = state.pendingChanges.channel ?? {};
+  const mergedTelegram = pendingChannels.telegram ? { ...config.channel.telegram, ...pendingChannels.telegram } : config.channel.telegram;
+  const mergedFeishu = pendingChannels.feishu ? { ...config.channel.feishu, ...pendingChannels.feishu } : config.channel.feishu;
+  const mergedLogger = pendingChannels.logger ? { ...config.channel.logger, ...pendingChannels.logger } : config.channel.logger;
+  const channels = [];
+  const loggerEnabled = mergedLogger?.enabled === true;
+  const loggerInstanceId = "logger:default";
+  const loggerBoundAgent = Object.entries(currentBindings).find(([, v]) => v === loggerInstanceId)?.[0];
+  const loggerStatus = loggerBoundAgent ? pc6.green(`[bound to ${loggerBoundAgent}]`) : loggerEnabled ? pc6.green("[configured]") : pc6.gray("[not configured]");
+  channels.push({ name: "logger", value: "logger", status: loggerStatus });
+  if (mergedTelegram?.enabled && mergedTelegram.bot_token) {
+    const instanceId = getChannelInstanceId("telegram", mergedTelegram.bot_token);
+    const boundAgent = Object.entries(currentBindings).find(([, v]) => v === instanceId)?.[0];
+    const status = boundAgent ? pc6.green(`[bound to ${boundAgent}]`) : pc6.green("[configured]");
+    channels.push({ name: "telegram", value: "telegram", status });
+  } else {
+    channels.push({ name: "telegram", value: "telegram", status: pc6.gray("[not configured]") });
+  }
+  if (mergedFeishu?.enabled && mergedFeishu.app_id) {
+    const instanceId = getChannelInstanceId("feishu", mergedFeishu.app_id);
+    const boundAgent = Object.entries(currentBindings).find(([, v]) => v === instanceId)?.[0];
+    const status = boundAgent ? pc6.green(`[bound to ${boundAgent}]`) : pc6.green("[configured]");
+    channels.push({ name: "feishu", value: "feishu", status });
+  } else {
+    channels.push({ name: "feishu", value: "feishu", status: pc6.gray("[not configured]") });
+  }
+  const choice = await prompts.channelSelect(channels);
+  state.currentChannelName = choice;
+  const result = await stepChannelConfig(state);
+  if (result.action === "back") {
+    return { action: "next", next: "agent-select" };
+  }
+  return { action: "next", next: "binding-confirm" };
+}
+
+// src/cli/wizard/steps/binding-confirm.ts
+import pc7 from "picocolors";
+var STEP5 = "STEP 5";
+async function stepBindingConfirm(state) {
+  const agentName = state.currentAgentName;
+  const channelName = state.currentChannelName;
+  console.log(pc7.bold(`
+${STEP5} \u2014 Confirm Binding
+`));
+  console.log(pc7.gray(`${"\u2500".repeat(50)}
+`));
+  const config = loadConfig();
+  const currentBindings = { ...config.bindings ?? {} };
+  for (const [a, cid] of Object.entries(state.bindings)) {
+    if (cid) currentBindings[a] = cid;
+  }
+  const pendingChannel = state.pendingChanges.channel?.[channelName];
+  const telegramConfig = pendingChannel && channelName === "telegram" ? { ...config.channel.telegram, ...pendingChannel } : config.channel.telegram;
+  const feishuConfig = pendingChannel && channelName === "feishu" ? { ...config.channel.feishu, ...pendingChannel } : config.channel.feishu;
+  const agentCurrentChannel = currentBindings[agentName];
+  let channelCurrentAgent;
+  let instanceId;
+  if (channelName === "telegram" && telegramConfig?.bot_token) {
+    instanceId = getChannelInstanceId("telegram", telegramConfig.bot_token);
+    channelCurrentAgent = Object.entries(currentBindings).find(([, v]) => v === instanceId)?.[0];
+  } else if (channelName === "feishu" && feishuConfig?.app_id) {
+    instanceId = getChannelInstanceId("feishu", feishuConfig.app_id);
+    channelCurrentAgent = Object.entries(currentBindings).find(([, v]) => v === instanceId)?.[0];
+  } else if (channelName === "logger") {
+    instanceId = "logger:default";
+    channelCurrentAgent = Object.entries(currentBindings).find(([, v]) => v === instanceId)?.[0];
+  }
+  console.log(`  ${pc7.cyan(agentName)} current binding: ${agentCurrentChannel ? pc7.yellow(agentCurrentChannel) : pc7.gray("none")}`);
+  console.log(`  ${pc7.cyan(channelName)} current binding: ${channelCurrentAgent ? pc7.yellow(channelCurrentAgent) : pc7.gray("none")}`);
+  console.log("");
+  const choice = await prompts.bindingConfirm(agentName, channelName);
+  if (choice === "confirm" && instanceId) {
+    const oldChannelId = currentBindings[agentName];
+    for (const [a, cid] of Object.entries(currentBindings)) {
+      if (cid === instanceId && a !== agentName) {
+        delete state.bindings[a];
+      }
+    }
+    if (oldChannelId && oldChannelId !== instanceId) {
+      console.log(pc7.yellow(`  \u26A0 ${agentName} migrated from ${oldChannelId} to ${instanceId}`));
+    }
+    state.bindings[agentName] = instanceId;
+    state.sessionConfigured.add(`binding:${agentName}`);
+    console.log(pc7.green(`  \u2713 ${agentName} bound to ${channelName}`));
+  } else {
+    console.log(pc7.gray(`  Binding cancelled`));
+  }
+  console.log("");
+  return { action: "next", next: "pair-continue" };
+}
+
+// src/cli/wizard/steps/pair-continue.ts
+import pc8 from "picocolors";
+var STEP6 = "STEP 6";
+async function stepPairContinue(state) {
+  console.log(pc8.bold(`
+${STEP6} \u2014 Add Another Pair?
+`));
+  console.log(pc8.gray(`${"\u2500".repeat(50)}
+`));
+  const choice = await prompts.pairContinue();
+  if (choice === "continue") {
+    state.currentAgentName = void 0;
+    state.currentChannelName = void 0;
+    return { action: "next", next: "agent-select" };
+  }
+  return { action: "next", next: "final" };
+}
+
 // src/cli/daemon.ts
 import { spawn } from "child_process";
 import { exec } from "child_process";
@@ -1155,14 +1526,14 @@ var DaemonManager = class {
       }
     }
     try {
-      const homedir14 = process.env.HOME || process.env.USERPROFILE || "";
-      const logDir = join6(homedir14, ".handsoff", "logs");
+      const homedir15 = process.env.HOME || process.env.USERPROFILE || "";
+      const logDir = join6(homedir15, ".handsoff", "logs");
       mkdirSync5(logDir, { recursive: true });
       removePidFile(this.pidFilePath);
       const __dirname3 = dirname4(fileURLToPath(import.meta.url));
-      let daemonScript = join6(__dirname3, "..", "daemon", "process.js");
+      let daemonScript = join6(__dirname3, "..", "gateway", "process.js");
       if (!existsSync7(daemonScript)) {
-        daemonScript = join6(__dirname3, "..", "..", "src", "daemon", "process.ts");
+        daemonScript = join6(__dirname3, "..", "..", "src", "gateway", "process.ts");
       }
       if (!existsSync7(daemonScript)) {
         this.lastError = t("daemon.scriptNotFound", { path: daemonScript });
@@ -1244,20 +1615,20 @@ var DaemonManager = class {
 // src/cli/wizard/steps/final.ts
 import { join as join7 } from "path";
 import { homedir as homedir6 } from "os";
-import pc5 from "picocolors";
+import pc9 from "picocolors";
 import ora3 from "ora";
 async function stepFinal(state) {
-  console.log(pc5.bold(`
+  console.log(pc9.bold(`
 ${t("wizard.section.complete")}
 `));
   if (state.sessionConfigured.size === 0) {
-    console.log(pc5.gray(`  ${t("wizard.final.noItems")}
+    console.log(pc9.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(pc9.green(`* ${t("wizard.final.itemOk", { item })}`));
       }
     }
     console.log("");
@@ -1265,12 +1636,12 @@ ${t("wizard.section.complete")}
   const pidFilePath = join7(homedir6(), ".handsoff", "handsoff.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;
+  const hasChanges = state.sessionConfigured.size > 0 || Object.keys(state.pendingChanges).length > 0 || Object.keys(state.bindings).length > 0;
   if (daemon.isRunning()) {
     if (hasChanges) {
-      console.log(pc5.blue(`i ${t("wizard.final.runningChanges")}
+      console.log(pc9.blue(`i ${t("wizard.final.runningChanges")}
 `));
-      console.log(pc5.yellow(`  ${t("wizard.final.configModified")}
+      console.log(pc9.yellow(`  ${t("wizard.final.configModified")}
 `));
       const shouldRestart = await prompts.restartGateway();
       if (shouldRestart) {
@@ -1283,20 +1654,20 @@ ${t("wizard.section.complete")}
           spinner.fail(t("wizard.final.startFailed", { error: daemon.getLastError() ?? "unknown" }));
         }
       } else {
-        console.log(pc5.gray(`  ${t("wizard.final.restartTip")}
+        console.log(pc9.gray(`  ${t("wizard.final.restartTip")}
 `));
       }
     } else {
-      console.log(pc5.blue(`i ${t("wizard.final.running")}
+      console.log(pc9.blue(`i ${t("wizard.final.running")}
 `));
-      console.log(pc5.green(`  ${t("wizard.final.runningReady")}
+      console.log(pc9.green(`  ${t("wizard.final.runningReady")}
 `));
     }
   } else {
-    console.log(pc5.blue(`i ${t("wizard.final.notRunning")}
+    console.log(pc9.blue(`i ${t("wizard.final.notRunning")}
 `));
     if (hasChanges) {
-      console.log(pc5.yellow(`  ${t("wizard.final.configModifiedStart")}
+      console.log(pc9.yellow(`  ${t("wizard.final.configModifiedStart")}
 `));
     }
     const shouldStart = await prompts.restartGateway();
@@ -1309,11 +1680,11 @@ ${t("wizard.section.complete")}
         spinner2.fail(t("wizard.final.startFailed", { error: daemon.getLastError() ?? "unknown" }));
       }
     } else {
-      console.log(pc5.gray(`  ${t("wizard.final.startTip")}
+      console.log(pc9.gray(`  ${t("wizard.final.startTip")}
 `));
     }
   }
-  console.log(pc5.green(`
+  console.log(pc9.green(`
 ${t("wizard.final.done")}
 `));
   return { action: "next", next: "done" };
@@ -1333,23 +1704,30 @@ var WizardEngine = class {
     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);
+        this.applicator.apply(this.state.pendingChanges, this.state.bindings);
       }
       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";
+        this.state.current = this.state.previous || "agent-select";
       } else if (result.action === "quit") {
         this.state.current = "quit";
       }
     }
   }
   async detectAllStatus() {
+    const config = loadConfig();
     const claude = detectClaude();
     this.state.claudeDetection = claude;
     this.state.itemStatus.set("claude", claude.hooked ? "configured" : "unconfigured");
+    const codex = detectCodex();
+    this.state.codexDetection = codex;
+    this.state.itemStatus.set(
+      "codex",
+      config.agent.codex?.enabled ? "configured" : codex.installed ? "detected" : "not-found"
+    );
     const channelNames = ["logger", "telegram", "feishu"];
     for (const name of channelNames) {
       const detection = await detectChannel(name);
@@ -1362,12 +1740,18 @@ var WizardEngine = class {
   }
   async runStep(step) {
     switch (step) {
+      case "agent-select":
+        return await stepAgentSelect(this.state);
+      case "channel-select":
+        return await stepChannelSelect(this.state);
+      case "binding-confirm":
+        return await stepBindingConfirm(this.state);
+      case "pair-continue":
+        return await stepPairContinue(this.state);
       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":
@@ -1379,7 +1763,7 @@ var WizardEngine = class {
     }
   }
   hasChanges() {
-    return this.state.sessionConfigured.size > 0 || Object.keys(this.state.pendingChanges).length > 0;
+    return this.state.sessionConfigured.size > 0 || Object.keys(this.state.pendingChanges).length > 0 || Object.keys(this.state.bindings).length > 0;
   }
 };
 
@@ -1921,9 +2305,170 @@ function registerClaudeCommand(program2) {
   });
 }
 
+// src/cli/agent/codex.ts
+import { spawn as spawn4 } from "child_process";
+import { homedir as homedir14 } from "os";
+import { join as join16 } from "path";
+import { execSync as execSync3 } from "child_process";
+
+// src/shared/logger.ts
+import pino from "pino";
+import { mkdirSync as mkdirSync7, existsSync as existsSync13, appendFileSync } from "fs";
+import { dirname as dirname7 } from "path";
+import { hostname } from "os";
+var LOG_LEVEL_MAP = {
+  debug: 20,
+  info: 30,
+  warn: 40,
+  error: 50
+};
+var currentLogLevel = "info" /* INFO */;
+function createSyncLogger(logFilePath, minLevel = "info" /* INFO */) {
+  const hostnameValue = hostname();
+  const writeLog = (level, msg, obj) => {
+    try {
+      const logDir = dirname7(logFilePath);
+      if (!existsSync13(logDir)) {
+        mkdirSync7(logDir, { recursive: true });
+      }
+      const logEntry = {
+        level,
+        time: Date.now(),
+        msg,
+        pid: process.pid,
+        hostname: hostnameValue,
+        ...obj
+      };
+      const line = JSON.stringify(logEntry) + "\n";
+      appendFileSync(logFilePath, line);
+    } catch (err) {
+      console.error(`[Logger] Failed to write to ${logFilePath}:`, err);
+    }
+  };
+  const log = (logLevel) => {
+    const minLevelNum = LOG_LEVEL_MAP[minLevel] ?? LOG_LEVEL_MAP.info;
+    const callLevelNum = LOG_LEVEL_MAP[logLevel] ?? LOG_LEVEL_MAP.info;
+    return (obj, msg) => {
+      if (callLevelNum < minLevelNum) return;
+      if (typeof obj === "string") {
+        writeLog(logLevel, obj);
+      } else {
+        writeLog(logLevel, msg || "", obj);
+      }
+    };
+  };
+  const createChild = (_bindings) => {
+    return {
+      info: log("info"),
+      warn: log("warn"),
+      error: log("error"),
+      debug: log("debug"),
+      child: createChild,
+      level: "debug",
+      levels: LOG_LEVEL_MAP
+    };
+  };
+  return {
+    info: log("info"),
+    warn: log("warn"),
+    error: log("error"),
+    debug: log("debug"),
+    child: createChild,
+    level: "debug",
+    levels: LOG_LEVEL_MAP
+  };
+}
+function createAgentLogger(agentType) {
+  const homedir15 = process.env.HOME || process.env.USERPROFILE || "";
+  const logFile = `${homedir15}/.handsoff/logs/agents/${agentType}.log`;
+  return createSyncLogger(logFile, currentLogLevel);
+}
+
+// src/cli/agent/codex.ts
+function isCodexInstalled() {
+  try {
+    execSync3("codex --version", { encoding: "utf8", stdio: "pipe", windowsHide: true });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function getCodexVersion() {
+  try {
+    return execSync3("codex --version", { encoding: "utf8", stdio: "pipe", windowsHide: true }).trim();
+  } catch {
+    return void 0;
+  }
+}
+function registerCodexCommand(program2) {
+  program2.command("codex").description("Start Codex CLI with handsoff integration").option("-d, --directory <dir>", "Working directory for Codex").action(async (options) => {
+    const version = getCodexVersion();
+    if (!isCodexInstalled()) {
+      console.error("\n" + t("cli.codex.notInstalled") + "\n");
+      console.error(t("cli.codex.installMethods") + "\n");
+      console.error(t("cli.codex.option1npm") + "\n");
+      console.error(t("cli.codex.option2brew") + "\n");
+      console.error(t("cli.codex.alternative") + "\n");
+      process.exit(1);
+    }
+    const config = loadConfig();
+    const port = config.general.hook_server_port;
+    const pidFilePath = join16(homedir14(), ".handsoff", "handsoff.pid");
+    const daemon = new DaemonManager(pidFilePath, port);
+    let daemonStarted = false;
+    if (daemon.isRunning()) {
+      console.log(t("cli.codex.alreadyRunning"));
+      daemonStarted = true;
+    } else {
+      console.log(t("cli.codex.starting"));
+      daemonStarted = await daemon.start();
+      if (!daemonStarted) {
+        console.error(t("cli.codex.startFailed"));
+        process.exit(1);
+      }
+      console.log(t("cli.codex.started"));
+    }
+    if (!config.agent.codex?.enabled) {
+      console.error(t("cli.codex.notEnabled"));
+      console.error(t("cli.codex.enableHint"));
+      process.exit(1);
+    }
+    const workDir = options.directory || process.cwd();
+    const codexCommand = config.agent.codex?.command?.[0] || "codex";
+    const codexArgs = config.agent.codex?.command?.slice(1) || ["app-server", "--listen", "stdio://"];
+    console.log(t("cli.codex.startingIn", { dir: workDir, version: version || "unknown" }));
+    console.log(t("cli.codex.pressCtrlC") + "\n");
+    const codexProcess = spawn4(codexCommand, codexArgs, {
+      cwd: workDir,
+      stdio: "inherit",
+      shell: true
+    });
+    const logger = createAgentLogger("codex");
+    logger.info({ command: codexCommand, args: codexArgs, cwd: workDir }, "Codex CLI spawned");
+    codexProcess.on("exit", (code) => {
+      logger.info({ code }, "Codex CLI exited");
+      console.log(t("cli.codex.exited", { code }));
+      console.log(t("cli.codex.daemonRunning"));
+      process.exit(code || 0);
+    });
+    codexProcess.on("error", (err) => {
+      logger.error({ error: err.message }, "Codex CLI spawn failed");
+    });
+    process.on("SIGINT", () => {
+      console.log(t("cli.codex.detaching"));
+      codexProcess.kill("SIGINT");
+    });
+    process.on("SIGTERM", () => {
+      console.log(t("cli.codex.detaching"));
+      codexProcess.kill("SIGTERM");
+    });
+  });
+}
+
 // src/cli/agent/index.ts
 function registerAgentCommands(program2) {
   registerClaudeCommand(program2);
+  registerCodexCommand(program2);
 }
 
 // src/cli/index.ts