@craftsamo/whatsapp-tools 0.1.0 → 0.1.2

package/dist/cli.js

@@ -26,6 +26,12 @@ var PROJECT = {
   toolsets: ["account", "chats", "contacts", "history", "files", "sends", "actions"],
   /** The toolsets on when a setting names none. */
   defaultToolsets: ["account", "chats", "contacts", "history", "sends"],
+  /** The package's own settings, which the tools themselves read: each snake_case name and its type, with bounds when it needs them. */
+  options: {
+    state_dir: "path",
+    download_dir: "path",
+    send_dirs: "paths"
+  },
   /** The environment variables the tools read besides the settings, which Codex forwards to the server after them. */
   toolVariables: []
 };
@@ -5100,7 +5106,7 @@ var recursive = /* @__PURE__ */ new WeakMap();
 var NONE = 0;
 var ASSUMED = 1;
 var PROVEN = 2;
-function isRecursive(inst, stack, resolve8) {
+function isRecursive(inst, stack, resolve6) {
   const cached2 = recursive.get(inst);
   if (cached2 !== void 0)
     return cached2 ? PROVEN : NONE;
@@ -5110,7 +5116,7 @@ function isRecursive(inst, stack, resolve8) {
   let result = NONE;
   const check2 = (child) => {
     if (result !== PROVEN && child?._zod) {
-      const answer = isRecursive(child, stack, resolve8);
+      const answer = isRecursive(child, stack, resolve6);
       if (answer > result)
         result = answer;
     }
@@ -5121,7 +5127,7 @@ function isRecursive(inst, stack, resolve8) {
       const desc = Object.getOwnPropertyDescriptor(sh, key);
       if (spread && !desc.enumerable)
         continue;
-      const child = desc.get ? ASSUMED : desc.value?._zod ? isRecursive(desc.value, stack, resolve8) : NONE;
+      const child = desc.get ? ASSUMED : desc.value?._zod ? isRecursive(desc.value, stack, resolve6) : NONE;
       if (child > answer)
         answer = child;
     }
@@ -5185,7 +5191,7 @@ function isRecursive(inst, stack, resolve8) {
       break;
     // `$ZodLazy` caches its inner on the def, so a resolved edge is followed exactly
     case "lazy": {
-      const inner = def._cachedInner ?? (resolve8 ? inst._zod.innerType : void 0);
+      const inner = def._cachedInner ?? (resolve6 ? inst._zod.innerType : void 0);
       merge2(inner ? isRecursive(inner, stack, false) : ASSUMED);
       break;
     }
@@ -20147,7 +20153,7 @@ function abortError(signal) {
 }
 function exec(argv, options) {
   const { signal } = options;
-  return new Promise((resolve8, reject) => {
+  return new Promise((resolve6, reject) => {
     if (signal?.aborted) {
       reject(abortError(signal));
       return;
@@ -20206,7 +20212,7 @@ function exec(argv, options) {
     }
     const finish = () => settle3(() => {
       const { code, killedBy } = exitedWith ?? { code: null, killedBy: null };
-      resolve8({
+      resolve6({
         code: code ?? -1,
         stdout,
         stderr,
@@ -22709,7 +22715,7 @@ function callService(paths, op, args, { mode, signal, timeoutMs: requestedMs = D
   if (signal?.aborted) return Promise.reject(abortError(signal));
   const timeoutMs = Number.isNaN(requestedMs) ? DEFAULT_TIMEOUT_MS2 : Math.min(Math.max(Math.ceil(requestedMs), 1), MAX_DEADLINE_MS);
   const request = encodeLine({ op, args, deadline_ms: timeoutMs });
-  return new Promise((resolve8, reject) => {
+  return new Promise((resolve6, reject) => {
     const socket = createConnection(paths.socket);
     socket.setEncoding("utf8");
     let sent = false;
@@ -22754,7 +22760,7 @@ function callService(paths, op, args, { mode, signal, timeoutMs: requestedMs = D
       if (end === -1) return;
       const response = parseResponse(received.slice(0, end));
       if (!response) return unknownOutcome2("The sync service's answer could not be read");
-      if (response.ok) return finish(() => resolve8(response.data));
+      if (response.ok) return finish(() => resolve6(response.data));
       fail(new ToolError(response.error.code, response.error.message));
     });
     socket.on("error", (error62) => {
@@ -27798,6 +27804,35 @@ var ALL_TRANSLATIONS = mergeTranslations(
   FACT_TRANSLATIONS
 );
 
+// src/entry/directory.ts
+import { homedir as homedir3 } from "node:os";
+import { isAbsolute as isAbsolute6, resolve as resolve4 } from "node:path";
+var DOWNLOADS_DIR = "Downloads";
+function homeDir(env7) {
+  const envHome = env7.HOME;
+  if (envHome && isAbsolute6(envHome)) return envHome;
+  return homedir3();
+}
+function pathOf(value) {
+  return typeof value === "string" ? value : void 0;
+}
+function pathsOf(value) {
+  return typeof value === "object" ? value : [];
+}
+function directorySettings(options, env7, profile) {
+  const home = homeDir(env7);
+  const xdg = env7.XDG_STATE_HOME;
+  const stateHome = xdg && isAbsolute6(xdg) ? xdg : resolve4(home, ".local", "state");
+  return {
+    state_dir: pathOf(options.state_dir) ?? resolve4(stateHome, profile.name),
+    download_dir: pathOf(options.download_dir) ?? resolve4(home, DOWNLOADS_DIR, profile.name),
+    send_dirs: [...new Set(pathsOf(options.send_dirs))]
+  };
+}
+function toolDirectories(settings) {
+  return { stateDir: settings.state_dir, downloadDir: settings.download_dir, sendDirs: settings.send_dirs };
+}
+
 // src/entry/errors.ts
 function errorBody(code, message, details) {
   return { code, message, ...details !== void 0 && { details } };
@@ -27903,9 +27938,9 @@ async function timedCallDescription(spec, args, ctx, timeoutMs = DESCRIBE_TIMEOU
   let timer;
   let onAbort;
   try {
-    const timedOut = new Promise((resolve8) => {
+    const timedOut = new Promise((resolve6) => {
       timer = setTimeout(() => {
-        resolve8(void 0);
+        resolve6(void 0);
         controller.abort();
       }, timeoutMs);
     });
@@ -27955,63 +27990,13 @@ async function checkPin(spec, args, ctx, pin, timeoutMs = DESCRIBE_TIMEOUT_MS) {
 var PROJECT_PROFILE = {
   name: PROJECT.name,
   envPrefix: PROJECT.envPrefix,
-  toolsets: { names: PROJECT.toolsets, defaults: PROJECT.defaultToolsets }
+  toolsets: { names: PROJECT.toolsets, defaults: PROJECT.defaultToolsets },
+  options: PROJECT.options
 };
 
-// src/entry/directory.ts
-import { homedir as homedir3 } from "node:os";
-import { isAbsolute as isAbsolute6, join as join12, resolve as resolve4, sep as sep4 } from "node:path";
-function homeDir(env7) {
-  const envHome = env7.HOME;
-  if (envHome && isAbsolute6(envHome)) return envHome;
-  return homedir3();
-}
-function expandTilde(text2, home) {
-  if (text2 === "~") return home;
-  if (text2.startsWith("~/") || text2.startsWith(`~${sep4}`)) {
-    return join12(home, text2.slice(2));
-  }
-  return text2;
-}
-function resolveGivenDirectory(given, home) {
-  const text2 = given.text.trim();
-  const expanded = expandTilde(text2, home);
-  if (!text2 || !isAbsolute6(expanded)) {
-    throw new ToolError("invalid_argument", `${given.source} must be an absolute path.`);
-  }
-  return resolve4(expanded);
-}
-function toolDirectories(settings) {
-  return { stateDir: settings.state_dir, downloadDir: settings.download_dir, sendDirs: settings.send_dirs };
-}
-
-// src/entry/download-dir.ts
-import { resolve as resolve5 } from "node:path";
-var DOWNLOADS_DIR = "Downloads";
-function resolveDownloadDir(given, env7, profile) {
-  const home = homeDir(env7);
-  return given !== void 0 ? resolveGivenDirectory(given, home) : resolve5(home, DOWNLOADS_DIR, profile.name);
-}
-
-// src/entry/send-dirs.ts
-function resolveSendDirs(given, env7) {
-  const home = homeDir(env7);
-  return [...new Set(given.map((directory) => resolveGivenDirectory(directory, home)))];
-}
-
-// src/entry/state-dir.ts
-import { isAbsolute as isAbsolute7, resolve as resolve6 } from "node:path";
-function resolveStateDir(given, env7, profile) {
-  const home = homeDir(env7);
-  if (given !== void 0) return resolveGivenDirectory(given, home);
-  const xdg = env7.XDG_STATE_HOME;
-  if (xdg && isAbsolute7(xdg)) {
-    return resolve6(xdg, profile.name);
-  }
-  return resolve6(home, ".local", "state", profile.name);
-}
-
 // src/entry/settings.ts
+import { homedir as homedir4 } from "node:os";
+import { isAbsolute as isAbsolute7, join as join12, resolve as resolvePath, sep as sep4 } from "node:path";
 var CONFIRM_MODES = ["harness", "elicitation"];
 var ALL_TOOLSETS = "all";
 var TRUE_VALUES = ["1", "true"];
@@ -28021,17 +28006,28 @@ var OPTIONS = {
   read_only: { flag: "--read-only", envSuffix: "READ_ONLY", boolean: true },
   tools: { flag: "--tools", envSuffix: "TOOLS" },
   exclude_tools: { flag: "--exclude-tools", envSuffix: "EXCLUDE_TOOLS" },
-  confirm: { flag: "--confirm", envSuffix: "CONFIRM" },
-  state_dir: { flag: "--state-dir", envSuffix: "STATE_DIR" },
-  download_dir: { flag: "--download-dir", envSuffix: "DOWNLOAD_DIR" },
-  send_dirs: { flag: "--send-dirs", envSuffix: "SEND_DIRS" }
+  confirm: { flag: "--confirm", envSuffix: "CONFIRM" }
 };
+function profileOptions(profile) {
+  return profile.options ?? {};
+}
+function settingOptions(profile) {
+  const toolOptions = Object.entries(profileOptions(profile)).map(([name, spec]) => [
+    name,
+    {
+      flag: `--${name.replace(/_/g, "-")}`,
+      envSuffix: name.toUpperCase(),
+      ...optionType(spec) === "boolean" && { boolean: true }
+    }
+  ]);
+  return { ...OPTIONS, ...Object.fromEntries(toolOptions) };
+}
 function envName(name, profile) {
-  return `${profile.envPrefix}_${OPTIONS[name].envSuffix}`;
+  return `${profile.envPrefix}_${settingOptions(profile)[name].envSuffix}`;
 }
-function readFlags(argv) {
+function readFlags(argv, profile) {
   const byFlag = new Map(
-    Object.keys(OPTIONS).map((name) => [OPTIONS[name].flag, { name, ...OPTIONS[name] }])
+    Object.entries(settingOptions(profile)).map(([name, option]) => [option.flag, { name, ...option }])
   );
   const given = {};
   for (let i = 0; i < argv.length; i++) {
@@ -28056,9 +28052,6 @@ function readFlags(argv) {
 function splitList(value) {
   return value.split(",").map((item) => item.trim()).filter((item) => item !== "");
 }
-function listedDirectories(given) {
-  return given === void 0 ? [] : splitList(given.text).map((text2) => ({ text: text2, source: given.source }));
-}
 function checkToolsets(names, source, toolsets) {
   if (names.includes(ALL_TOOLSETS)) return ALL_TOOLSETS;
   const unknown2 = names.find((name) => !toolsets.names.includes(name));
@@ -28087,20 +28080,108 @@ function parseConfirm(value, source) {
   }
   return mode;
 }
+function parseNumber2(value, source) {
+  const trimmed = value.trim();
+  const parsed = trimmed === "" ? Number.NaN : Number(trimmed);
+  if (!Number.isFinite(parsed)) {
+    throw new ToolError("invalid_argument", `Unknown number "${value}" in ${source}; use a finite number.`);
+  }
+  return parsed;
+}
+function absolutePath(text2, source, env7) {
+  const home = env7.HOME !== void 0 && isAbsolute7(env7.HOME) ? env7.HOME : homedir4();
+  const expanded = text2 === "~" || text2.startsWith("~/") || text2.startsWith(`~${sep4}`) ? join12(home, text2.slice(1)) : text2;
+  if (!isAbsolute7(expanded)) throw new ToolError("invalid_argument", `${source} must be an absolute path.`);
+  return resolvePath(expanded);
+}
+function absolutePaths(items, source, env7) {
+  return items.length > 0 ? items.map((item) => absolutePath(item, source, env7)) : void 0;
+}
 function envText(name, env7, profile) {
   const variable = envName(name, profile);
   const text2 = env7[variable];
   return text2 === void 0 || text2.trim() === "" ? void 0 : { text: text2, source: variable };
 }
+function optionType(spec) {
+  return typeof spec === "string" ? spec : spec.type;
+}
+function itemCount(count) {
+  return count === 1 ? "1 item" : `${count} items`;
+}
+function numberBoundsError({ integer: integer2, min, max }, source) {
+  const range = min !== void 0 && max !== void 0 ? ` from ${min} to ${max}` : min !== void 0 ? ` of at least ${min}` : max !== void 0 ? ` of at most ${max}` : "";
+  return new ToolError("invalid_argument", `${source} must be ${integer2 ? "a whole number" : "a number"}${range}.`);
+}
+function countBoundsError({ min, max }, source) {
+  const range = min !== void 0 && max !== void 0 ? `from ${min} to ${max} items` : min !== void 0 ? `at least ${itemCount(min)}` : `at most ${itemCount(max)}`;
+  return new ToolError("invalid_argument", `${source} must list ${range}.`);
+}
+function withinBounds(spec, value, source) {
+  if (value === void 0 || typeof spec === "string") return value;
+  const bounds = spec;
+  const { integer: integer2, min, max } = bounds;
+  if (typeof value === "number") {
+    if (integer2 && !Number.isInteger(value) || min !== void 0 && value < min || max !== void 0 && value > max) {
+      throw numberBoundsError(bounds, source);
+    }
+  } else if (typeof value === "object" && (min !== void 0 && value.length < min || max !== void 0 && value.length > max)) {
+    throw countBoundsError(bounds, source);
+  }
+  return value;
+}
+function parseOptionText(spec, given, env7) {
+  return withinBounds(spec, parseTypedText(optionType(spec), given, env7), given.source);
+}
+function parseTypedText(kind, given, env7) {
+  switch (kind) {
+    case "text":
+      return nonBlank(given.text);
+    case "boolean":
+      return parseBoolean(given.text, given.source);
+    case "number":
+      return parseNumber2(given.text, given.source);
+    case "list": {
+      const items = splitList(given.text);
+      return items.length > 0 ? items : void 0;
+    }
+    case "path": {
+      const text2 = nonBlank(given.text);
+      return text2 === void 0 ? void 0 : absolutePath(text2, given.source, env7);
+    }
+    case "paths":
+      return absolutePaths(splitList(given.text), given.source, env7);
+  }
+}
+function optionsFrom(flags, env7, profile) {
+  const options = {};
+  for (const [name, spec] of Object.entries(profileOptions(profile))) {
+    if (flags[name] !== void 0) {
+      const parsed = parseOptionText(spec, { text: flags[name], source: settingOptions(profile)[name].flag }, env7);
+      if (parsed !== void 0) options[name] = parsed;
+      continue;
+    }
+    const fromEnv = envText(name, env7, profile);
+    if (fromEnv !== void 0) {
+      const parsed = parseOptionText(spec, fromEnv, env7);
+      if (parsed !== void 0) options[name] = parsed;
+    }
+  }
+  return options;
+}
+function parseToolOptions(argv, env7, profile = PROJECT_PROFILE) {
+  const flags = readFlags(argv, profile);
+  const known = profileOptions(profile);
+  const other = Object.keys(flags).find((name) => !(name in known));
+  if (other !== void 0) {
+    throw new ToolError("invalid_argument", `Unknown option "${settingOptions(profile)[other].flag}".`);
+  }
+  return optionsFrom(flags, env7, profile);
+}
 function parseSettings(argv, env7, profile = PROJECT_PROFILE) {
-  const flags = readFlags(argv);
+  const flags = readFlags(argv, profile);
   const value = (name) => flags[name] !== void 0 ? { text: flags[name], source: OPTIONS[name].flag } : envText(name, env7, profile);
-  const settings = {
-    confirm: "harness",
-    state_dir: resolveStateDir(value("state_dir"), env7, profile),
-    download_dir: resolveDownloadDir(value("download_dir"), env7, profile),
-    send_dirs: resolveSendDirs(listedDirectories(value("send_dirs")), env7)
-  };
+  const options = optionsFrom(flags, env7, profile);
+  const settings = { confirm: "harness", ...directorySettings(options, env7, profile), options };
   const toolsets = value("toolsets");
   if (toolsets) settings.toolsets = checkToolsets(splitList(toolsets.text), toolsets.source, profile.toolsets);
   const readOnly = value("read_only");
@@ -28125,38 +28206,6 @@ function parseToolSettings(argv, env7, profile = PROJECT_PROFILE) {
   );
   return settings;
 }
-function parseStateDir(argv, env7, profile = PROJECT_PROFILE) {
-  const flags = readFlags(argv);
-  const other = Object.keys(flags).find((name) => name !== "state_dir");
-  if (other !== void 0)
-    throw new ToolError("invalid_argument", `Option ${OPTIONS[other].flag} is not available here.`);
-  const given = flags.state_dir !== void 0 ? { text: flags.state_dir, source: OPTIONS.state_dir.flag } : void 0;
-  return resolveStateDir(given ?? envText("state_dir", env7, profile), env7, profile);
-}
-var DIRECTORY_OPTION_NAMES = ["state_dir", "download_dir", "send_dirs"];
-function parseDirectorySettings(argv, env7, profile = PROJECT_PROFILE) {
-  const flags = readFlags(argv);
-  const other = Object.keys(flags).find((name) => !DIRECTORY_OPTION_NAMES.includes(name));
-  if (other !== void 0)
-    throw new ToolError("invalid_argument", `Option ${OPTIONS[other].flag} is not available here.`);
-  const value = (name) => flags[name] !== void 0 ? { text: flags[name], source: OPTIONS[name].flag } : envText(name, env7, profile);
-  return {
-    state_dir: resolveStateDir(value("state_dir"), env7, profile),
-    download_dir: resolveDownloadDir(value("download_dir"), env7, profile),
-    send_dirs: resolveSendDirs(listedDirectories(value("send_dirs")), env7)
-  };
-}
-var TOOL_OPTION_NAMES = [
-  "toolsets",
-  "read_only",
-  "tools",
-  "exclude_tools",
-  "state_dir",
-  "download_dir",
-  "send_dirs"
-];
-var LANGUAGE_OPTION = "language";
-var PLUGIN_OPTION_NAMES = [...TOOL_OPTION_NAMES, LANGUAGE_OPTION];
 function languageVariable(profile = PROJECT_PROFILE) {
   return `${profile.envPrefix}_LANGUAGE`;
 }
@@ -28183,6 +28232,7 @@ async function defaultReadLine(prompt) {
 }
 
 // src/cli/command-args.ts
+var STATE_DIR_OPTION = "state_dir";
 function usageError(message) {
   return new ToolError("invalid_argument", message);
 }
@@ -28231,7 +28281,10 @@ function parseFlagArgs(argv, spec) {
   return { values, switches, rest };
 }
 function parseCommandStateDir(rest, io) {
-  return parseStateDir(rest, io.env, io.profile ?? PROJECT_PROFILE);
+  const profile = io.profile ?? PROJECT_PROFILE;
+  const options = Object.entries(profile.options ?? {}).filter(([name]) => name === STATE_DIR_OPTION);
+  const stateOnly = { ...profile, options: Object.fromEntries(options) };
+  return directorySettings(parseToolOptions(rest, io.env, stateOnly), io.env, profile).state_dir;
 }
 
 // src/core/whatsapp/pairing.ts
@@ -28283,9 +28336,9 @@ function spawnError(error62) {
 }
 function spawnWacli(program, args, { env: env7, onStdoutLine, onStderrLine, onRawStderrLine, stopGraceMs = DEFAULT_STOP_GRACE_MS }) {
   const child = spawn2(program, args, { env: env7, shell: false, stdio: ["ignore", "pipe", "pipe"] });
-  const spawned = new Promise((resolve8) => {
-    child.once("spawn", () => resolve8(true));
-    child.once("error", () => resolve8(false));
+  const spawned = new Promise((resolve6) => {
+    child.once("spawn", () => resolve6(true));
+    child.once("error", () => resolve6(false));
   });
   const stdout = lineSplitter((line) => onStdoutLine?.(line));
   const stderr = lineSplitter((line) => {
@@ -28297,14 +28350,14 @@ function spawnWacli(program, args, { env: env7, onStdoutLine, onStderrLine, onRa
   let killTimer;
   let drainTimer;
   let ended2;
-  const exited = new Promise((resolve8, reject) => {
+  const exited = new Promise((resolve6, reject) => {
     const finish = () => {
       clearTimeout(drainTimer);
       child.stdout.destroy();
       child.stderr.destroy();
       stdout.flush();
       stderr.flush();
-      resolve8(ended2);
+      resolve6(ended2);
     };
     child.on("error", (error62) => {
       clearTimeout(killTimer);
@@ -28431,9 +28484,9 @@ async function runAuth(program, paths, phone, options) {
   });
   let timer;
   let onAbort;
-  const interrupted = new Promise((resolve8) => {
-    timer = setTimeout(() => resolve8("timeout"), timeoutMs);
-    onAbort = () => resolve8("abort");
+  const interrupted = new Promise((resolve6) => {
+    timer = setTimeout(() => resolve6("timeout"), timeoutMs);
+    onAbort = () => resolve6("abort");
     if (signal.aborted) onAbort();
     else signal.addEventListener("abort", onAbort, { once: true });
   });
@@ -29633,7 +29686,7 @@ import { realpathSync } from "node:fs";
 
 // src/cli/service-program.ts
 import { access as access2, constants as constants6, realpath as realpath7, stat as stat5 } from "node:fs/promises";
-import { isAbsolute as isAbsolute8, join as join16, resolve as resolve7, sep as sep5 } from "node:path";
+import { isAbsolute as isAbsolute8, join as join16, resolve as resolve5, sep as sep5 } from "node:path";
 var PROBE_TIMEOUT_MS = 1e4;
 var PROGRAM_NAME2 = "node";
 var PROBE_ARGS = ["-p", "process.execPath"];
@@ -29666,7 +29719,7 @@ async function resolveRoots(roots) {
   const resolved = /* @__PURE__ */ new Set();
   for (const root of roots) {
     if (root === "" || !isAbsolute8(root)) continue;
-    resolved.add(resolve7(root));
+    resolved.add(resolve5(root));
     try {
       resolved.add(await realpath7(root));
     } catch {
@@ -29697,7 +29750,7 @@ async function pickStableProgram(options) {
     if (dir !== "" && isAbsolute8(dir)) candidates.add(join16(dir, PROGRAM_NAME2));
   }
   for (const candidate of candidates) {
-    if (pathHoldsVersion(candidate, version2) || isUnder(resolve7(candidate), volatileRoots)) continue;
+    if (pathHoldsVersion(candidate, version2) || isUnder(resolve5(candidate), volatileRoots)) continue;
     if (!await isExecutableFile2(candidate)) continue;
     let started;
     try {
@@ -29959,8 +30012,10 @@ import { setTimeout as delay3 } from "node:timers/promises";
 // src/core/whatsapp/service-socket.ts
 import { chmod as chmod5, rm as rm6 } from "node:fs/promises";
 import { createServer } from "node:net";
+import { clearTimeout as clearTimeout2, setTimeout as setTimeout4 } from "node:timers";
 var MAX_REQUEST_BYTES = 1048576;
 var REQUEST_READ_TIMEOUT_MS = 1e4;
+var CLOSE_GRACE_MS = 1e3;
 var MAX_QUOTED_OP = 40;
 var MAX_LOGGED_ERROR = 200;
 var SOCKET_MODE = 384;
@@ -30079,11 +30134,11 @@ async function listenOnServiceSocket(path, options) {
     });
   });
   await rm6(path, { force: true });
-  await new Promise((resolve8, reject) => {
+  await new Promise((resolve6, reject) => {
     server.once("error", reject);
     server.listen(path, () => {
       server.off("error", reject);
-      resolve8();
+      resolve6();
     });
   });
   try {
@@ -30097,9 +30152,16 @@ async function listenOnServiceSocket(path, options) {
     close() {
       closing ??= (async () => {
         shutdown.abort();
-        const closed = new Promise((resolve8) => server.close(() => resolve8()));
+        const closed = new Promise((resolve6) => server.close(() => resolve6()));
         await queue;
         for (const socket of sockets) socket.end(() => socket.destroy());
+        let timer;
+        const grace = new Promise((resolve6) => {
+          timer = setTimeout4(resolve6, CLOSE_GRACE_MS).unref();
+        });
+        await Promise.race([closed, grace]);
+        clearTimeout2(timer);
+        for (const socket of sockets) socket.destroy();
         await closed;
         await rm6(path, { force: true });
       })();
@@ -30127,7 +30189,7 @@ var Ending = class {
   };
   result;
   constructor() {
-    this.promise = new Promise((resolve8) => this.resolve = resolve8);
+    this.promise = new Promise((resolve6) => this.resolve = resolve6);
   }
   /** Aborts once the run has ended, so waits and operations still going give up. */
   get signal() {
@@ -30186,7 +30248,7 @@ function startSyncChild(options) {
   let stoppedByService = false;
   let markReady = () => {
   };
-  const ready = new Promise((resolve8) => markReady = resolve8);
+  const ready = new Promise((resolve6) => markReady = resolve6);
   const wacli2 = spawnWacli(program, syncArgv(paths), {
     env: wacliEnv(env7, paths),
     stopGraceMs,
@@ -30213,11 +30275,11 @@ function startSyncChild(options) {
   };
 }
 function waitUntilReady(child, signal) {
-  return new Promise((resolve8) => {
-    if (signal.aborted) return resolve8(false);
+  return new Promise((resolve6) => {
+    if (signal.aborted) return resolve6(false);
     const finish = (ready) => {
       signal.removeEventListener("abort", onAbort);
-      resolve8(ready);
+      resolve6(ready);
     };
     const onAbort = () => finish(false);
     signal.addEventListener("abort", onAbort, { once: true });
@@ -30526,9 +30588,17 @@ function takeFlag(argv, flag2) {
 }
 function parseCommand(argv, io) {
   const profile = io.profile ?? PROJECT_PROFILE;
+  const select = (flags) => {
+    const settings = parseToolSettings(flags, io.env, profile);
+    return {
+      selected: selectTools(io.specs, settings, profile.toolsets),
+      directories: toolDirectories(settings),
+      options: settings.options
+    };
+  };
   const [name, ...args] = argv;
   if (name === "list") {
-    return { name, selected: selectTools(io.specs, parseToolSettings(args, io.env, profile), profile.toolsets) };
+    return { name, selected: select(args).selected };
   }
   if (name !== "run" && name !== "target") {
     const given = name === void 0 ? "No command given" : `Unknown command "${name}"`;
@@ -30542,28 +30612,22 @@ function parseCommand(argv, io) {
   if (cwd === void 0) throw usageError(`Command ${name} needs ${CWD_FLAG} <dir>.`);
   if (name === "target") {
     const { value: language, rest: afterLanguage } = takeFlag(rest, LANGUAGE_FLAG);
-    const { value: harnessLanguage, rest: directoryOptions } = takeFlag(afterLanguage, HARNESS_LANGUAGE_FLAG);
+    const { value: harnessLanguage, rest: targetSettings } = takeFlag(afterLanguage, HARNESS_LANGUAGE_FLAG);
+    const toolOptions = parseToolOptions(targetSettings, io.env, profile);
     return {
       name,
       toolId,
       cwd,
-      directories: toolDirectories(parseDirectorySettings(directoryOptions, io.env, profile)),
-      language: promptLanguage(language, io.env, harnessLanguage, profile)
+      directories: toolDirectories(directorySettings(toolOptions, io.env, profile)),
+      language: promptLanguage(language, io.env, harnessLanguage, profile),
+      options: toolOptions
     };
   }
   const { value: pin, rest: selection } = takeFlag(rest, PIN_FLAG);
   if (pin !== void 0 && !PIN_PATTERN.test(pin)) {
     throw usageError(`Option ${PIN_FLAG} needs the 64 lowercase hexadecimal digits \`target\` answered with.`);
   }
-  const settings = parseToolSettings(selection, io.env, profile);
-  return {
-    name,
-    toolId,
-    cwd,
-    pin,
-    selected: selectTools(io.specs, settings, profile.toolsets),
-    directories: toolDirectories(settings)
-  };
+  return { name, toolId, cwd, pin, ...select(selection) };
 }
 function describeSpec(spec) {
   return {
@@ -30605,6 +30669,7 @@ async function runTool(command, io) {
       ownDir: io.ownDir,
       ...command.directories,
       programName: PROJECT.name,
+      options: command.options,
       signal: io.signal
     };
     await checkPin(spec, args, ctx, command.pin, io.describeTimeoutMs);
@@ -30629,6 +30694,7 @@ async function targetOf5(command, io) {
       ownDir: io.ownDir,
       ...command.directories,
       programName: PROJECT.name,
+      options: command.options,
       signal: io.signal
     };
     const t = promptTranslator(io.translations ?? {}, command.language);