lody 0.103.0 → 0.104.0

package/README.md

@@ -14,6 +14,38 @@ Install the CLI package:
 npm install -g lody@next
 ```
 
+## Daemon upgrades and autostart
+
+Remote upgrades install globally using the daemon's npm environment, resolve the
+installed package's declared CLI entry via `npm root -g`, and verify its version.
+The watchdog launches that entry explicitly and only reports upgrade success after
+the replacement reaches ready with the same version. A successful npm install alone
+does not prove that the running daemon upgraded. Verification or handoff failure is
+logged as failure; the existing restart recovery remains available.
+
+Autostart scripts, scheduled tasks, and service definitions must invoke the stable
+global installation, not an absolute `_npx` cache entry or a version-specific store
+path. This repository does not generate or rewrite user-owned autostart scripts.
+If an existing daemon was launched from such a pinned path:
+
+1. In the same OS environment and user account as the daemon, install the desired
+   version globally. Windows and WSL have separate installations.
+2. Find the global prefix with `npm prefix -g`. On Windows the stable launcher is
+   `<prefix>\lody.cmd`; on Linux/WSL/macOS it is `<prefix>/bin/lody`.
+   Check that launcher's `--version` before using it. Use the same Node/npm
+   installation and preserve the script's environment and daemon arguments.
+3. Replace the old cache path in the autostart command with that absolute launcher.
+   In PowerShell invoke a quoted launcher with `&`. Ensure the task's PATH includes
+   the intended Node runtime; WSL tasks must use the launcher inside that distro.
+4. Use the verified launcher to run `daemon stop`, then `daemon start` with the
+   original options, and check `daemon status` and the startup log's CLI version.
+   Restart the watchdog too: restarting only its Worker leaves old upgrade code alive.
+
+An already-running old watchdog cannot acquire this fix merely by downloading it;
+the one-time launcher correction and restart are needed for that deployment.
+Older releases without versioned readiness cannot be verified by the new remote
+handoff and must be started explicitly if a rollback is required.
+
 ## Workspace discovery
 
 The cloud workspace CLI and Lody MCP share resource queries. Lists return 20 entries
@@ -39,11 +71,20 @@ Matching MCP tools are `lody_machine_list`, `lody_project_list`,
 `lody_operation_list`. Session list adds `query`, `machineId`, `agentConfigId`,
 and `agentRoleId`. Creation provenance is what the Role filter matches.
 
+`lody_session_create_options` and Agent config discovery expose `runConfig.modes`
+and `runConfig.configOptions` (ids, types and choices, without current values).
+Single and batch MCP creates accept `modeId` and `configOptionValues`, matching
+CLI `--mode` and `--config-option` validation against target capabilities.
+For example, a Grok target may use `configOptionValues: { permission_mode: "ask" }`;
+its ACP mode `default` is not a permission policy. Explicit permissions may exceed
+the parent; callers must follow their user authorization. Roles still override
+manual configuration. Merge, Plan and retry behavior: [creation contract](../../specs/session-orchestration.md#session-creation-configuration).
+
 `project list` without catalog options retains the local daemon project listing.
 Workspace project listing now spans authorized machines and enabled GitHub repositories;
 `--machine` restricts it to local projects on that machine. Directory lists are
 paginated summaries rather than the old unbounded/full configuration dumps.
-`agent-config show` remains the trusted configuration inspection command;
+`agent-config show` inspects a configuration with environment values hidden;
 `get` returns the safe discovery projection. Legacy `machine list --include-agents`
 and `--include-acp-capabilities` retain their detailed output and cannot combine with
 directory pagination/filter flags.
@@ -60,3 +101,20 @@ These workspace queries use the existing cloud command runtime. The OSS local
 composition does not enable cloud queries; local project listing remains available.
 Catalog `--offline` skips catalog synchronization but still verifies authorization;
 GitHub repository listing requires connectivity.
+
+## Agent configuration output
+
+`agent-config show [id] [--json]` returns sorted `envKeys`, not environment values.
+Text output marks every key `[configured]`, including empty values. For deliberate
+inspection, `show --show-secrets` includes the original values (`env` in JSON).
+That output may contain credentials: use it only where the output is trusted.
+The flag is only available on `show`; list/get remain safe discovery summaries.
+
+JSON create/update responses contain `ok`, `workspaceId`, `agentConfigId` and
+`changedFields` (initialized/requested field names, not values), rather than `agentConfig`.
+Scripts should read `agentConfigId` for the saved id and use a separate `show`
+when inspection is needed. Scripts reading `show.agentConfig.env` must explicitly
+opt in to secret output, or migrate to `envKeys`. The output is a presentation
+contract, not a full configuration backup; runtime/auth/custom-launch fields are
+not exported. No masked placeholder is stored or returned as an environment value.
+Assignment errors report entry/line numbers without echoing their contents.

package/dist/baguette-worker.js

@@ -0,0 +1,480 @@
+import { spawn } from "node:child_process";
+import { createServer } from "node:net";
+import { setTimeout as setTimeout$1 } from "node:timers/promises";
+import { mkdtemp, writeFile, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { l as IosSimulatorDeviceControlSchema } from "./chunks/ios-simulator-hTbW-tat.js";
+import { s as string, o as object, e as union, a as _enum, n as number, l as literal } from "./chunks/schemas-D_XLKCXC.js";
+const guestButtonsSource = String.raw`
+#import <Foundation/Foundation.h>
+#import <objc/message.h>
+#import <dlfcn.h>
+#import <mach/mach_time.h>
+#import <signal.h>
+#import <unistd.h>
+
+@interface LodyButtonProperties : NSObject
+@end
+@implementation LodyButtonProperties
+- (id)propertyForKey:(NSString *)key forService:(id)service {
+  return (@{@"PrimaryUsagePage": @11, @"PrimaryUsage": @1,
+    @"DeviceUsagePairs": @[@{@"DeviceUsagePage": @11, @"DeviceUsage": @1}],
+    @"Transport": @"CoreDevice", @"Product": @"Lody simulator buttons",
+    @"Built-In": @YES, @"VendorID": @0, @"ProductID": @0,
+    @"VersionNumber": @0, @"ReportInterval": @8000})[key];
+}
+- (BOOL)setProperty:(id)value forKey:(NSString *)key forService:(id)service { return YES; }
+- (id)copyEventMatching:(id)matching forService:(id)service { return nil; }
+- (BOOL)setOutputEvent:(id)event forService:(id)service { return YES; }
+- (void)notification:(uint32_t)type withProperty:(id)property forService:(id)service {}
+@end
+static volatile sig_atomic_t stopping = 0;
+static void stop(int sig) { stopping = 1; }
+int main(void) {
+ @autoreleasepool {
+  signal(SIGTERM, stop); signal(SIGINT, stop);
+  dlopen("/System/Library/PrivateFrameworks/HID.framework/HID", RTLD_NOW);
+  void *lib = dlopen("/System/Library/Frameworks/IOKit.framework/IOKit", RTLD_NOW);
+  CFTypeRef (*event)(CFAllocatorRef,uint64_t,uint32_t,uint32_t,Boolean,uint32_t) =
+    dlsym(lib, "IOHIDEventCreateKeyboardEvent");
+  id service = [[NSClassFromString(@"HIDVirtualEventService") alloc] init];
+  if (!event || !service) return 1;
+  LodyButtonProperties *properties = [LodyButtonProperties new];
+  ((void (*)(id,SEL,id))objc_msgSend)(service,sel_registerName("setDelegate:"),properties);
+  dispatch_queue_t queue = dispatch_queue_create("ai.lody.simulator.buttons", DISPATCH_QUEUE_SERIAL);
+  ((void (*)(id,SEL,id))objc_msgSend)(service,sel_registerName("setDispatchQueue:"),queue);
+  ((void (*)(id,SEL))objc_msgSend)(service,sel_registerName("activate"));
+  if (!((uint64_t (*)(id,SEL))objc_msgSend)(service,sel_registerName("serviceID"))) return 1;
+  // The guest enumerates the newly registered service asynchronously.
+  usleep(300000);
+  if (!stopping) { puts("ready"); fflush(stdout); }
+  char line[64];
+  while (!stopping && fgets(line,sizeof(line),stdin)) {
+    unsigned sequence = 0; char name[32], extra;
+    if (sscanf(line,"%u %31s %c",&sequence,name,&extra) != 2 || !sequence) break;
+    unsigned usage = 0, count = 1;
+    if (!strcmp(name,"home")) usage = 64;
+    else if (!strcmp(name,"app-switcher")) { usage = 64; count = 2; }
+    else if (!strcmp(name,"lock")) usage = 48;
+    else break;
+    BOOL ok = YES;
+    for (unsigned i=0; i<count && !stopping; i++) {
+      CFTypeRef down = event(kCFAllocatorDefault,mach_absolute_time(),12,usage,true,0);
+      if (!down) { ok = NO; break; }
+      BOOL sent = ((BOOL (*)(id,SEL,id))objc_msgSend)(service,sel_registerName("dispatchEvent:"),(__bridge id)down);
+      CFRelease(down);
+      usleep(100000);
+      // Always release a submitted down, including a shutdown during the hold.
+      CFTypeRef up = event(kCFAllocatorDefault,mach_absolute_time(),12,usage,false,0);
+      BOOL released = up && ((BOOL (*)(id,SEL,id))objc_msgSend)(service,sel_registerName("dispatchEvent:"),(__bridge id)up);
+      if (up) CFRelease(up);
+      ok = ok && sent && released;
+      if (i+1<count) usleep(150000);
+    }
+    if (stopping) break;
+    printf("%u %s\n",sequence,ok ? "ok" : "error"); fflush(stdout);
+    if (!ok) break;
+  }
+  ((void (*)(id,SEL))objc_msgSend)(service,sel_registerName("cancel"));
+  return 0;
+ }
+}
+`;
+function createGuestButtons(signal, executable = "/usr/bin/xcrun") {
+  let directory;
+  let device;
+  let child2;
+  let childClosed;
+  let preparing;
+  let pending;
+  let sequence = 0;
+  let failed = false;
+  let stopping;
+  const error = () => new Error("Simulator buttons unavailable.");
+  const fail = () => {
+    failed = true;
+    pending?.reject(error());
+    pending = void 0;
+  };
+  let terminating;
+  function terminate() {
+    if (terminating) return terminating;
+    const owned = child2;
+    if (!owned) return Promise.resolve();
+    const closed = childClosed;
+    terminating = (async () => {
+      owned.stdin.end();
+      const send = (terminationSignal) => {
+        if (owned.pid) {
+          try {
+            process.kill(-owned.pid, terminationSignal);
+            return true;
+          } catch (e) {
+            if (!(e instanceof Error && "code" in e && e.code === "ESRCH")) throw e;
+          }
+        }
+        return false;
+      };
+      const term = setTimeout(() => send("SIGTERM"), 1e3);
+      const kill = setTimeout(() => send("SIGKILL"), 2e3);
+      await closed;
+      clearTimeout(term);
+      clearTimeout(kill);
+      if (send("SIGTERM")) {
+        const killAt = Date.now() + 1e3;
+        while (send(0)) {
+          if (Date.now() >= killAt) send("SIGKILL");
+          await setTimeout$1(25);
+        }
+      }
+      if (child2 === owned) child2 = void 0;
+    })();
+    return terminating;
+  }
+  function launch(args, protocol) {
+    signal.throwIfAborted();
+    if (failed) throw error();
+    const process2 = spawn(executable, args, { detached: true, stdio: ["pipe", "pipe", "ignore"] });
+    child2 = process2;
+    terminating = void 0;
+    childClosed = new Promise((resolve) => process2.once("close", resolve));
+    process2.stdin.on("error", fail);
+    return new Promise((resolve, reject) => {
+      let ready = false;
+      let buffer = "";
+      process2.once("error", () => {
+        fail();
+        reject(error());
+      });
+      process2.once("close", (code) => {
+        if (!protocol && code === 0 && !signal.aborted) resolve();
+        else {
+          fail();
+          reject(error());
+        }
+      });
+      if (protocol) {
+        pending = {
+          line: "ready",
+          resolve: () => {
+            ready = true;
+            resolve();
+          },
+          reject
+        };
+        process2.stdout.setEncoding("utf8");
+        process2.stdout.on("data", (chunk) => {
+          buffer += chunk;
+          if (buffer.length > 1024) {
+            fail();
+            void terminate();
+            return;
+          }
+          while (buffer.includes("\n")) {
+            const at = buffer.indexOf("\n");
+            const line = buffer.slice(0, at);
+            buffer = buffer.slice(at + 1);
+            const request = pending;
+            if (!request || line !== request.line || line === "ready" && ready) {
+              fail();
+              void terminate();
+              return;
+            }
+            pending = void 0;
+            request.resolve();
+          }
+        });
+      } else process2.stdin.end();
+    });
+  }
+  async function prepare(udid) {
+    directory = await mkdtemp(join(tmpdir(), "lody-simulator-buttons-"));
+    signal.throwIfAborted();
+    const source = join(directory, "buttons.m");
+    const binary = join(directory, "buttons");
+    await writeFile(source, guestButtonsSource, { mode: 384 });
+    await launch(
+      [
+        "--sdk",
+        "iphonesimulator",
+        "clang",
+        "-arch",
+        "arm64",
+        "-target",
+        "arm64-apple-ios17.0-simulator",
+        "-framework",
+        "Foundation",
+        "-fobjc-arc",
+        "-Wl,-adhoc_codesign",
+        source,
+        "-o",
+        binary
+      ],
+      false
+    );
+    await launch(["simctl", "spawn", udid, binary], true);
+  }
+  const close = () => {
+    stopping ??= (async () => {
+      fail();
+      await terminate();
+      await preparing?.catch(() => {
+      });
+      if (directory) await rm(directory, { recursive: true, force: true });
+      signal.removeEventListener("abort", onAbort);
+    })();
+    return stopping;
+  };
+  const onAbort = () => {
+    void close().catch(() => {
+    });
+  };
+  signal.addEventListener("abort", onAbort, { once: true });
+  return {
+    close,
+    async prepare(udid) {
+      await this.press(udid);
+    },
+    async press(udid, button) {
+      signal.throwIfAborted();
+      if (failed || pending || device && device !== udid) throw error();
+      device = udid;
+      const timeout = setTimeout(() => {
+        void close().catch(() => {
+        });
+      }, 1e4);
+      try {
+        preparing ??= prepare(udid);
+        await preparing;
+        if (failed || signal.aborted || !child2) throw error();
+        if (!button) return;
+        const id = ++sequence;
+        await new Promise((resolve, reject) => {
+          pending = { line: `${id} ok`, resolve, reject };
+          child2?.stdin.write(`${id} ${button}
+`, (err) => {
+            if (err) fail();
+          });
+        });
+      } catch {
+        await close();
+        throw error();
+      } finally {
+        clearTimeout(timeout);
+      }
+    }
+  };
+}
+async function runSimulatorHostControl(udid, control, signal, executable = "/usr/bin/xcrun") {
+  async function run(args, input) {
+    signal.throwIfAborted();
+    return new Promise((resolve, reject) => {
+      const child2 = spawn(executable, args, {
+        stdio: ["pipe", "ignore", "ignore"],
+        // The IPC worker has a filtered environment. simctl decodes stdin with
+        // the locale, so an unset locale rejects non-ASCII pasteboard contents.
+        env: { ...process.env, LANG: "en_US.UTF-8", LC_ALL: "en_US.UTF-8" }
+      });
+      let kill;
+      const cancel = () => {
+        child2.kill("SIGTERM");
+        kill ??= setTimeout(() => child2.kill("SIGKILL"), 1e3);
+      };
+      signal.addEventListener("abort", cancel, { once: true });
+      if (signal.aborted) cancel();
+      child2.stdin.on("error", () => {
+      });
+      child2.stdin.end(input);
+      let failed = false;
+      child2.once("error", () => {
+        failed = true;
+      });
+      child2.once("close", (code2) => {
+        clearTimeout(kill);
+        signal.removeEventListener("abort", cancel);
+        if (signal.aborted || failed) reject(new Error("Simulator control failed."));
+        else resolve(code2);
+      });
+    });
+  }
+  let code;
+  switch (control.kind) {
+    case "prepare-buttons":
+    case "button":
+      throw new Error("Simulator buttons require the owned guest service.");
+    case "prepare-keyboard":
+      code = await run([
+        "simctl",
+        "spawn",
+        udid,
+        "defaults",
+        "write",
+        "com.apple.Preferences",
+        "AutomaticMinimizationEnabled",
+        "-bool",
+        "false"
+      ]);
+      if (code === 0)
+        code = await run([
+          "simctl",
+          "spawn",
+          udid,
+          "notifyutil",
+          "-p",
+          "com.apple.keyboard.preferences.changed"
+        ]);
+      break;
+    case "text":
+      code = await run(
+        ["devicectl", "device", "pasteboard", "copy", "--device", udid],
+        control.text
+      );
+      if (code !== 0) code = await run(["simctl", "pbcopy", udid], control.text);
+      break;
+    case "shake":
+      code = await run([
+        "simctl",
+        "spawn",
+        udid,
+        "notifyutil",
+        "-p",
+        "com.apple.UIKit.SimulatorShake"
+      ]);
+      break;
+    case "appearance":
+      code = await run(["simctl", "ui", udid, "appearance", control.appearance]);
+      break;
+    case "open-url":
+      code = await run(["simctl", "openurl", udid, control.url]);
+      break;
+  }
+  if (code !== 0) throw new Error("Simulator control failed.");
+}
+const abort = new AbortController();
+const stop = () => abort.abort();
+const buttons = createGuestButtons(abort.signal);
+process.on("disconnect", stop);
+let pendingHostControl;
+const onMessage = (raw) => {
+  const request = object({
+    type: literal("control"),
+    id: number().int().positive(),
+    udid: string().uuid(),
+    control: union([
+      IosSimulatorDeviceControlSchema,
+      object({ kind: _enum(["prepare-keyboard", "prepare-buttons"]) }).strict()
+    ])
+  }).strict().safeParse(raw);
+  if (!request.success || pendingHostControl || abort.signal.aborted) {
+    stop();
+    return;
+  }
+  const { id, udid, control } = request.data;
+  if (!(control.kind === "button" && ["home", "app-switcher", "lock"].includes(control.button)) && control.kind !== "text" && control.kind !== "appearance" && control.kind !== "open-url" && control.kind !== "shake" && control.kind !== "prepare-buttons" && control.kind !== "prepare-keyboard") {
+    stop();
+    return;
+  }
+  pendingHostControl = (control.kind === "prepare-buttons" ? buttons.prepare(udid) : control.kind === "button" ? buttons.press(udid, _enum(["home", "app-switcher", "lock"]).parse(control.button)) : runSimulatorHostControl(
+    udid,
+    control,
+    AbortSignal.any([abort.signal, AbortSignal.timeout(1e4)])
+  )).then(
+    () => {
+      if (process.connected) process.send?.({ type: "control-result", id, success: true });
+    },
+    () => {
+      if (process.connected) process.send?.({ type: "control-result", id, success: false });
+    }
+  ).finally(() => {
+    pendingHostControl = void 0;
+  });
+};
+process.on("message", onMessage);
+process.once("SIGTERM", stop);
+process.once("SIGINT", stop);
+let child;
+let exited;
+try {
+  if (!process.connected) throw new Error("Missing lifecycle owner");
+  const binary = string().min(1).parse(process.argv[2]);
+  const reservation = createServer();
+  await new Promise((resolve, reject) => {
+    reservation.once("error", reject);
+    reservation.listen(0, "127.0.0.1", resolve);
+  });
+  const address = reservation.address();
+  if (!address || typeof address === "string") throw new Error("Port allocation failed");
+  const port = address.port;
+  await new Promise(
+    (resolve, reject) => reservation.close((error) => error ? reject(error) : resolve())
+  );
+  abort.signal.throwIfAborted();
+  child = spawn(binary, ["serve", "--host", "127.0.0.1", "--port", String(port), "--no-plugins"], {
+    // Isolate the native server and its xcrun descendants in our own process group.
+    detached: true,
+    stdio: "ignore",
+    env: process.env
+  });
+  exited = new Promise((resolve) => {
+    child?.once("error", () => {
+      stop();
+      resolve();
+    });
+    child?.once("exit", () => {
+      stop();
+      resolve();
+    });
+  });
+  const signal = AbortSignal.any([abort.signal, AbortSignal.timeout(3e4)]);
+  while (true) {
+    signal.throwIfAborted();
+    try {
+      const response = await fetch(`http://127.0.0.1:${port}/simulators`, {
+        signal: AbortSignal.any([signal, AbortSignal.timeout(1e3)])
+      });
+      await response.body?.cancel();
+      if (response.ok) break;
+    } catch {
+      signal.throwIfAborted();
+    }
+    await setTimeout$1(100, void 0, { signal });
+  }
+  process.send?.({ type: "ready", port });
+  await new Promise((resolve) => {
+    if (abort.signal.aborted) resolve();
+    else abort.signal.addEventListener("abort", () => resolve(), { once: true });
+  });
+} catch {
+  process.exitCode = 1;
+} finally {
+  stop();
+  await pendingHostControl;
+  await buttons.close().catch(() => {
+    process.exitCode = 1;
+  });
+  if (child?.pid !== void 0) {
+    const group = -child.pid;
+    const signalGroup = (signal) => {
+      try {
+        process.kill(group, signal);
+        return true;
+      } catch (error) {
+        if (error instanceof Error && "code" in error && error.code === "ESRCH") return false;
+        throw error;
+      }
+    };
+    if (signalGroup("SIGTERM")) {
+      const killAt = Date.now() + 3e3;
+      while (signalGroup(0)) {
+        if (Date.now() >= killAt) signalGroup("SIGKILL");
+        await setTimeout$1(25);
+      }
+    }
+    await exited;
+  }
+  process.removeListener("disconnect", stop);
+  process.removeListener("message", onMessage);
+  if (process.connected) process.disconnect();
+}
+//# sourceMappingURL=baguette-worker.js.map

