sessix-server 0.3.9 → 0.4.0

package/dist/index.js

@@ -24,10 +24,10 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 
 // src/index.ts
-var import_node_os8 = require("os");
+var import_node_os9 = require("os");
 var import_node_fs4 = require("fs");
-var import_node_path7 = require("path");
-var import_node_child_process10 = require("child_process");
+var import_node_path8 = require("path");
+var import_node_child_process11 = require("child_process");
 
 // src/i18n/locales/zh.ts
 var zh = {
@@ -302,12 +302,12 @@ function t(key, params) {
 }
 
 // src/server.ts
-var import_uuid6 = require("uuid");
-var import_promises4 = require("fs/promises");
-var import_node_os7 = require("os");
-var import_node_path6 = require("path");
-var import_node_child_process9 = require("child_process");
-var import_node_util = require("util");
+var import_uuid7 = require("uuid");
+var import_promises5 = require("fs/promises");
+var import_node_os8 = require("os");
+var import_node_path7 = require("path");
+var import_node_child_process10 = require("child_process");
+var import_node_util2 = require("util");
 
 // src/providers/ProcessProvider.ts
 var import_child_process = require("child_process");
@@ -3126,9 +3126,26 @@ process.stdin.on('end', async () => {
       signal: AbortSignal.timeout(320000),
     })
     const data = await res.json()
-    process.exit(data.decision === 'deny' ? 1 : 0)
+    const decision = data.decision === 'deny' ? 'deny' : 'allow'
+    const output = {
+      hookSpecificOutput: {
+        hookEventName: 'PreToolUse',
+        permissionDecision: decision,
+      },
+    }
+    if (decision === 'deny' && data.reason) {
+      output.hookSpecificOutput.permissionDecisionReason = String(data.reason)
+    }
+    process.stdout.write(JSON.stringify(output))
+    process.exit(0)
   } catch {
-    // Sessix \u670D\u52A1\u5668\u4E0D\u53EF\u7528\uFF0C\u9ED8\u8BA4\u653E\u884C
+    // Sessix \u670D\u52A1\u5668\u4E0D\u53EF\u7528\uFF0C\u9ED8\u8BA4\u653E\u884C\uFF08\u8F93\u51FA\u663E\u5F0F allow\uFF0C\u907F\u514D\u843D\u5230\u7EC8\u7AEF\u63D0\u793A\uFF09
+    process.stdout.write(JSON.stringify({
+      hookSpecificOutput: {
+        hookEventName: 'PreToolUse',
+        permissionDecision: 'allow',
+      },
+    }))
     process.exit(0)
   }
 })
@@ -3171,15 +3188,19 @@ var HookInstaller = class {
     console.log("[HookInstaller] Hook uninstalled");
   }
   /**
-   * 检查 hook 是否已安装
-   * 脚本文件和 settings.json 配置必须同时存在才算已安装
+   * 检查 hook 是否已安装且为最新版本
+   *
+   * 必须同时满足：
+   * 1. 两个脚本文件都存在
+   * 2. settings.json 中有 Sessix hook 配置
+   * 3. approval-hook.js 包含最新的 permissionDecision 输出协议
+   *    （旧版仅用 exit code，会导致 ExitPlanMode 等工具卡住）
    */
   async isInstalled() {
-    let approvalScriptExists = false;
+    let approvalScriptContent = "";
     let permissionScriptExists = false;
     try {
-      await (0, import_promises2.access)(HOOK_SCRIPT_PATH);
-      approvalScriptExists = true;
+      approvalScriptContent = await (0, import_promises2.readFile)(HOOK_SCRIPT_PATH, "utf-8");
     } catch {
     }
     try {
@@ -3187,9 +3208,10 @@ var HookInstaller = class {
       permissionScriptExists = true;
     } catch {
     }
+    const isLatestVersion = approvalScriptContent.includes("permissionDecision");
     const settings = await this.readClaudeSettings();
     const configExists = this.hasHookConfig(settings);
-    return approvalScriptExists && permissionScriptExists && configExists;
+    return isLatestVersion && permissionScriptExists && configExists;
   }
   // ============================================
   // 内部方法
@@ -4363,7 +4385,7 @@ var AuthManager = class extends import_events3.EventEmitter {
 };
 
 // src/server.ts
-var import_promises5 = require("fs/promises");
+var import_promises6 = require("fs/promises");
 
 // src/terminal/TerminalExecutor.ts
 var import_node_child_process7 = require("child_process");
@@ -4452,8 +4474,422 @@ var TerminalExecutor = class {
   }
 };
 
