@lawaty/lacode 0.0.0-stage → 0.1.1

package/dist/pool.js

@@ -0,0 +1,487 @@
+// src/lib/pool.ts
+import { existsSync, mkdirSync, readdirSync, readFileSync, renameSync, statSync, unlinkSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+var CLAIM_TTL_MS = 10 * 60 * 1e3;
+var DEAD_FILE_MS = 2 * CLAIM_TTL_MS;
+var ORPHAN_TMP_MS = 60 * 1e3;
+var CATALOG_TTL_MS = 10 * 60 * 1e3;
+var STUCK_MIN_AGE_MS = 5 * 60 * 1e3;
+var STUCK_IDLE_MS = 3 * 60 * 1e3;
+var HANG_COOLDOWN_MS = 10 * 60 * 1e3;
+var MAX_WEIGHT = 100;
+var MAX_SLOTS = 4;
+var COOLDOWN_BASE_MS = 60 * 1e3;
+var COOLDOWN_MAX_MS = 15 * 60 * 1e3;
+var STRIKE_DECAY_MS = 30 * 60 * 1e3;
+var BASES = ["explore-fast", "implement-fast", "context-manager"];
+var findPackageRoot = (start) => {
+  let dir = start;
+  for (let up = 0; up < 6; up++) {
+    try {
+      if (JSON.parse(readFileSync(join(dir, "package.json"), "utf8")).name === "@lawaty/lacode") return dir;
+    } catch {
+    }
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return join(start, "..", "..");
+};
+var PACKAGE_ROOT = findPackageRoot(dirname(fileURLToPath(import.meta.url)));
+var PRESETS_DIR = join(PACKAGE_ROOT, "presets");
+var DEFAULT_PRESET = join(PRESETS_DIR, "free-tier.json");
+var USER_CONFIG_DIR = join(homedir(), ".config", "lacode");
+var USER_MODELS_PATH = join(USER_CONFIG_DIR, "pool.json");
+var FALLBACK_SLOTS = [
+  { index: 1, model: "opencode/space-bunny-free", weight: 3 },
+  { index: 2, model: "openrouter/nvidia/nemotron-3-ultra-550b-a55b:free", weight: 2 },
+  { index: 3, model: "opencode/big-pickle", weight: 1 },
+  { index: 4, model: "openrouter/thinkingmachines/inkling:free", weight: 1 }
+];
+function parseSlots(parsed, origin) {
+  const problems = [];
+  const entries = parsed?.slots;
+  if (!Array.isArray(entries) || entries.length === 0) {
+    return { slots: FALLBACK_SLOTS, problems: [`${origin} has no non-empty "slots" array; using built-in defaults`] };
+  }
+  const slots = [];
+  entries.forEach((entry, i) => {
+    const model = typeof entry?.model === "string" ? entry.model.trim() : "";
+    const at = `slot ${i + 1}`;
+    if (slots.length >= MAX_SLOTS) {
+      problems.push(`${at} (${model || "?"}): the pool is capped at ${MAX_SLOTS} slots (one variant agent per base per slot is declared); entry ignored`);
+      return;
+    }
+    if (!model.includes("/")) return problems.push(`${at}: model must be written provider/model-id, got "${model}"`);
+    const weight = readWeight(entry, at, model, problems);
+    if (slots.some((s) => s.model === model)) return problems.push(`${at}: ${model} is already used by another slot; slots must be distinct models`);
+    slots.push({ index: slots.length + 1, model, weight });
+  });
+  if (slots.length === 0) {
+    problems.push(`${origin} yielded no usable slot; using built-in defaults`);
+    return { slots: FALLBACK_SLOTS, problems };
+  }
+  return { slots, problems };
+}
+var readJSON = (path) => {
+  try {
+    return { ok: true, value: JSON.parse(readFileSync(path, "utf8")) };
+  } catch (error) {
+    return { ok: false, error: String(error) };
+  }
+};
+function readOptional(path, origin, problems) {
+  const result = readJSON(path);
+  if (!result.ok) {
+    if (existsSync(path)) problems.push(`${origin} unreadable (${result.error}); trying the next source`);
+    return void 0;
+  }
+  return result.value;
+}
+function resolveModels(input = {}) {
+  const problems = [];
+  if (input.models !== void 0) {
+    const origin = "plugin options";
+    if (typeof input.models !== "object" || input.models === null || Array.isArray(input.models)) {
+      return { slots: FALLBACK_SLOTS, problems: [`${origin}: "models" must be an object like {"slots":[...]}`], origin };
+    }
+    const parsed = parseSlots(input.models, origin);
+    return { slots: parsed.slots, problems: [...problems, ...parsed.problems], origin };
+  }
+  if (input.modelsFile) {
+    const result = readJSON(input.modelsFile);
+    if (!result.ok) return { slots: FALLBACK_SLOTS, problems: [`${input.modelsFile} unreadable (${result.error}); using built-in defaults`], origin: input.modelsFile };
+    const parsed = parseSlots(result.value, input.modelsFile);
+    return { slots: parsed.slots, problems: parsed.problems, origin: input.modelsFile };
+  }
+  const user = readOptional(USER_MODELS_PATH, USER_MODELS_PATH, problems);
+  if (user !== void 0) {
+    const parsed = parseSlots(user, USER_MODELS_PATH);
+    if (parsed.slots !== FALLBACK_SLOTS) return { slots: parsed.slots, problems, origin: USER_MODELS_PATH };
+    problems.push(...parsed.problems);
+  }
+  const preset = readOptional(DEFAULT_PRESET, DEFAULT_PRESET, problems);
+  if (preset !== void 0) {
+    const parsed = parseSlots(preset, "presets/free-tier.json");
+    return { slots: parsed.slots, problems: [...problems, ...parsed.problems], origin: "presets/free-tier.json" };
+  }
+  return { slots: FALLBACK_SLOTS, problems: [...problems, `no pool source found (${USER_MODELS_PATH}, ${DEFAULT_PRESET}); using built-in defaults`], origin: "built-in defaults" };
+}
+function readSlotFile(path) {
+  const result = readJSON(path);
+  if (!result.ok) return { slots: FALLBACK_SLOTS, problems: [`${path} unreadable (${result.error}); using built-in defaults`] };
+  return parseSlots(result.value, path);
+}
+function ensureUserConfigDir() {
+  try {
+    mkdirSync(USER_CONFIG_DIR, { recursive: true });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function readWeight(entry, at, model, problems) {
+  const raw = entry?.weight;
+  if (raw === void 0) {
+    const legacy = entry?.tier;
+    if (legacy !== void 0) {
+      problems.push(
+        `weight: "tier" is deprecated; write "weight" instead (primary is weight 2, overflow is weight 1), got ${JSON.stringify(legacy)}`
+      );
+      if (legacy === "primary" || legacy === "overflow") return legacy === "primary" ? 2 : 1;
+    }
+    return 1;
+  }
+  const weight = typeof raw === "number" ? raw : Number(raw);
+  if (!Number.isFinite(weight) || weight <= 0 || weight > MAX_WEIGHT) {
+    problems.push(`${at} (${model}): weight must be a number in (0, ${MAX_WEIGHT}], got ${JSON.stringify(raw)}; using weight 1`);
+    return 1;
+  }
+  return weight;
+}
+var LIMIT_PATTERNS = [
+  /rate[\s_-]?limit/i,
+  /usage limit/i,
+  /too many requests/i,
+  /\b429\b/,
+  /quota/i,
+  /freelimiterror/i,
+  /overloaded/i
+];
+var isLimitText = (text) => LIMIT_PATTERNS.some((re) => re.test(text));
+var statedCooldown = (text) => {
+  const hm = /resets?\s+in\s+(\d+)\s*(?:h|hr|hour)s?\s*(\d+)?\s*(?:m|min|minute)?s?/i.exec(text);
+  if (hm) return (Number(hm[1]) * 60 + (hm[2] ? Number(hm[2]) : 0)) * 60 * 1e3;
+  const m = /resets?\s+in\s+(\d+)\s*(?:m|min|minute)s?/i.exec(text);
+  if (m) return Number(m[1]) * 60 * 1e3;
+  const s = /retry[\s-]?in\s+(\d+)\s*(?:s|sec|second)s?/i.exec(text);
+  if (s) return Number(s[1]) * 1e3;
+  return void 0;
+};
+var retryAfterMs = (headers) => {
+  if (!headers) return void 0;
+  for (const [key, value] of Object.entries(headers)) {
+    if (key.toLowerCase() !== "retry-after") continue;
+    const seconds = Number(value);
+    if (Number.isFinite(seconds) && seconds > 0) return Math.min(seconds * 1e3, COOLDOWN_MAX_MS);
+    const when = Date.parse(value);
+    if (Number.isFinite(when)) return Math.min(Math.max(when - Date.now(), 1e3), COOLDOWN_MAX_MS);
+  }
+  return void 0;
+};
+function state(opts = {}) {
+  const id = opts.id ?? String(process.pid);
+  const dir = opts.dir ?? join(homedir(), ".local", "share", "opencode", "agent-pool");
+  const modelsFile = opts.modelsFile;
+  const models = opts.models;
+  const key = /* @__PURE__ */ Symbol.for(`agent-pool:state:${id}:${dir}:${modelsFile ?? ""}:${models === void 0 ? "" : "inline"}`);
+  const g = globalThis;
+  if (!g[key]) {
+    g[key] = {
+      own: /* @__PURE__ */ new Map(),
+      models: /* @__PURE__ */ new Map(),
+      known: /* @__PURE__ */ new Set(),
+      warned: /* @__PURE__ */ new Set(),
+      initialized: false,
+      dirReady: false,
+      catalog: /* @__PURE__ */ new Map(),
+      catalogAt: 0,
+      cooling: /* @__PURE__ */ new Map(),
+      activity: /* @__PURE__ */ new Map(),
+      reaped: 0,
+      reaping: false,
+      lastSweep: 0,
+      id,
+      dir,
+      modelsFile,
+      inlineModels: models,
+      origin: "unresolved",
+      slots: []
+    };
+  }
+  return g[key];
+}
+function ensureSlots(s, onWarn) {
+  if (s.slots.length > 0) return s.slots;
+  const { slots, problems, origin } = resolveModels({ models: s.inlineModels, modelsFile: s.modelsFile });
+  s.slots = slots;
+  s.origin = origin;
+  for (const problem of problems) onWarn(problem);
+  return slots;
+}
+var claimKey = (sessionID, callID) => `${sessionID}:${callID}`;
+var selfFile = (id) => `claims.${id}.json`;
+var limitFile = (model) => `limit.${model.replace(/[^a-zA-Z0-9._-]/g, "__")}.json`;
+function init(s, onWarn) {
+  ensureSlots(s, onWarn);
+  if (s.initialized) return;
+  s.initialized = true;
+  try {
+    mkdirSync(s.dir, { recursive: true });
+    s.dirReady = true;
+    try {
+      unlinkSync(join(s.dir, selfFile(s.id)));
+    } catch {
+    }
+  } catch {
+    onWarn(`claim dir ${s.dir} unusable; pool load tracked in memory only`);
+  }
+}
+function pruneOwn(s) {
+  const now = Date.now();
+  for (const [key, claim] of s.own) if (now - claim.t > CLAIM_TTL_MS) s.own.delete(key);
+}
+function publish(s) {
+  if (!s.dirReady) return;
+  const now = Date.now();
+  const payload = {};
+  for (const [key, claim] of s.own) if (now - claim.t <= CLAIM_TTL_MS) payload[key] = claim;
+  try {
+    writeFileSync(join(s.dir, `${selfFile(s.id)}.tmp`), JSON.stringify(payload));
+    renameSync(join(s.dir, `${selfFile(s.id)}.tmp`), join(s.dir, selfFile(s.id)));
+  } catch {
+    s.dirReady = false;
+  }
+}
+function readSiblings(s) {
+  const siblings = [];
+  let entries;
+  try {
+    entries = readdirSync(s.dir);
+  } catch {
+    return siblings;
+  }
+  const now = Date.now();
+  for (const entry of entries) {
+    const path = join(s.dir, entry);
+    let age;
+    try {
+      age = now - statSync(path).mtimeMs;
+    } catch {
+      continue;
+    }
+    if (entry.endsWith(".tmp")) {
+      if (age > ORPHAN_TMP_MS) try {
+        unlinkSync(path);
+      } catch {
+      }
+      continue;
+    }
+    const match = /^claims\.(.+)\.json$/.exec(entry);
+    if (!match || match[1] === s.id) continue;
+    if (age > DEAD_FILE_MS) {
+      try {
+        unlinkSync(path);
+      } catch {
+      }
+      continue;
+    }
+    try {
+      const parsed = JSON.parse(readFileSync(path, "utf8"));
+      const claims = Object.values(parsed).filter(
+        (c) => c && typeof c.v === "string" && typeof c.m === "string" && now - c.t <= CLAIM_TTL_MS
+      );
+      siblings.push({ id: match[1], claims });
+    } catch {
+    }
+  }
+  return siblings;
+}
+function readLimits(s) {
+  const cooling = /* @__PURE__ */ new Map();
+  let entries;
+  try {
+    entries = readdirSync(s.dir);
+  } catch {
+    return cooling;
+  }
+  const now = Date.now();
+  for (const entry of entries) {
+    if (!entry.startsWith("limit.") || !entry.endsWith(".json")) continue;
+    const path = join(s.dir, entry);
+    try {
+      const strike = JSON.parse(readFileSync(path, "utf8"));
+      if (typeof strike.until !== "number" || typeof strike.model !== "string") continue;
+      if (strike.until > now) cooling.set(strike.model, strike);
+      else unlinkSync(path);
+    } catch {
+      try {
+        unlinkSync(path);
+      } catch {
+      }
+    }
+  }
+  s.cooling = cooling;
+  return cooling;
+}
+function recordStrike(s, model, reason, stated) {
+  if (!s.dirReady) return;
+  const now = Date.now();
+  const prior = s.cooling.get(model);
+  const strikes = prior && now - prior.last < STRIKE_DECAY_MS ? prior.strikes + 1 : 1;
+  const backoff = Math.min(COOLDOWN_MAX_MS, COOLDOWN_BASE_MS * 2 ** (strikes - 1));
+  const strike = { model, until: now + (stated ?? backoff), strikes, reason, last: now };
+  s.cooling.set(model, strike);
+  const path = join(s.dir, limitFile(model));
+  try {
+    writeFileSync(`${path}.tmp`, JSON.stringify(strike));
+    renameSync(`${path}.tmp`, path);
+  } catch {
+  }
+  return strike;
+}
+function refreshCatalog(s, serverUrl) {
+  if (!serverUrl || Date.now() - s.catalogAt < CATALOG_TTL_MS) return;
+  s.catalogAt = Date.now();
+  void (async () => {
+    try {
+      const response = await fetch(new URL("/api/model", serverUrl).toString());
+      if (!response.ok) return;
+      const payload = await response.json();
+      const catalog = /* @__PURE__ */ new Map();
+      for (const m of payload.data ?? []) catalog.set(`${m.providerID}/${m.id}`, m.status ?? "unknown");
+      if (catalog.size > 0) s.catalog = catalog;
+    } catch {
+    }
+  })();
+}
+function isAvailable(s, model, cooling) {
+  if (cooling.has(model)) return false;
+  const status = s.catalog.get(model);
+  return status === void 0 || status === "active" || status === "unknown";
+}
+function snapshot(s) {
+  pruneOwn(s);
+  const siblings = readSiblings(s);
+  const cooling = readLimits(s);
+  const counts = /* @__PURE__ */ new Map();
+  const bump = (m) => counts.set(m, (counts.get(m) ?? 0) + 1);
+  for (const claim of s.own.values()) bump(claim.m);
+  for (const sibling of siblings) for (const claim of sibling.claims) bump(claim.m);
+  return { counts, cooling, siblings, own: s.own, dirReady: s.dirReady };
+}
+var loadOf = (counts, model) => counts.get(model) ?? 0;
+var underCeiling = (slot, counts) => loadOf(counts, slot.model) < slot.weight;
+function pickSlot(s, snap) {
+  const slots = s.slots.length > 0 ? s.slots : FALLBACK_SLOTS;
+  const usable = slots.filter((slot) => isAvailable(s, slot.model, snap.cooling));
+  const pool = usable.length > 0 ? usable : slots;
+  const open = pool.filter((slot) => underCeiling(slot, snap.counts));
+  if (open.length > 0) return open.reduce((best, slot) => slot.weight > best.weight ? slot : best, open[0]);
+  return pool.reduce((best, slot) => loadOf(snap.counts, slot.model) < loadOf(snap.counts, best.model) ? slot : best, pool[0]);
+}
+function agentFor(base, slot) {
+  return `${base}-${slot}`;
+}
+function acquire(s, base, slot, ownerSession, key, target) {
+  s.own.set(key, { v: base, k: slot.index, m: slot.model, t: Date.now(), s: ownerSession, g: target });
+  if (target) s.activity.set(target, Date.now());
+  publish(s);
+}
+function release(s, key) {
+  if (s.own.delete(key)) publish(s);
+}
+function bindChild(s, parentID, childID) {
+  const candidates = [...s.own.entries()].filter(([, c]) => c.s === parentID && !c.g).sort((a, b) => a[1].t - b[1].t);
+  if (candidates.length === 0) return false;
+  candidates[0][1].g = childID;
+  s.activity.set(childID, Date.now());
+  publish(s);
+  return true;
+}
+function noteActivity(s, sessionID) {
+  s.activity.set(sessionID, Date.now());
+}
+function idleFor(s, claim, now) {
+  const target = claim.g;
+  if (!target) return Infinity;
+  const seen = s.activity.get(target);
+  return seen ? now - seen : Infinity;
+}
+function findStuck(s, now = Date.now()) {
+  const stuck = [];
+  for (const [key, claim] of s.own) {
+    if (now - claim.t <= STUCK_MIN_AGE_MS) continue;
+    if (idleFor(s, claim, now) < STUCK_IDLE_MS) continue;
+    stuck.push({ key, claim });
+  }
+  return stuck;
+}
+function releaseStuck(s, keys) {
+  for (const key of keys) s.own.delete(key);
+  if (keys.length > 0) publish(s);
+}
+function slotFor(s, model) {
+  return s.slots.find((slot) => slot.model === model);
+}
+function splitModel(model) {
+  const slash = model.indexOf("/");
+  if (slash < 0) return { provider: model, id: "" };
+  return { provider: model.slice(0, slash), id: model.slice(slash + 1) };
+}
+var providerOf = (model) => splitModel(model).provider;
+function coolProvider(s, provider, until, reason) {
+  const affected = [];
+  for (const slot of s.slots.length > 0 ? s.slots : FALLBACK_SLOTS) {
+    if (providerOf(slot.model) !== provider) continue;
+    const existing = s.cooling.get(slot.model);
+    const untilMs = Math.max(until, existing?.until ?? 0);
+    const strike = recordStrike(s, slot.model, reason, untilMs - Date.now());
+    if (strike) affected.push(strike);
+  }
+  return affected;
+}
+export {
+  BASES,
+  CATALOG_TTL_MS,
+  CLAIM_TTL_MS,
+  DEAD_FILE_MS,
+  DEFAULT_PRESET,
+  FALLBACK_SLOTS,
+  HANG_COOLDOWN_MS,
+  MAX_SLOTS,
+  MAX_WEIGHT,
+  ORPHAN_TMP_MS,
+  PACKAGE_ROOT,
+  PRESETS_DIR,
+  STUCK_IDLE_MS,
+  STUCK_MIN_AGE_MS,
+  USER_CONFIG_DIR,
+  USER_MODELS_PATH,
+  acquire,
+  agentFor,
+  bindChild,
+  claimKey,
+  coolProvider,
+  ensureSlots,
+  ensureUserConfigDir,
+  findStuck,
+  idleFor,
+  init,
+  isAvailable,
+  isLimitText,
+  noteActivity,
+  parseSlots,
+  pickSlot,
+  providerOf,
+  pruneOwn,
+  publish,
+  readLimits,
+  readSiblings,
+  readSlotFile,
+  recordStrike,
+  refreshCatalog,
+  release,
+  releaseStuck,
+  resolveModels,
+  retryAfterMs,
+  selfFile,
+  slotFor,
+  snapshot,
+  splitModel,
+  state,
+  statedCooldown,
+  underCeiling
+};

package/dist/tunnel.js

@@ -0,0 +1,180 @@
+// src/tunnel/index.ts
+import { spawnSync } from "node:child_process";
+import { homedir } from "node:os";
+import { join } from "node:path";
+var ICONS = [
+  "utilities-terminal",
+  "dialog-information",
+  "dialog-error",
+  "dialog-warning",
+  "system-run",
+  "emblem-default"
+];
+function resolveTunnel(env = process.env) {
+  const port = Number(env.OC_TUNNEL_PORT);
+  return {
+    user: env.OC_LOCAL_USER ?? "",
+    port: Number.isFinite(port) && port > 0 ? port : 10022,
+    key: env.OC_NOTIFY_KEY ?? join(homedir(), ".ssh", "lacode_notify"),
+    connectTimeoutMs: Number(env.OC_CONNECT_TIMEOUT_MS) || 5e3
+  };
+}
+function isRemote(env = process.env) {
+  return Boolean(env.SSH_CLIENT || env.SSH_TTY);
+}
+function normalizeUrgency(raw) {
+  return raw === "low" || raw === "critical" || raw === "normal" ? raw : "normal";
+}
+function normalizeIcon(raw) {
+  return ICONS.includes(raw) ? raw : "utilities-terminal";
+}
+var safeText = (raw, fallback, max) => {
+  const clean = raw.replace(/[\u0000-\u001f\u007f]/g, " ").replace(/\s+/g, " ").trim();
+  if (!clean) return fallback;
+  return clean.length > max ? `${clean.slice(0, max - 1)}\u2026` : clean;
+};
+var safeTitle = (raw) => safeText(raw ?? "", "LaCode", 120);
+var safeMessage = (raw) => safeText(raw ?? "", "", 400);
+var FIELD_SEPARATOR = "\n";
+var encodePayload = (request) => [
+  safeTitle(request.title),
+  safeMessage(request.message),
+  normalizeUrgency(request.urgency),
+  normalizeIcon(request.icon)
+].join(FIELD_SEPARATOR);
+var SSH_OPTS = [
+  "-o",
+  "BatchMode=yes",
+  "-o",
+  "IdentitiesOnly=yes",
+  "-o",
+  "ClearAllForwardings=yes",
+  "-o",
+  "LogLevel=ERROR",
+  "-o",
+  "StrictHostKeyChecking=accept-new"
+];
+var run = (command, args, timeout) => {
+  try {
+    const result = spawnSync(command, args, { timeout, encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] });
+    return {
+      ok: result.status === 0,
+      stdout: result.stdout ?? "",
+      stderr: (result.stderr ?? "").trim(),
+      // spawnSync reports a timeout as a null status and an ETIMEDOUT error; both
+      // are "did not arrive", not "crashed", and neither may throw.
+      detail: result.error ? String(result.error.code ?? result.error.message) : void 0
+    };
+  } catch (error) {
+    return { ok: false, stdout: "", stderr: "", detail: String(error) };
+  }
+};
+var have = (command) => {
+  try {
+    return spawnSync("sh", ["-c", `command -v ${command}`], { encoding: "utf8" }).status === 0;
+  } catch {
+    return false;
+  }
+};
+var CHANNEL_BINARY = {
+  "notify-send": "notify-send",
+  osascript: "osascript",
+  "terminal-notifier": "terminal-notifier"
+};
+var DARWIN_SCRIPT = [
+  "on run argv",
+  "  display notification (item 3 of argv) with title (item 2 of argv)",
+  "end run"
+].join("\n");
+var DARWIN_ARGV_MARKER = "lacode";
+function localChannel(platform = process.platform) {
+  if (platform === "darwin") {
+    if (have(CHANNEL_BINARY.osascript)) return "osascript";
+    if (have(CHANNEL_BINARY["terminal-notifier"])) return "terminal-notifier";
+    return "none";
+  }
+  return have(CHANNEL_BINARY["notify-send"]) ? "notify-send" : "none";
+}
+var NO_CHANNEL = {
+  linux: "notify-send is not installed",
+  darwin: "neither osascript nor terminal-notifier is installed"
+};
+function sendLocal(request, platform = process.platform) {
+  const channel = localChannel(platform);
+  if (channel === "none") {
+    return { ok: false, detail: NO_CHANNEL[platform] ?? `no local notification channel on ${platform}`, transport: "local" };
+  }
+  const title = safeTitle(request.title);
+  const body = safeMessage(request.message);
+  const args = channel === "osascript" ? ["-e", DARWIN_SCRIPT, DARWIN_ARGV_MARKER, title, body] : channel === "terminal-notifier" ? ["-title", title, "-message", body, "-appName", "LaCode", "-priority", normalizeUrgency(request.urgency)] : (
+    // Byte-identical to the notify-send call this package has always made.
+    [title, body, `--urgency=${normalizeUrgency(request.urgency)}`, `--icon=${normalizeIcon(request.icon)}`]
+  );
+  const result = run(CHANNEL_BINARY[channel], args, 5e3);
+  return { ok: result.ok, detail: result.ok ? void 0 : result.stderr || result.detail, transport: "local" };
+}
+function sendRemote(request, tunnel) {
+  if (!tunnel.user) return { ok: false, detail: "OC_LOCAL_USER is unset; the desktop user for the tunnel is unknown", transport: "remote" };
+  const args = [
+    ...SSH_OPTS,
+    "-o",
+    `ConnectTimeout=${Math.max(1, Math.round(tunnel.connectTimeoutMs / 1e3))}`,
+    "-i",
+    tunnel.key,
+    "-p",
+    String(tunnel.port),
+    `${tunnel.user}@localhost`,
+    "--",
+    encodePayload(request)
+  ];
+  const result = run("ssh", args, tunnel.connectTimeoutMs + 2e3);
+  return { ok: result.ok, detail: result.ok ? void 0 : result.stderr || result.detail, transport: "remote" };
+}
+function notify(request, env = process.env, platform = process.platform) {
+  try {
+    return isRemote(env) ? sendRemote(request, resolveTunnel(env)) : sendLocal(request, platform);
+  } catch (error) {
+    return { ok: false, detail: String(error), transport: "none" };
+  }
+}
+function forward(host, argv, options = {}) {
+  const env = options.env ?? process.env;
+  const timeoutMs = options.timeoutMs ?? (Number(env.OC_SSH_TIMEOUT_MS) || 3e4);
+  const result = run("ssh", [...SSH_OPTS, "-o", `ConnectTimeout=${Math.max(1, Math.round(timeoutMs / 1e3))}`, host, "--", ...argv], timeoutMs);
+  return {
+    ok: result.ok,
+    detail: result.ok ? void 0 : result.stderr || result.detail,
+    transport: "remote",
+    stdout: result.stdout
+  };
+}
+function describe(env = process.env, platform = process.platform) {
+  const tunnel = resolveTunnel(env);
+  return {
+    running: isRemote(env) ? "remote (over ssh)" : "local",
+    user: tunnel.user || "(unset)",
+    port: tunnel.port,
+    key: tunnel.key,
+    channel: localChannel(platform),
+    // Still exactly what it always meant -- is the notify-send binary present --
+    // rather than a second opinion about which channel runs.
+    notifySend: have("notify-send")
+  };
+}
+export {
+  FIELD_SEPARATOR,
+  ICONS,
+  describe,
+  encodePayload,
+  forward,
+  isRemote,
+  localChannel,
+  normalizeIcon,
+  normalizeUrgency,
+  notify,
+  resolveTunnel,
+  safeMessage,
+  safeTitle,
+  sendLocal,
+  sendRemote
+};