package/dist/chunks/{acp-BzvviK-N.js → acp-C0LiROfB.js}

@@ -1,5 +1,5 @@
 import { pathToFileURL } from "node:url";
-import { c as array, u as unknown, N as NEVER, e as union, n as number, s as string, o as object, r as record, Q as int, l as literal, b as boolean, E as intersection, H as url } from "./schemas-WuyisFi9.js";
+import { b as array, u as unknown, N as NEVER, e as union, n as number, s as string, o as object, r as record, Q as int, l as literal, c as boolean, D as intersection, H as url } from "./schemas-D_XLKCXC.js";
 const DEEPSEEK_HARNESS_PERMISSION_PRESETS = [
   {
     id: "read-only",
@@ -53,7 +53,7 @@ const ACP_EXTENSION_DSH_VERSION = "0.2.0";
 const DEEPSEEK_HARNESS_VERSION = "0.1.5-rc.2";
 const DEEPSEEK_HARNESS_PI_AI_VERSION = "0.85.1";
 const DEEPSEEK_HARNESS_SCHEMASTERY_VERSION = "3.18.2";
-const ACP_EXTENSION_DSH_PROFILE_REVISION = "v14";
+const ACP_EXTENSION_DSH_PROFILE_REVISION = "v15";
 const ACP_EXTENSION_DSH_SESSION_ROOT_ENV = "ACP_EXTENSION_DSH_SESSION_ROOT";
 const ACP_EXTENSION_DSH_QUERY_PATH_ENV = "ACP_EXTENSION_DSH_QUERY_PATH";
 const DEEPSEEK_HARNESS_DEFAULT_SESSION_COMPRESSION = "zstd";
@@ -4943,4 +4943,4 @@ export {
   DEEPSEEK_HARNESS_DEFAULT_MODEL as q,
   DEEPSEEK_HARNESS_PROVIDER as r
 };
-//# sourceMappingURL=acp-BzvviK-N.js.map
+//# sourceMappingURL=acp-C0LiROfB.js.map

package/dist/chunks/{cloudflared-native-DbUToPHH.js → cloudflared-native-BWtpTE_5.js}

@@ -2,7 +2,7 @@ import { spawn } from "node:child_process";
 import { mkdtemp, writeFile, rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { o as object, a as _enum, s as string } from "./schemas-WuyisFi9.js";
+import { o as object, a as _enum, s as string } from "./schemas-D_XLKCXC.js";
 class CloudflaredError extends Error {
   constructor(stage, message, cause) {
     super(message, { cause });
@@ -76,7 +76,7 @@ async function startCloudflaredNative(options) {
         "--metrics",
         "127.0.0.1:0",
         "--protocol",
-        "auto",
+        "http2",
         "--url",
         proxy.origin
       ],
@@ -237,4 +237,4 @@ export {
   CloudflaredError as C,
   startCloudflaredNative as s
 };
-//# sourceMappingURL=cloudflared-native-DbUToPHH.js.map
+//# sourceMappingURL=cloudflared-native-BWtpTE_5.js.map

package/dist/chunks/{daemon-session-tools-DESvdAeY.js → daemon-session-tools-C6AE_3JK.js}

@@ -7,7 +7,7 @@ import "fs";
 import "crypto";
 import "node:os";
 import "node:path";
-import "./schemas-WuyisFi9.js";
+import "./schemas-D_XLKCXC.js";
 import "node:events";
 import "node:child_process";
 import "node:process";
@@ -28,8 +28,9 @@ import "node:fs/promises";
 import "node:zlib";
 import "child_process";
 import "./plan-mode-D0D5cnMs.js";
-import "./acp-BzvviK-N.js";
+import "./acp-C0LiROfB.js";
 import "node:url";
+import "./ios-simulator-hTbW-tat.js";
 import "./subagent-events-BJ9JwZva.js";
 import "./loro_wasm_bg-DIxpLA2J.js";
 import "perf_hooks";
@@ -52,19 +53,21 @@ import "node:util/types";
 import "node:worker_threads";
 import "node:console";
 import "node:dns";
-import "./directory-handle-CtdCjbNh.js";
-import "./diff-line-counts-DDGc5P-T.js";
 import "node:stream/promises";
 import "node:string_decoder";
+import "async_hooks";
+import "./cloudflared-native-BWtpTE_5.js";
+import "node:dns/promises";
+import "dgram";
+import "timers/promises";
+import "node:timers/promises";
+import "./directory-handle-DgcESjFj.js";
+import "./diff-line-counts-DDGc5P-T.js";
 import "./package-BoOO46ct.js";
 import "./session-DyqwlJbY.js";
-import "async_hooks";
 import "module";
 import "./diff-worker-task-MZsLArT5.js";
 import "./workspace-watch-protocol-POg9Lpeq.js";
-import "node:dns/promises";
-import "./cloudflared-native-DbUToPHH.js";
-import "node:timers/promises";
 import "node:module";
 import "node:v8";
 import "http2";
@@ -94,4 +97,4 @@ async function executeDaemonSessionTool(context, name, args) {
 export {
   executeDaemonSessionTool
 };
-//# sourceMappingURL=daemon-session-tools-DESvdAeY.js.map
+//# sourceMappingURL=daemon-session-tools-C6AE_3JK.js.map