-// src/utils/cliCapabilities.ts
+// src/xcode/XcodeBuildExecutor.ts
 var import_node_child_process8 = require("child_process");
+var import_node_util = require("util");
+var import_promises4 = require("fs/promises");
+var import_node_path6 = require("path");
+var import_node_os7 = require("os");
+var import_uuid6 = require("uuid");
+var execAsync = (0, import_node_util.promisify)(import_node_child_process8.exec);
+var BUILD_TIMEOUT_MS = 30 * 60 * 1e3;
+var INSTALL_TIMEOUT_MS = 5 * 60 * 1e3;
+var CONFIG_FILE = (0, import_node_path6.join)((0, import_node_os7.homedir)(), ".sessix", "xcode-config.json");
+var SKIP_DIRS = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  "DerivedData",
+  "Pods",
+  ".build",
+  "build",
+  "dist",
+  "__pycache__",
+  ".next",
+  "vendor",
+  ".expo",
+  "android",
+  ".gradle",
+  "Carthage",
+  "xcarchive"
+]);
+var MAX_SCAN_DEPTH = 4;
+var XcodeBuildExecutor = class {
+  builds = /* @__PURE__ */ new Map();
+  installs = /* @__PURE__ */ new Map();
+  eventCallbacks = [];
+  configCache = null;
+  onEvent(callback) {
+    this.eventCallbacks.push(callback);
+    return () => {
+      const idx = this.eventCallbacks.indexOf(callback);
+      if (idx !== -1) this.eventCallbacks.splice(idx, 1);
+    };
+  }
+  emit(event) {
+    for (const cb of this.eventCallbacks) {
+      try {
+        cb(event);
+      } catch (err) {
+        console.error("[XcodeBuildExecutor] Event callback error:", err);
+      }
+    }
+  }
+  // ============================================
+  // 配置持久化
+  // ============================================
+  async loadConfigs() {
+    if (this.configCache) return this.configCache;
+    try {
+      const raw = await (0, import_promises4.readFile)(CONFIG_FILE, "utf8");
+      this.configCache = JSON.parse(raw);
+    } catch {
+      this.configCache = {};
+    }
+    return this.configCache;
+  }
+  async writeConfigs(store) {
+    await (0, import_promises4.mkdir)((0, import_node_path6.join)((0, import_node_os7.homedir)(), ".sessix"), { recursive: true });
+    await (0, import_promises4.writeFile)(CONFIG_FILE, JSON.stringify(store, null, 2), "utf8");
+    this.configCache = store;
+  }
+  async getSavedConfig(projectPath) {
+    const store = await this.loadConfigs();
+    return store[projectPath];
+  }
+  async saveConfig(projectPath, config) {
+    const store = await this.loadConfigs();
+    store[projectPath] = config;
+    await this.writeConfigs(store);
+  }
+  // ============================================
+  // 递归扫描 Xcode 工程
+  // ============================================
+  async findAllContainers(projectPath) {
+    const results = [];
+    await this.scanDir(projectPath, projectPath, 0, results);
+    results.sort((a, b) => a.path.split("/").length - b.path.split("/").length);
+    return results;
+  }
+  async scanDir(rootPath, currentPath, depth, results) {
+    if (depth > MAX_SCAN_DEPTH) return;
+    let entries;
+    try {
+      entries = await (0, import_promises4.readdir)(currentPath);
+    } catch {
+      return;
+    }
+    let foundWorkspace;
+    let foundProject;
+    for (const name of entries) {
+      if (name.endsWith(".xcworkspace") && !name.endsWith("project.xcworkspace")) {
+        foundWorkspace = foundWorkspace ?? name;
+      } else if (name.endsWith(".xcodeproj")) {
+        foundProject = foundProject ?? name;
+      }
+    }
+    if (foundWorkspace || foundProject) {
+      const relDir = currentPath === rootPath ? "" : currentPath.slice(rootPath.length + 1);
+      const containerName = foundWorkspace ? foundWorkspace.replace(/\.xcworkspace$/, "") : foundProject.replace(/\.xcodeproj$/, "");
+      results.push({
+        path: relDir,
+        name: containerName,
+        workspace: foundWorkspace ? relDir ? `${relDir}/${foundWorkspace}` : foundWorkspace : void 0,
+        project: foundProject ? relDir ? `${relDir}/${foundProject}` : foundProject : void 0
+      });
+    }
+    for (const name of entries) {
+      if (SKIP_DIRS.has(name)) continue;
+      if (name.startsWith(".")) continue;
+      if (name.endsWith(".xcodeproj") || name.endsWith(".xcworkspace")) continue;
+      const childPath = (0, import_node_path6.join)(currentPath, name);
+      await this.scanDir(rootPath, childPath, depth + 1, results);
+    }
+  }
+  // ============================================
+  // 探测 schemes（针对指定 container）
+  // ============================================
+  async detect(projectPath) {
+    if (process.platform !== "darwin") {
+      return { available: false, error: "Xcode \u6784\u5EFA\u53EA\u652F\u6301 macOS", containers: [], schemes: [] };
+    }
+    const containers = await this.findAllContainers(projectPath);
+    if (containers.length === 0) {
+      return { available: false, error: "\u672A\u627E\u5230 .xcworkspace \u6216 .xcodeproj", containers: [], schemes: [] };
+    }
+    const firstContainer = containers[0];
+    const schemes = await this.getSchemesForContainer(projectPath, firstContainer);
+    const saved = await this.getSavedConfig(projectPath);
+    return {
+      available: true,
+      containers,
+      schemes,
+      saved
+    };
+  }
+  async getSchemesForContainer(projectPath, container) {
+    const args = container.workspace ? ["-workspace", container.workspace, "-list", "-json"] : ["-project", container.project, "-list", "-json"];
+    try {
+      const { stdout } = await execAsync(
+        `xcodebuild ${args.map(shellQuote).join(" ")}`,
+        { cwd: projectPath, timeout: 3e4, maxBuffer: 4 * 1024 * 1024 }
+      );
+      const parsed = JSON.parse(stdout);
+      return parsed.workspace?.schemes ?? parsed.project?.schemes ?? [];
+    } catch {
+      return [];
+    }
+  }
+  // ============================================
+  // 列举 destinations
+  // ============================================
+  async listDestinations(projectPath, scheme, container) {
+    if (process.platform !== "darwin") return [];
+    const args = [
+      ...container.workspace ? ["-workspace", container.workspace] : ["-project", container.project],
+      "-scheme",
+      scheme,
+      "-showdestinations"
+    ];
+    try {
+      const { stdout, stderr } = await execAsync(
+        `xcodebuild ${args.map(shellQuote).join(" ")}`,
+        { cwd: projectPath, timeout: 6e4, maxBuffer: 4 * 1024 * 1024 }
+      );
+      return parseDestinations(stdout + "\n" + stderr);
+    } catch (err) {
+      const e = err;
+      const parsed = parseDestinations(`${e.stdout ?? ""}
+${e.stderr ?? ""}`);
+      if (parsed.length > 0) return parsed;
+      throw err;
+    }
+  }
+  // ============================================
+  // 构建
+  // ============================================
+  async build(sessionId, projectPath, override) {
+    if (process.platform !== "darwin") {
+      this.emitBuildError(sessionId, "", "Xcode \u6784\u5EFA\u4EC5\u652F\u6301 macOS\n");
+      return null;
+    }
+    const config = override ?? await this.getSavedConfig(projectPath);
+    if (!config) {
+      this.emitBuildError(sessionId, "", "\u672A\u914D\u7F6E Xcode \u6784\u5EFA\u53C2\u6570\uFF0C\u8BF7\u5148\u9009\u62E9 scheme \u4E0E\u76EE\u6807\u8BBE\u5907\n");
+      return null;
+    }
+    if (override) await this.saveConfig(projectPath, override);
+    const buildId = (0, import_uuid6.v4)();
+    const args = buildArgs(config);
+    const proc = (0, import_node_child_process8.spawn)("xcodebuild", args, {
+      cwd: projectPath,
+      stdio: ["ignore", "pipe", "pipe"],
+      env: { ...process.env, NSUnbufferedIO: "YES" }
+    });
+    this.builds.set(buildId, proc);
+    this.emit({
+      type: "xcode_build_output",
+      sessionId,
+      buildId,
+      stream: "stdout",
+      data: `$ xcodebuild ${args.map((a) => a.includes(" ") ? `"${a}"` : a).join(" ")}
+   cwd: ${projectPath}
+   destination: ${config.destinationName}
+
+`
+    });
+    proc.stdout?.on("data", (chunk) => {
+      this.emit({ type: "xcode_build_output", sessionId, buildId, stream: "stdout", data: chunk.toString() });
+    });
+    proc.stderr?.on("data", (chunk) => {
+      this.emit({ type: "xcode_build_output", sessionId, buildId, stream: "stderr", data: chunk.toString() });
+    });
+    proc.on("error", (err) => {
+      this.emit({ type: "xcode_build_output", sessionId, buildId, stream: "stderr", data: `[spawn error] ${err.message}
+` });
+    });
+    const timer = setTimeout(() => {
+      if (this.builds.has(buildId)) killProcessCrossPlatform(proc);
+    }, BUILD_TIMEOUT_MS);
+    proc.on("exit", (code, signal) => {
+      clearTimeout(timer);
+      this.builds.delete(buildId);
+      this.emit({ type: "xcode_build_exit", sessionId, buildId, code, signal });
+    });
+    console.log(`[XcodeBuildExecutor] build ${buildId} scheme=${config.scheme} dest=${config.destinationName}`);
+    return buildId;
+  }
+  killBuild(buildId) {
+    const proc = this.builds.get(buildId);
+    if (proc) {
+      killProcessCrossPlatform(proc);
+      console.log(`[XcodeBuildExecutor] kill build ${buildId}`);
+    }
+  }
+  emitBuildError(sessionId, buildId, msg) {
+    this.emit({ type: "xcode_build_output", sessionId, buildId, stream: "stderr", data: msg });
+    this.emit({ type: "xcode_build_exit", sessionId, buildId, code: 1, signal: null });
+  }
+  // ============================================
+  // 安装
+  // ============================================
+  async install(sessionId, projectPath) {
+    if (process.platform !== "darwin") {
+      this.emitInstallError(sessionId, "", "Xcode \u5B89\u88C5\u4EC5\u652F\u6301 macOS\n");
+      return null;
+    }
+    const config = await this.getSavedConfig(projectPath);
+    if (!config) {
+      this.emitInstallError(sessionId, "", "\u672A\u627E\u5230\u6784\u5EFA\u914D\u7F6E\uFF0C\u8BF7\u5148\u6784\u5EFA\u4E00\u6B21\n");
+      return null;
+    }
+    const installId = (0, import_uuid6.v4)();
+    let appPath;
+    try {
+      appPath = await this.getAppPath(projectPath, config);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      this.emitInstallError(sessionId, installId, `\u65E0\u6CD5\u5B9A\u4F4D\u6784\u5EFA\u4EA7\u7269: ${msg}
+`);
+      return null;
+    }
+    const { destinationKind, destinationId, destinationName } = config;
+    let installCmd;
+    if (destinationKind === "simulator") {
+      installCmd = ["xcrun", "simctl", "install", destinationId, appPath];
+    } else if (destinationKind === "device") {
+      installCmd = ["xcrun", "devicectl", "device", "install", "app", "--device-id", destinationId, appPath];
+    } else if (destinationKind === "mac") {
+      installCmd = ["open", appPath];
+    } else {
+      this.emitInstallError(sessionId, installId, `\u672A\u77E5\u76EE\u6807\u7C7B\u578B\uFF0C\u65E0\u6CD5\u81EA\u52A8\u5B89\u88C5
+`);
+      return null;
+    }
+    this.emit({
+      type: "xcode_install_output",
+      sessionId,
+      installId,
+      stream: "stdout",
+      data: `$ ${installCmd.join(" ")}
+   destination: ${destinationName}
+   app: ${appPath}
+
+`
+    });
+    const proc = (0, import_node_child_process8.spawn)(installCmd[0], installCmd.slice(1), {
+      cwd: projectPath,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    this.installs.set(installId, proc);
+    proc.stdout?.on("data", (chunk) => {
+      this.emit({ type: "xcode_install_output", sessionId, installId, stream: "stdout", data: chunk.toString() });
+    });
+    proc.stderr?.on("data", (chunk) => {
+      this.emit({ type: "xcode_install_output", sessionId, installId, stream: "stderr", data: chunk.toString() });
+    });
+    proc.on("error", (err) => {
+      this.emit({ type: "xcode_install_output", sessionId, installId, stream: "stderr", data: `[spawn error] ${err.message}
+` });
+    });
+    const timer = setTimeout(() => {
+      if (this.installs.has(installId)) killProcessCrossPlatform(proc);
+    }, INSTALL_TIMEOUT_MS);
+    proc.on("exit", (code, signal) => {
+      clearTimeout(timer);
+      this.installs.delete(installId);
+      this.emit({ type: "xcode_install_exit", sessionId, installId, code, signal });
+    });
+    console.log(`[XcodeBuildExecutor] install ${installId} dest=${destinationName} kind=${destinationKind}`);
+    return installId;
+  }
+  killInstall(installId) {
+    const proc = this.installs.get(installId);
+    if (proc) {
+      killProcessCrossPlatform(proc);
+      console.log(`[XcodeBuildExecutor] kill install ${installId}`);
+    }
+  }
+  emitInstallError(sessionId, installId, msg) {
+    this.emit({ type: "xcode_install_output", sessionId, installId, stream: "stderr", data: msg });
+    this.emit({ type: "xcode_install_exit", sessionId, installId, code: 1, signal: null });
+  }
+  /** 通过 xcodebuild -showBuildSettings 定位 .app 路径 */
+  async getAppPath(projectPath, config) {
+    const args = [
+      ...buildArgs(config).filter((a) => a !== "build"),
+      "-showBuildSettings"
+    ];
+    const { stdout } = await execAsync(
+      `xcodebuild ${args.map(shellQuote).join(" ")}`,
+      { cwd: projectPath, timeout: 3e4, maxBuffer: 4 * 1024 * 1024 }
+    );
+    const builtDir = extractBuildSetting(stdout, "BUILT_PRODUCTS_DIR");
+    const productName = extractBuildSetting(stdout, "FULL_PRODUCT_NAME");
+    if (!builtDir || !productName) {
+      throw new Error("\u65E0\u6CD5\u4ECE -showBuildSettings \u4E2D\u8BFB\u53D6 BUILT_PRODUCTS_DIR / FULL_PRODUCT_NAME");
+    }
+    return (0, import_node_path6.join)(builtDir, productName);
+  }
+  // ============================================
+  // 清理
+  // ============================================
+  destroy() {
+    for (const [id, proc] of this.builds) {
+      killProcessCrossPlatform(proc);
+      console.log(`[XcodeBuildExecutor] cleanup build ${id}`);
+    }
+    for (const [id, proc] of this.installs) {
+      killProcessCrossPlatform(proc);
+      console.log(`[XcodeBuildExecutor] cleanup install ${id}`);
+    }
+    this.builds.clear();
+    this.installs.clear();
+    this.eventCallbacks.length = 0;
+  }
+};
+function shellQuote(s) {
+  return `'${s.replace(/'/g, "'\\''")}'`;
+}
+function buildArgs(config) {
+  const container = config.workspace ? ["-workspace", config.workspace] : config.project ? ["-project", config.project] : [];
+  return [
+    ...container,
+    "-scheme",
+    config.scheme,
+    "-destination",
+    `id=${config.destinationId}`,
+    "-configuration",
+    config.configuration ?? "Debug",
+    "build"
+  ];
+}
+function extractBuildSetting(output, key) {
+  const match = new RegExp(`^\\s*${key}\\s*=\\s*(.+)$`, "m").exec(output);
+  return match?.[1]?.trim();
+}
+function parseDestinations(text) {
+  const results = [];
+  const seen = /* @__PURE__ */ new Set();
+  const lineRegex = /\{\s*([^{}]+)\s*\}/g;
+  let match;
+  while ((match = lineRegex.exec(text)) !== null) {
+    const fields = {};
+    for (const part of match[1].split(",")) {
+      const colon = part.indexOf(":");
+      if (colon === -1) continue;
+      const key = part.slice(0, colon).trim();
+      const value = part.slice(colon + 1).trim();
+      if (key) fields[key] = value;
+    }
+    const { id, name, platform: platform2 } = fields;
+    if (!id || !name || !platform2) continue;
+    if (seen.has(id)) continue;
+    seen.add(id);
+    let kind = "unknown";
+    if (platform2.includes("Simulator")) kind = "simulator";
+    else if (platform2 === "iOS" || platform2 === "watchOS" || platform2 === "tvOS" || platform2 === "visionOS") kind = "device";
+    else if (platform2 === "macOS") kind = "mac";
+    results.push({ id, name, platform: platform2, os: fields.OS, kind });
+  }
+  results.sort((a, b) => kindOrder(a.kind) - kindOrder(b.kind));
+  return results;
+}
+function kindOrder(k) {
+  return k === "device" ? 0 : k === "simulator" ? 1 : k === "mac" ? 2 : 3;
+}
+
+// src/utils/cliCapabilities.ts
+var import_node_child_process9 = require("child_process");
 var DEFAULT_CAPABILITIES = {
   effortLevels: ["low", "medium", "high", "xhigh", "max"]
 };
@@ -4481,7 +4917,7 @@ async function parseCliCapabilities() {
 }
 function runCli(path2, args) {
   return new Promise((resolve) => {
-    (0, import_node_child_process8.execFile)(path2, args, { timeout: 5e3 }, (err, stdout) => {
+    (0, import_node_child_process9.execFile)(path2, args, { timeout: 5e3 }, (err, stdout) => {
       if (err) {
         console.warn(`[CliCapabilities] Failed to run ${path2} ${args.join(" ")}:`, err.message);
         resolve(null);
@@ -4495,11 +4931,11 @@ function runCli(path2, args) {
 // src/server.ts
 var WS_PORT = 3745;
 var HTTP_PORT = 3746;
-var execAsync = (0, import_node_util.promisify)(import_node_child_process9.exec);
+var execAsync2 = (0, import_node_util2.promisify)(import_node_child_process10.exec);
 async function killPortProcess(port) {
   try {
     if (isWindows) {
-      const { stdout } = await execAsync(
+      const { stdout } = await execAsync2(
         `netstat -ano | findstr :${port} | findstr LISTENING`
       );
       const pids = /* @__PURE__ */ new Set();
@@ -4509,14 +4945,14 @@ async function killPortProcess(port) {
         if (pid && /^\d+$/.test(pid) && pid !== "0") pids.add(pid);
       }
       for (const pid of pids) {
-        await execAsync(`taskkill /PID ${pid} /F`).catch(() => {
+        await execAsync2(`taskkill /PID ${pid} /F`).catch(() => {
         });
       }
     } else {
-      const { stdout } = await execAsync(`lsof -ti :${port}`);
+      const { stdout } = await execAsync2(`lsof -ti :${port}`);
       const pids = stdout.trim().split("\n").filter((p) => p && /^\d+$/.test(p));
       if (pids.length > 0) {
-        await execAsync(`kill -9 ${pids.join(" ")}`);
+        await execAsync2(`kill -9 ${pids.join(" ")}`);
       }
     }
     await new Promise((resolve) => setTimeout(resolve, 600));
@@ -4537,8 +4973,8 @@ async function createWithRetry(label, port, factory) {
   }
 }
 async function start(opts = {}) {
-  const configDir = (0, import_node_path6.join)((0, import_node_os7.homedir)(), ".sessix");
-  const tokenFile = (0, import_node_path6.join)(configDir, "token");
+  const configDir = (0, import_node_path7.join)((0, import_node_os8.homedir)(), ".sessix");
+  const tokenFile = (0, import_node_path7.join)(configDir, "token");
   let token;
   if (opts.token !== void 0) {
     token = opts.token;
@@ -4548,17 +4984,23 @@ async function start(opts = {}) {
       token = envToken;
     } else {
       try {
-        token = (await (0, import_promises4.readFile)(tokenFile, "utf8")).trim();
+        token = (await (0, import_promises5.readFile)(tokenFile, "utf8")).trim();
       } catch {
-        token = (0, import_uuid6.v4)();
-        await (0, import_promises4.mkdir)(configDir, { recursive: true });
-        await (0, import_promises4.writeFile)(tokenFile, token, "utf8");
+        token = (0, import_uuid7.v4)();
+        await (0, import_promises5.mkdir)(configDir, { recursive: true });
+        await (0, import_promises5.writeFile)(tokenFile, token, "utf8");
       }
     }
   }
   const providerFactory = new ProviderFactory();
   const sessionManager = new SessionManager(providerFactory);
   const terminalExecutor = new TerminalExecutor();
+  const xcodeBuildExecutor = new XcodeBuildExecutor();
+  const approvalProxy = await createWithRetry(
+    "ApprovalProxy",
+    HTTP_PORT,
+    () => ApprovalProxy.create({ port: HTTP_PORT, token })
+  );
   const wsBridge = await createWithRetry(
     "WsBridge",
     WS_PORT,
@@ -4589,15 +5031,10 @@ async function start(opts = {}) {
   const sessionFileWatcher = new SessionFileWatcher((event) => {
     wsBridge.broadcast(event);
   });
-  const approvalProxy = await createWithRetry(
-    "ApprovalProxy",
-    HTTP_PORT,
-    () => ApprovalProxy.create({ port: HTTP_PORT, token })
-  );
   let mdnsService = null;
   const pairingManager = new PairingManager({
     token,
-    serverName: (0, import_node_os7.hostname)(),
+    serverName: (0, import_node_os8.hostname)(),
     version: "0.2.0",
     onStateChange: (state) => mdnsService?.updatePairingState(state)
   });
@@ -4651,7 +5088,7 @@ async function start(opts = {}) {
     try {
       switch (event.type) {
         case "create_session": {
-          await (0, import_promises4.mkdir)(event.projectPath, { recursive: true });
+          await (0, import_promises5.mkdir)(event.projectPath, { recursive: true });
           const resumeId = event.resumeSessionId ?? event.newSessionId;
           if (resumeId) sessionFileWatcher.unwatch(resumeId);
           await sessionManager.createSession(
@@ -4839,7 +5276,7 @@ async function start(opts = {}) {
             if (!isStreaming) {
               const filePath = getSessionFilePath(event.projectPath, event.sessionId);
               try {
-                const fileStat = await (0, import_promises5.stat)(filePath);
+                const fileStat = await (0, import_promises6.stat)(filePath);
                 sessionFileWatcher.watch(event.sessionId, filePath, fileStat.size);
               } catch {
               }
@@ -4948,6 +5385,56 @@ async function start(opts = {}) {
           wsBridge.send(ws, { type: "agent_list", agents });
           break;
         }
+        case "xcode_detect": {
+          const info = await xcodeBuildExecutor.detect(event.projectPath);
+          wsBridge.send(ws, { type: "xcode_info", sessionId: event.sessionId, info });
+          break;
+        }
+        case "xcode_list_schemes": {
+          const schemes = await xcodeBuildExecutor.getSchemesForContainer(event.projectPath, event.container);
+          wsBridge.send(ws, {
+            type: "xcode_info",
+            sessionId: event.sessionId,
+            info: {
+              available: schemes.length > 0,
+              containers: [event.container],
+              schemes
+            }
+          });
+          break;
+        }
+        case "xcode_list_destinations": {
+          try {
+            const destinations = await xcodeBuildExecutor.listDestinations(event.projectPath, event.scheme, event.container);
+            wsBridge.send(ws, { type: "xcode_destinations", sessionId: event.sessionId, scheme: event.scheme, destinations });
+          } catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            wsBridge.send(ws, {
+              type: "xcode_destinations",
+              sessionId: event.sessionId,
+              scheme: event.scheme,
+              destinations: [],
+              error: message.split("\n")[0]
+            });
+          }
+          break;
+        }
+        case "xcode_save_config": {
+          await xcodeBuildExecutor.saveConfig(event.projectPath, event.config);
+          break;
+        }
+        case "xcode_build": {
+          await xcodeBuildExecutor.build(event.sessionId, event.projectPath, event.config);
+          break;
+        }
+        case "xcode_build_kill": {
+          xcodeBuildExecutor.killBuild(event.buildId);
+          break;
+        }
+        case "xcode_install": {
+          await xcodeBuildExecutor.install(event.sessionId, event.projectPath);
+          break;
+        }
         default: {
           wsBridge.send(ws, {
             type: "error",
@@ -4983,6 +5470,9 @@ async function start(opts = {}) {
   terminalExecutor.onEvent((event) => {
     wsBridge.broadcast(event);
   });
+  xcodeBuildExecutor.onEvent((event) => {
+    wsBridge.broadcast(event);
+  });
   wsBridge.onDisconnect(() => {
     if (wsBridge.getConnectionCount() === 0 && approvalProxy.getPendingCount() > 0) {
       approvalProxy.approveAll(t("server.phoneDisconnected"));
@@ -5090,6 +5580,7 @@ async function start(opts = {}) {
     await attempt(() => approvalProxy.close(), "ApprovalProxy");
     await attempt(() => sessionManager.destroy(), "SessionManager");
     await attempt(() => terminalExecutor.destroy(), "TerminalExecutor");
+    await attempt(() => xcodeBuildExecutor.destroy(), "XcodeBuildExecutor");
     await attempt(() => notificationService.destroy(), "NotificationService");
     await attempt(() => sessionFileWatcher.destroy(), "SessionFileWatcher");
     if (errors.length > 0) {
@@ -5118,9 +5609,9 @@ async function start(opts = {}) {
     openPairing: (duration) => pairingManager.open(duration),
     closePairing: () => pairingManager.close(),
     regenerateToken: async () => {
-      const newToken = (0, import_uuid6.v4)();
-      await (0, import_promises4.mkdir)(configDir, { recursive: true });
-      await (0, import_promises4.writeFile)(tokenFile, newToken, "utf8");
+      const newToken = (0, import_uuid7.v4)();
+      await (0, import_promises5.mkdir)(configDir, { recursive: true });
+      await (0, import_promises5.writeFile)(tokenFile, newToken, "utf8");
       instance.token = newToken;
       wsBridge.updateToken(newToken);
       approvalProxy.updateToken(newToken);
@@ -5137,7 +5628,7 @@ async function start(opts = {}) {
 var import_qrcode_terminal = __toESM(require("qrcode-terminal"));
 function getPackageVersion() {
   try {
-    const pkg = JSON.parse((0, import_node_fs4.readFileSync)((0, import_node_path7.join)(__dirname, "..", "package.json"), "utf8"));
+    const pkg = JSON.parse((0, import_node_fs4.readFileSync)((0, import_node_path8.join)(__dirname, "..", "package.json"), "utf8"));
     return pkg.version ?? "0.0.0";
   } catch {
     return "0.0.0";
@@ -5175,7 +5666,7 @@ async function autoUpdateIfNeeded() {
   console.log(`  \u{1F4E6} ${t("startup.autoUpdating", { current: PKG_VERSION, latest })}`);
   console.log();
   try {
-    (0, import_node_child_process10.execFileSync)("npx", [`sessix-server@${latest}`], {
+    (0, import_node_child_process11.execFileSync)("npx", [`sessix-server@${latest}`], {
       stdio: "inherit",
       env: { ...process.env, __SESSIX_UPDATED: "1" }
     });
@@ -5281,7 +5772,7 @@ ${t("startup.pairingReopened")}`);
   }
 }
 function getLocalIp() {
-  const interfaces = (0, import_node_os8.networkInterfaces)();
+  const interfaces = (0, import_node_os9.networkInterfaces)();
   for (const iface of Object.values(interfaces)) {
     for (const addr of iface ?? []) {
       if (addr.family === "IPv4" && !addr.internal) {