@craftsamo/whatsapp-tools 0.1.0 → 0.1.1

package/dist/opencode.js

@@ -25,6 +25,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: []
 };
@@ -5099,7 +5105,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;
@@ -5109,7 +5115,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;
     }
@@ -5120,7 +5126,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;
     }
@@ -5184,7 +5190,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;
     }
@@ -20117,7 +20123,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;
@@ -20176,7 +20182,7 @@ function exec(argv, options) {
     }
     const finish = () => settle2(() => {
       const { code, killedBy } = exitedWith ?? { code: null, killedBy: null };
-      resolve8({
+      resolve6({
         code: code ?? -1,
         stdout,
         stderr,
@@ -21882,7 +21888,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;
@@ -21927,7 +21933,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) => {
@@ -27034,9 +27040,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);
     });
@@ -27112,60 +27118,41 @@ ${JSON.stringify(error62.details)}` : ""}`;
 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/settings.ts
+import { homedir as homedir3 } from "node:os";
+import { isAbsolute as isAbsolute6, join as join11, resolve as resolvePath, sep as sep4 } from "node:path";
+
 // src/entry/directory.ts
 import { homedir as homedir2 } from "node:os";
-import { isAbsolute as isAbsolute5, join as join11, resolve as resolve4, sep as sep4 } from "node:path";
+import { isAbsolute as isAbsolute5, resolve as resolve4 } from "node:path";
+var DOWNLOADS_DIR = "Downloads";
 function homeDir(env7) {
   const envHome = env7.HOME;
   if (envHome && isAbsolute5(envHome)) return envHome;
   return homedir2();
 }
-function expandTilde(text2, home) {
-  if (text2 === "~") return home;
-  if (text2.startsWith("~/") || text2.startsWith(`~${sep4}`)) {
-    return join11(home, text2.slice(2));
-  }
-  return text2;
-}
-function resolveGivenDirectory(given, home) {
-  const text2 = given.text.trim();
-  const expanded = expandTilde(text2, home);
-  if (!text2 || !isAbsolute5(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 };
+function pathOf(value) {
+  return typeof value === "string" ? value : void 0;
 }
-
-// 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);
+function pathsOf(value) {
+  return typeof value === "object" ? value : [];
 }
-
-// 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 isAbsolute6, resolve as resolve6 } from "node:path";
-function resolveStateDir(given, env7, profile) {
+function directorySettings(options, env7, profile) {
   const home = homeDir(env7);
-  if (given !== void 0) return resolveGivenDirectory(given, home);
   const xdg = env7.XDG_STATE_HOME;
-  if (xdg && isAbsolute6(xdg)) {
-    return resolve6(xdg, profile.name);
-  }
-  return resolve6(home, ".local", "state", profile.name);
+  const stateHome = xdg && isAbsolute5(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/settings.ts
@@ -27177,20 +27164,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 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));
@@ -27209,30 +27204,85 @@ function parseBoolean(value, source) {
     `Unknown value "${value}" in ${source}; use one of ${[...TRUE_VALUES, ...FALSE_VALUES].join(", ")}.`
   );
 }
+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 && isAbsolute6(env7.HOME) ? env7.HOME : homedir3();
+  const expanded = text2 === "~" || text2.startsWith("~/") || text2.startsWith(`~${sep4}`) ? join11(home, text2.slice(1)) : text2;
+  if (!isAbsolute6(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 };
 }
-var TOOL_OPTION_NAMES = [
-  "toolsets",
-  "read_only",
-  "tools",
-  "exclude_tools",
-  "state_dir",
-  "download_dir",
-  "send_dirs"
-];
+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);
+  }
+}
+var TOOL_OPTION_NAMES = ["toolsets", "read_only", "tools", "exclude_tools"];
 function stringList(value) {
   return Array.isArray(value) && value.every((item) => typeof item === "string") ? value : void 0;
 }
 function optionError(name, expected) {
   return new ToolError("invalid_argument", `Option "${name}" must be ${expected}.`);
 }
-function directoryOption(name, value) {
-  if (typeof value !== "string") throw optionError(name, "an absolute path");
-  return value;
-}
 function toolsetsOption(value, toolsets) {
   if (value === ALL_TOOLSETS) return ALL_TOOLSETS;
   const names = stringList(value);
@@ -27251,7 +27301,9 @@ function listOption(name) {
   };
 }
 var LANGUAGE_OPTION = "language";
-var PLUGIN_OPTION_NAMES = [...TOOL_OPTION_NAMES, LANGUAGE_OPTION];
+function pluginOptionNames(profile) {
+  return [...TOOL_OPTION_NAMES, LANGUAGE_OPTION, ...Object.keys(profileOptions(profile))];
+}
 function languageVariable(profile = PROJECT_PROFILE) {
   return `${profile.envPrefix}_LANGUAGE`;
 }
@@ -27266,43 +27318,77 @@ function languageOption(value) {
   if (typeof value !== "string") throw optionError(LANGUAGE_OPTION, 'a language tag such as "ja"');
   return nonBlank(value);
 }
+function toolOption(name, spec, value, env7) {
+  return withinBounds(spec, toolOptionOfType(name, optionType(spec), value, env7), `Option "${name}"`);
+}
+function toolOptionOfType(name, kind, value, env7) {
+  switch (kind) {
+    case "text":
+      if (typeof value !== "string") throw optionError(name, "text");
+      return nonBlank(value);
+    case "boolean":
+      if (typeof value !== "boolean") throw optionError(name, "true or false");
+      return value;
+    case "number":
+      if (typeof value !== "number" || !Number.isFinite(value)) throw optionError(name, "a finite number");
+      return value;
+    case "list": {
+      const list = stringList(value);
+      if (!list) throw optionError(name, "a list of strings");
+      const items = list.map((item) => item.trim()).filter((item) => item !== "");
+      return items.length > 0 ? items : void 0;
+    }
+    case "path": {
+      if (typeof value !== "string") throw optionError(name, "an absolute path");
+      const text2 = nonBlank(value);
+      return text2 === void 0 ? void 0 : absolutePath(text2, `Option "${name}"`, env7);
+    }
+    case "paths": {
+      const list = stringList(value);
+      if (!list) throw optionError(name, "a list of absolute paths");
+      return absolutePaths(
+        list.flatMap((item) => nonBlank(item) ?? []),
+        `Option "${name}"`,
+        env7
+      );
+    }
+  }
+}
 function settingsFromOptions(options, env7, profile = PROJECT_PROFILE) {
   const given = options ?? {};
-  const unknown2 = Object.keys(given).find((name) => !PLUGIN_OPTION_NAMES.includes(name));
+  const names = pluginOptionNames(profile);
+  const unknown2 = Object.keys(given).find((name) => !names.includes(name));
   if (unknown2 !== void 0) {
-    throw new ToolError(
-      "invalid_argument",
-      `Unknown option "${unknown2}"; use one of ${PLUGIN_OPTION_NAMES.join(", ")}.`
-    );
+    throw new ToolError("invalid_argument", `Unknown option "${unknown2}"; use one of ${names.join(", ")}.`);
   }
-  const resolve8 = (name, fromOption, fromText) => {
+  const resolve6 = (name, fromOption, fromText) => {
     if (given[name] !== void 0) return fromOption(given[name]);
     const text2 = envText(name, env7, profile);
     return text2 !== void 0 ? fromText(text2) : void 0;
   };
-  const directoryGiven = (name) => given[name] !== void 0 ? { text: directoryOption(name, given[name]), source: `Option "${name}"` } : envText(name, env7, profile);
-  const sendDirsGiven = () => {
-    if (given.send_dirs === void 0) return listedDirectories(envText("send_dirs", env7, profile));
-    const list = stringList(given.send_dirs);
-    if (!list) throw optionError("send_dirs", "a list of absolute paths");
-    return list.map((text2) => ({ text: text2, source: 'Option "send_dirs"' }));
-  };
-  const settings = {
-    state_dir: resolveStateDir(directoryGiven("state_dir"), env7, profile),
-    download_dir: resolveDownloadDir(directoryGiven("download_dir"), env7, profile),
-    send_dirs: resolveSendDirs(sendDirsGiven(), env7)
-  };
-  const toolsets = resolve8(
+  const parsedOptions = {};
+  for (const [name, spec] of Object.entries(profileOptions(profile))) {
+    let parsed;
+    if (given[name] !== void 0) {
+      parsed = toolOption(name, spec, given[name], env7);
+    } else {
+      const fromEnv = envText(name, env7, profile);
+      if (fromEnv !== void 0) parsed = parseOptionText(spec, fromEnv, env7);
+    }
+    if (parsed !== void 0) parsedOptions[name] = parsed;
+  }
+  const settings = { ...directorySettings(parsedOptions, env7, profile), options: parsedOptions };
+  const toolsets = resolve6(
     "toolsets",
     (value) => toolsetsOption(value, profile.toolsets),
     ({ text: text2, source }) => checkToolsets(splitList(text2), source, profile.toolsets)
   );
   if (toolsets !== void 0) settings.toolsets = toolsets;
-  const readOnly = resolve8("read_only", booleanOption, ({ text: text2, source }) => parseBoolean(text2, source));
+  const readOnly = resolve6("read_only", booleanOption, ({ text: text2, source }) => parseBoolean(text2, source));
   if (readOnly !== void 0) settings.read_only = readOnly;
-  const tools = resolve8("tools", listOption("tools"), ({ text: text2 }) => splitList(text2));
+  const tools = resolve6("tools", listOption("tools"), ({ text: text2 }) => splitList(text2));
   if (tools !== void 0) settings.tools = tools;
-  const excluded = resolve8("exclude_tools", listOption("exclude_tools"), ({ text: text2 }) => splitList(text2));
+  const excluded = resolve6("exclude_tools", listOption("exclude_tools"), ({ text: text2 }) => splitList(text2));
   if (excluded !== void 0) settings.exclude_tools = excluded;
   const language = given[LANGUAGE_OPTION] !== void 0 ? languageOption(given[LANGUAGE_OPTION]) : promptLanguage(void 0, env7, void 0, profile);
   if (language !== void 0) settings.language = language;
@@ -27329,7 +27415,8 @@ function selectedTools(specs, options, deps) {
   return {
     tools: selectTools(specs, settings, profile.toolsets),
     directories: { ...toolDirectories(settings), programName: PROJECT.name },
-    translator: promptTranslator(deps.translations ?? {}, settings.language)
+    translator: promptTranslator(deps.translations ?? {}, settings.language),
+    options: settings.options
   };
 }
 async function runTool(spec, args, ctx, pin) {
@@ -27363,12 +27450,12 @@ ${lines.join("\n")}` : "";
 function workingDir(context) {
   return context.worktree && context.worktree !== "/" ? context.worktree : context.directory;
 }
-function v1Tool(spec, ownDir, directories, t) {
+function v1Tool(spec, ownDir, directories, t, options) {
   return {
     description: `${spec.description}${describeArguments(spec)}`,
     args: spec.input.shape,
     async execute(args, context) {
-      const ctx = { cwd: workingDir(context), ownDir, ...directories, signal: context.abort };
+      const ctx = { cwd: workingDir(context), ownDir, ...directories, options, signal: context.abort };
       let pin;
       if (needsPermission(spec)) {
         const approval = await approvalOf(spec, args, ctx, DESCRIBE_TIMEOUT_MS, t);
@@ -27388,16 +27475,16 @@ function v1Tool(spec, ownDir, directories, t) {
 }
 function createV1Server(specs, deps = {}) {
   return async function server(_input, options) {
-    const { tools, directories, translator: translator2 } = selectedTools(specs, options, deps);
+    const { tools, directories, translator: translator2, options: toolOptions } = selectedTools(specs, options, deps);
     const tool = {};
-    for (const spec of tools) tool[spec.id] = v1Tool(spec, deps.ownDir, directories, translator2);
+    for (const spec of tools) tool[spec.id] = v1Tool(spec, deps.ownDir, directories, translator2, toolOptions);
     return { tool };
   };
 }
 
 // src/opencode/skills.ts
 import { readFile as readFile2, readdir as readdir3 } from "node:fs/promises";
-import { join as join12, resolve as resolve7 } from "node:path";
+import { join as join12, resolve as resolve5 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 var SKILL_FILE = "SKILL.md";
 var FRONTMATTER = /^---[ \t]*\r?\n([\s\S]*?\r?\n)?---[ \t]*(?:\r?\n|$)/;
@@ -27488,7 +27575,7 @@ async function readSkillFile(path) {
   }
 }
 async function readSkills(dir) {
-  const root = resolve7(typeof dir === "string" ? dir : fileURLToPath2(dir));
+  const root = resolve5(typeof dir === "string" ? dir : fileURLToPath2(dir));
   let entries;
   try {
     entries = (await readdir3(root, { withFileTypes: true })).filter((entry2) => !entry2.isFile()).map((entry2) => entry2.name);
@@ -27518,7 +27605,7 @@ async function sessionDirectory(ctx, sessionID) {
     return void 0;
   }
 }
-function v2Tool(ctx, spec, ownDir, directories, t) {
+function v2Tool(ctx, spec, ownDir, directories, t, options) {
   return {
     name: spec.id,
     description: spec.description,
@@ -27526,7 +27613,7 @@ function v2Tool(ctx, spec, ownDir, directories, t) {
     output: spec.output,
     async execute(input12, { sessionID, signal }) {
       const directory = await sessionDirectory(ctx, sessionID);
-      const toolContext = { cwd: directory ?? process.cwd(), ownDir, ...directories, signal };
+      const toolContext = { cwd: directory ?? process.cwd(), ownDir, ...directories, options, signal };
       let pin;
       if (needsPermission(spec)) {
         if (directory === void 0) {
@@ -27554,7 +27641,7 @@ function createV2Setup(specs, deps = {}) {
   return async function setup(ctx) {
     const selection = selectedTools(specs, ctx.options, deps);
     const tools = selection.tools.map(
-      (spec) => v2Tool(ctx, spec, deps.ownDir, selection.directories, selection.translator)
+      (spec) => v2Tool(ctx, spec, deps.ownDir, selection.directories, selection.translator, selection.options)
     );
     const skills = deps.skillsDir === void 0 ? [] : await loadSkills(deps.skillsDir, new Set(selection.tools.map((spec) => spec.toolset)));
     if (tools.length > 0) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@craftsamo/whatsapp-tools",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "WhatsApp tools for coding agents: chats, contacts, history, received files, sends and actions.",
   "author": "craftsamo",
   "license": "LicenseRef-AGPL-3.0-Commons-Clause",

package/plugin.yaml

@@ -1,5 +1,5 @@
 name: whatsapp-tools
-version: 0.1.0
+version: 0.1.1
 description: "WhatsApp tools for coding agents: chats, contacts, history, received files, sends and actions."
 manifest_version: 1
 requires_hermes: ">=0.22"

package/src/hermes/whatsapp_tools_hermes/approval.py

@@ -155,7 +155,6 @@ def resolve_target(
     runtime: Runtime,
     tool_id: str,
     args: Any,
-    flags: list[str] | None = None,
     language: str | None = None,
     harness_language: Callable[[], str | None] = lambda: display_language(),
     option_flags: list[str] | None = None,
@@ -172,7 +171,6 @@ def resolve_target(
                 tool_id,
                 "--cwd",
                 agent_cwd(),
-                *(flags or []),
                 *language_flags(language, _known(harness_language)),
                 *(option_flags or []),
             ],
@@ -223,7 +221,6 @@ def _message(tool: ToolInfo, target: Target, surface: Callable[[], str | None])
 def make_hook(
     runtime: Runtime,
     tools: list[ToolInfo],
-    flags: list[str] | None = None,
     surface: Callable[[], str | None] = lambda: None,
     language: str | None = None,
     harness_language: Callable[[], str | None] = lambda: display_language(),
@@ -244,7 +241,7 @@ def make_hook(
         tool = by_id.get(tool_name)
         if tool is None or tool.write_class == READ_CLASS:
             return None
-        target = resolve_target(runtime, tool.id, args, flags, language, harness_language, option_flags)
+        target = resolve_target(runtime, tool.id, args, language, harness_language, option_flags)
         call = pin_key(kwargs)
         if pins is not None and call is not None:
             # An entry left by a call that never reached the pin hook must not stand for this one.
@@ -305,7 +302,6 @@ def register_approval(
     ctx: PluginContext,
     runtime: Runtime,
     tools: list[ToolInfo],
-    flags: list[str] | None = None,
     language: str | None = None,
     option_flags: list[str] | None = None,
 ) -> None:
@@ -320,7 +316,6 @@ def register_approval(
         make_hook(
             runtime,
             tools,
-            flags,
             surface=lambda: session_surface(ctx),
             language=language,
             pins=pins,

package/src/hermes/whatsapp_tools_hermes/plugin.py

@@ -9,7 +9,7 @@ from .context import PluginContext
 from .listing import list_tools
 from . import project
 from .runtime import Unavailable, locate_runtime
-from .settings import SettingsError, directory_flags, emoji_setting, language_setting, option_flags, settings_flags
+from .settings import SettingsError, emoji_setting, language_setting, option_flags, settings_flags
 from .skills import register_skills
 from .tools import register_tools
 
@@ -34,5 +34,5 @@ def register(ctx: PluginContext) -> None:
         return
 
     register_tools(ctx, runtime, tools, flags, emoji_setting(ctx))
-    register_approval(ctx, runtime, tools, directory_flags(ctx), language_setting(ctx), option_flags(ctx))
+    register_approval(ctx, runtime, tools, language_setting(ctx), option_flags(ctx))
     register_skills(ctx, runtime.skills_dir, {tool.toolset for tool in tools})

package/src/hermes/whatsapp_tools_hermes/project.py

@@ -22,10 +22,10 @@ TOOLSET_EMOJI: dict[str, str] = {
     "actions": "🔧",
 }
 
-#: The settings the tools themselves read, beside the ones every plugin takes: each snake_case name and its type
-#: (``text``, ``boolean``, ``number`` or ``list``), as in ``src/project.ts``. A setting ``a_b`` becomes the flag
-#: ``--a-b`` of the command line.
-OPTIONS: dict[str, str] = {}
+#: The settings the tools themselves read: each snake_case name and a type (``text``, ``boolean``, ``number``,
+#: ``list``, ``path`` or ``paths``) or a dict with ``type`` and optional bounds (``integer``, ``min``, ``max``),
+#: as in ``src/project.ts``. Write OPTIONS on one line with double quotes. A setting ``a_b`` becomes ``--a-b``.
+OPTIONS: dict[str, str | dict[str, object]] = {"state_dir": "path", "download_dir": "path", "send_dirs": "paths"}
 
 #: How long one call of a tool may take, in seconds, for a tool that may take longer than the default.
 #: ``whatsapp_history_backfill`` waits up to 300 seconds for the phone, so it gets a margin above that;