@lawaty/lacode 0.9.0 → 0.11.0

package/dist/lacode.js

@@ -2,12 +2,22 @@
 
 // bin/lacode
 import { fileURLToPath as fileURLToPath3 } from "node:url";
-import { existsSync as existsSync3, readFileSync as readFileSync4 } from "node:fs";
+import { existsSync as existsSync4, readFileSync as readFileSync7 } from "node:fs";
 import { spawnSync as spawnSync3 } from "node:child_process";
 
 // src/tunnel/index.ts
 import { spawn, spawnSync } from "node:child_process";
-import { existsSync } from "node:fs";
+import { appendFileSync, existsSync as existsSync2, mkdirSync as mkdirSync3, readFileSync as readFileSync4, unlinkSync as unlinkSync3 } from "node:fs";
+import { homedir as homedir3 } from "node:os";
+import { join as join4 } from "node:path";
+
+// src/lib/notify.ts
+import { closeSync, mkdirSync as mkdirSync2, openSync, readFileSync as readFileSync3, statSync as statSync2, unlinkSync as unlinkSync2, writeSync } from "node:fs";
+import { homedir as homedir2 } from "node:os";
+import { join as join3 } from "node:path";
+
+// src/lib/pool.ts
+import { existsSync, mkdirSync, readdirSync, readFileSync as readFileSync2, renameSync, statSync, unlinkSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { join as join2 } from "node:path";
 
@@ -31,6 +41,36 @@ var findPackageRoot = (start) => {
 };
 var PACKAGE_ROOT = findPackageRoot(dirname(fileURLToPath(import.meta.url)));
 
+// src/lib/pool.ts
+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 MAX_CLAIM_AGE_MS = 30 * 60 * 1e3;
+var HANG_COOLDOWN_MS = 10 * 60 * 1e3;
+var UNAVAILABLE_COOLDOWN_MS = 60 * 1e3;
+var COOLDOWN_BASE_MS = 60 * 1e3;
+var COOLDOWN_MAX_MS = 15 * 60 * 1e3;
+var QUOTA_COOLDOWN_BASE_MS = 15 * 60 * 1e3;
+var QUOTA_COOLDOWN_MAX_MS = 6 * 60 * 60 * 1e3;
+var STRIKE_DECAY_MS = 30 * 60 * 1e3;
+var PRESETS_DIR = join2(PACKAGE_ROOT, "presets");
+var DEFAULT_PRESET = join2(PRESETS_DIR, "free-tier.json");
+var USER_CONFIG_DIR = join2(homedir(), ".config", "lacode");
+var USER_MODELS_PATH = join2(USER_CONFIG_DIR, "pool.json");
+var USER_MODELS_TXT = join2(USER_CONFIG_DIR, "pool.txt");
+var STATE_SWEEP_INTERVAL_MS = 60 * 60 * 1e3;
+var CHILD_MEMORY_MS = 30 * 6e4;
+
+// src/lib/notify.ts
+var NOTIFY_SESSION_ENV = "LACODE_NOTIFY_SESSION";
+var NOTIFY_CLOSE_ENV = "LACODE_NOTIFY_CLOSE";
+var notificationStateDir = () => process.env.LACODE_NOTIFY_DIR ?? join3(homedir2(), ".local", "share", "opencode", "lacode", "notify");
+var safeCorrelationKey = (correlationKey) => correlationKey.replace(/[^A-Za-z0-9._-]/g, "_").slice(0, 64);
+var notificationIdFile = (correlationKey) => join3(notificationStateDir(), `${safeCorrelationKey(correlationKey)}.ids`);
+
 // src/tunnel/index.ts
 var ICONS = [
   "utilities-terminal",
@@ -53,7 +93,7 @@ function resolveTunnel(env = process.env) {
     user: env.OC_LOCAL_USER ?? "",
     host: env.OC_LOCAL_HOST ?? "",
     port: Number.isFinite(port) && port > 0 ? port : 10022,
-    key: env.OC_NOTIFY_KEY ?? join2(homedir(), ".ssh", "lacode_notify"),
+    key: env.OC_NOTIFY_KEY ?? join4(homedir3(), ".ssh", "lacode_notify"),
     connectTimeoutMs: Number(env.OC_CONNECT_TIMEOUT_MS) || 5e3
   };
 }
@@ -76,15 +116,37 @@ var safeText = (raw, fallback, max) => {
 };
 var safeTitle = (raw) => safeText(raw ?? "", "LaCode", 120);
 var safeMessage = (raw) => safeText(raw ?? "", "", 400);
+var safeRequestId = (raw) => {
+  const clean = (raw ?? "").replace(/[\u0000-\u001f\u007f]/g, "").trim();
+  if (!clean) return void 0;
+  return clean.length > 128 ? clean.slice(0, 128) : clean;
+};
+var CLOSE_REQUEST_PREFIX = "close:";
+var wireCorrelationKey = (raw) => safeText(raw ?? "", "", 200);
+var presentCorrelationKey = (raw) => {
+  const clean = wireCorrelationKey(raw);
+  return clean ? clean : void 0;
+};
+var isCloseRequest = (correlationKey) => typeof correlationKey === "string" && correlationKey.startsWith(CLOSE_REQUEST_PREFIX);
+var closeRequestTarget = (correlationKey) => {
+  if (!isCloseRequest(correlationKey)) return void 0;
+  const target = correlationKey?.slice(CLOSE_REQUEST_PREFIX.length).trim() ?? "";
+  return target ? target : void 0;
+};
 var FIELD_SEPARATOR = "\n";
 function parsePayload(raw) {
-  const [title, message, urgency, icon, sound] = raw.split(FIELD_SEPARATOR);
+  const [title, message, urgency, icon, sound, requestID, correlationKey] = raw.split(FIELD_SEPARATOR);
+  const key = wireCorrelationKey(correlationKey);
   return {
     title: safeTitle(title),
     message: safeMessage(message),
     urgency: normalizeUrgency(urgency),
     icon: normalizeIcon(icon),
-    sound: normalizeSound(sound)
+    sound: normalizeSound(sound),
+    requestID: safeRequestId(requestID),
+    // The seventh field, empty when there is none. A close request keeps its
+    // marker here, so the receiver can still tell it apart from a session.
+    ...key ? { correlationKey: key } : {}
   };
 }
 var encodePayload = (request) => [
@@ -92,7 +154,14 @@ var encodePayload = (request) => [
   safeMessage(request.message),
   normalizeUrgency(request.urgency),
   normalizeIcon(request.icon),
-  normalizeSound(request.sound)
+  normalizeSound(request.sound),
+  // The sixth field, empty when there is no request id: an absent id and an
+  // empty one mean the same thing, and the field count never changes.
+  safeRequestId(request.requestID) ?? "",
+  // The seventh field, the correlation key, empty when there is none. The
+  // `close:` marker of a close request is part of the key and travels with
+  // it, so the far end closes instead of raising.
+  wireCorrelationKey(request.correlationKey)
 ].join(FIELD_SEPARATOR);
 var SSH_OPTS = [
   "-o",
@@ -112,11 +181,16 @@ var CONTROL_OPTS = [
   "-o",
   "ControlPersist=300",
   "-o",
-  `ControlPath=${join2(homedir(), ".ssh", "lacode-cm-%C")}`
+  `ControlPath=${join4(homedir3(), ".ssh", "lacode-cm-%C")}`
 ];
-var run = (command2, args, timeout) => {
+var run = (command2, args, timeout, extraEnv) => {
   try {
-    const result = spawnSync(command2, args, { timeout, encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] });
+    const result = spawnSync(command2, args, {
+      timeout,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "pipe"],
+      ...extraEnv ? { env: { ...process.env, ...extraEnv } } : {}
+    });
     return {
       ok: result.status === 0,
       stdout: result.stdout ?? "",
@@ -175,14 +249,105 @@ var NO_CHANNEL = {
   linux: "notify-send is not installed",
   darwin: "neither osascript nor terminal-notifier is installed"
 };
+var NEVER_EXPIRE_FLAG = "--expire-time=0";
+var APP_NAME_FLAG = "--app-name=LaCode";
+var NOTIFICATION_ACTIONS = [
+  ["once", "Allow once"],
+  ["always", "Always allow"],
+  ["reject", "Deny"]
+];
+var ACTION_WAIT_MS = 10 * 6e4;
+var isNotificationId = (id) => /^\d+$/.test(id);
+var recordNotificationId = (correlationKey, id) => {
+  if (!isNotificationId(id)) return false;
+  try {
+    mkdirSync3(notificationStateDir(), { recursive: true });
+    appendFileSync(notificationIdFile(correlationKey), `${id}
+`, "utf8");
+    return true;
+  } catch {
+    return false;
+  }
+};
+var sessionBusEnv = () => {
+  if (process.env.DBUS_SESSION_BUS_ADDRESS) return {};
+  const uid = typeof process.getuid === "function" ? process.getuid() : void 0;
+  return uid === void 0 ? {} : { DBUS_SESSION_BUS_ADDRESS: `unix:path=/run/user/${uid}/bus` };
+};
+var CLOSE_TIMEOUT_MS = 5e3;
+function closeNotification(id) {
+  if (!isNotificationId(id)) return false;
+  const env = sessionBusEnv();
+  const viaGdbus = run(
+    "gdbus",
+    [
+      "call",
+      "--session",
+      "--dest",
+      "org.freedesktop.Notifications",
+      "--object-path",
+      "/org/freedesktop/Notifications",
+      "--method",
+      "org.freedesktop.Notifications.CloseNotification",
+      id
+    ],
+    CLOSE_TIMEOUT_MS,
+    env
+  );
+  if (viaGdbus.ok) return true;
+  const viaDbusSend = run(
+    "dbus-send",
+    [
+      "--session",
+      "--dest=org.freedesktop.Notifications",
+      "--type=method_call",
+      "/org/freedesktop/Notifications",
+      "org.freedesktop.Notifications.CloseNotification",
+      `uint32:${id}`
+    ],
+    CLOSE_TIMEOUT_MS,
+    env
+  );
+  return viaDbusSend.ok;
+}
+function closeCorrelationKey(correlationKey) {
+  const file = notificationIdFile(correlationKey);
+  let content = "";
+  try {
+    content = readFileSync4(file, "utf8");
+  } catch {
+    return true;
+  }
+  let closed = true;
+  for (const line of content.split("\n")) {
+    const id = line.trim();
+    if (!isNotificationId(id)) continue;
+    if (!closeNotification(id)) closed = false;
+  }
+  try {
+    unlinkSync3(file);
+  } catch {
+  }
+  return closed;
+}
+var splitNotifyOutput = (stdout) => {
+  const newline = stdout.indexOf("\n");
+  if (newline === -1) return { id: stdout.trim(), action: "" };
+  return { id: stdout.slice(0, newline).trim(), action: stdout.slice(newline + 1).trim() };
+};
 function sendLocal(request, platform = process.platform) {
+  const closing = closeRequestTarget(request.correlationKey);
+  if (closing !== void 0) {
+    const closed = closeCorrelationKey(closing);
+    return { ok: closed, detail: closed ? void 0 : "a popup could not be closed", transport: "local" };
+  }
   const sound = normalizeSound(request.sound);
   const playSound = () => {
     if (sound === "none") return;
     const channel2 = soundChannel(platform);
     if (channel2 === "none") return;
-    const path = join2(PACKAGE_ROOT, "sounds", `${sound}.wav`);
-    if (!existsSync(path)) return;
+    const path = join4(PACKAGE_ROOT, "sounds", `${sound}.wav`);
+    if (!existsSync2(path)) return;
     const child = spawn(channel2, [path], { detached: true, stdio: "ignore" });
     child.on("error", () => {
     });
@@ -195,35 +360,80 @@ function sendLocal(request, platform = process.platform) {
   }
   const title = safeTitle(request.title);
   const body = safeMessage(request.message);
+  const requestID = safeRequestId(request.requestID);
+  const actionable = channel === "notify-send" && requestID !== void 0;
+  const actionArgs = actionable ? NOTIFICATION_ACTIONS.map(([name, label]) => `--action=${name}=${label}`) : [];
+  const correlationKey = presentCorrelationKey(request.correlationKey);
+  const trackable = channel === "notify-send" && correlationKey !== void 0;
   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)}`]
+    // Never auto-dismissed: the notification waits for the user to close it.
+    [title, body, APP_NAME_FLAG, `--urgency=${normalizeUrgency(request.urgency)}`, `--icon=${normalizeIcon(request.icon)}`, NEVER_EXPIRE_FLAG, ...trackable ? ["--print-id"] : [], ...actionArgs]
   );
-  const result = run(CHANNEL_BINARY[channel], args, 5e3);
+  const result = run(CHANNEL_BINARY[channel], args, actionable ? ACTION_WAIT_MS : 5e3);
   playSound();
-  return { ok: result.ok, detail: result.ok ? void 0 : result.stderr || result.detail, transport: "local" };
+  const printed = trackable ? splitNotifyOutput(result.stdout) : { id: "", action: result.stdout.trim() };
+  const action = actionable ? printed.action : "";
+  if (correlationKey !== void 0 && printed.id) recordNotificationId(correlationKey, printed.id);
+  return {
+    ok: result.ok,
+    detail: result.ok ? void 0 : result.stderr || result.detail,
+    transport: "local",
+    ...action ? { action } : {}
+  };
 }
 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 connect = ["-o", `ConnectTimeout=${Math.max(1, Math.round(tunnel.connectTimeoutMs / 1e3))}`];
+  const actionable = safeRequestId(request.requestID) !== void 0;
+  const timeoutMs = actionable ? Math.max(tunnel.connectTimeoutMs + 2e3, ACTION_WAIT_MS + 2e3) : tunnel.connectTimeoutMs + 2e3;
+  const deliver = (args) => {
+    const result = run("ssh", args, timeoutMs);
+    const action = actionable ? result.stdout.trim() : "";
+    return {
+      ok: result.ok,
+      detail: result.ok ? void 0 : result.stderr || result.detail,
+      transport: "remote",
+      ...action ? { action } : {}
+    };
+  };
   if (tunnel.host) {
-    const result2 = run(
-      "ssh",
-      [...SSH_OPTS, ...CONTROL_OPTS, ...connect, "-i", tunnel.key, `${tunnel.user}@${tunnel.host}`, "--", encodePayload(request)],
-      tunnel.connectTimeoutMs + 2e3
-    );
-    return { ok: result2.ok, detail: result2.ok ? void 0 : result2.stderr || result2.detail, transport: "remote" };
-  }
-  const result = run(
-    "ssh",
-    [...SSH_OPTS, ...connect, "-i", tunnel.key, "-p", String(tunnel.port), `${tunnel.user}@localhost`, "--", encodePayload(request)],
-    tunnel.connectTimeoutMs + 2e3
-  );
-  return { ok: result.ok, detail: result.ok ? void 0 : result.stderr || result.detail, transport: "remote" };
+    return deliver([
+      ...SSH_OPTS,
+      ...CONTROL_OPTS,
+      ...connect,
+      "-i",
+      tunnel.key,
+      `${tunnel.user}@${tunnel.host}`,
+      "--",
+      encodePayload(request)
+    ]);
+  }
+  return deliver([
+    ...SSH_OPTS,
+    ...connect,
+    "-i",
+    tunnel.key,
+    "-p",
+    String(tunnel.port),
+    `${tunnel.user}@localhost`,
+    "--",
+    encodePayload(request)
+  ]);
 }
 function notify(request, env = process.env, platform = process.platform) {
   try {
-    return isRemote(env) ? sendRemote(request, resolveTunnel(env)) : sendLocal(request, platform);
+    const closeKey = (env[NOTIFY_CLOSE_ENV] ?? "").trim();
+    if (closeKey) {
+      if (!isRemote(env)) {
+        const closed = closeCorrelationKey(closeKey);
+        return { ok: closed, detail: closed ? void 0 : "a popup could not be closed", transport: "local" };
+      }
+      return sendRemote({ ...request, correlationKey: `${CLOSE_REQUEST_PREFIX}${closeKey}` }, resolveTunnel(env));
+    }
+    const sessionKey = presentCorrelationKey(env[NOTIFY_SESSION_ENV]);
+    const tracked = sessionKey ? { ...request, correlationKey: request.correlationKey ?? sessionKey } : request;
+    const result = isRemote(env) ? sendRemote(tracked, resolveTunnel(env)) : sendLocal(tracked, platform);
+    return result.action ? { ...result, action: result.action } : result;
   } catch (error) {
     return { ok: false, detail: String(error), transport: "none" };
   }
@@ -256,18 +466,18 @@ function describe(env = process.env, platform = process.platform) {
 
 // src/lib/selfupdate.ts
 import { spawn as spawn2 } from "node:child_process";
-import { closeSync, mkdirSync, openSync, readFileSync as readFileSync2, renameSync, rmSync, statSync, unlinkSync, writeFileSync, writeSync } from "node:fs";
-import { homedir as homedir2 } from "node:os";
-import { dirname as dirname2, join as join3, resolve } from "node:path";
+import { closeSync as closeSync2, mkdirSync as mkdirSync4, openSync as openSync2, readFileSync as readFileSync5, renameSync as renameSync2, rmSync, statSync as statSync3, unlinkSync as unlinkSync4, writeFileSync as writeFileSync2, writeSync as writeSync2 } from "node:fs";
+import { homedir as homedir4 } from "node:os";
+import { dirname as dirname2, join as join5, resolve } from "node:path";
 var REGISTRY_LATEST = `https://registry.npmjs.org/${PACKAGE_NAME}/latest`;
 var CHECK_INTERVAL_MS = 6 * 60 * 60 * 1e3;
 var FETCH_TIMEOUT_MS = 4e3;
 var INSTALL_TIMEOUT_MS = 12e4;
 var LOCK_STALE_MS = 10 * 60 * 1e3;
 var CHILD_ENV = "LACODE_SELFUPDATE_CHILD";
-var STATE_DIR = join3(homedir2(), ".local", "share", "opencode", "lacode");
-var STATE_PATH = join3(STATE_DIR, "selfupdate.json");
-var LOCK_PATH = join3(STATE_DIR, "selfupdate.lock");
+var STATE_DIR = join5(homedir4(), ".local", "share", "opencode", "lacode");
+var STATE_PATH = join5(STATE_DIR, "selfupdate.json");
+var LOCK_PATH = join5(STATE_DIR, "selfupdate.lock");
 function compareSemver(a, b) {
   const parse = (v) => v.split("-")[0].split("+")[0].split(".").map((n) => Number.parseInt(n, 10) || 0);
   const left = parse(a);
@@ -281,13 +491,13 @@ function compareSemver(a, b) {
 }
 function readInstalledVersion(packageRoot, read = (path) => {
   try {
-    return readFileSync2(path, "utf8");
+    return readFileSync5(path, "utf8");
   } catch {
     return void 0;
   }
 }) {
   try {
-    const raw = read(join3(packageRoot, "package.json"));
+    const raw = read(join5(packageRoot, "package.json"));
     if (raw === void 0) return void 0;
     const manifest = JSON.parse(raw);
     if (manifest.name !== PACKAGE_NAME) return void 0;
@@ -298,20 +508,20 @@ function readInstalledVersion(packageRoot, read = (path) => {
 }
 function resolveCacheRoot(packageRoot, exists = (p) => {
   try {
-    return statSync(p).isFile();
+    return statSync3(p).isFile();
   } catch {
     return false;
   }
 }) {
-  const tail = join3("node_modules", "@lawaty", "lacode");
+  const tail = join5("node_modules", "@lawaty", "lacode");
   if (!packageRoot.endsWith(tail)) return void 0;
   const cacheRoot = resolve(packageRoot, "..", "..", "..");
-  if (!exists(join3(cacheRoot, "package.json"))) return void 0;
+  if (!exists(join5(cacheRoot, "package.json"))) return void 0;
   return cacheRoot;
 }
 function resolveOpencodeBin(execPath = process.execPath, env = process.env, exists = (p) => {
   try {
-    return statSync(p).isFile();
+    return statSync3(p).isFile();
   } catch {
     return false;
   }
@@ -319,10 +529,10 @@ function resolveOpencodeBin(execPath = process.execPath, env = process.env, exis
   if (execPath && /(^|[\\/])opencode(\.exe)?$/.test(execPath)) return execPath;
   for (const dir of (env.PATH ?? "").split(":")) {
     if (!dir) continue;
-    const candidate = join3(dir, "opencode");
+    const candidate = join5(dir, "opencode");
     if (exists(candidate)) return candidate;
   }
-  const fallback = join3(homedir2(), ".opencode", "bin", "opencode");
+  const fallback = join5(homedir4(), ".opencode", "bin", "opencode");
   return exists(fallback) ? fallback : void 0;
 }
 async function fetchLatest(fetchImpl = fetch, timeoutMs = FETCH_TIMEOUT_MS) {
@@ -354,11 +564,11 @@ async function refreshCache(opts) {
   const { cacheRoot, bin, latest } = opts;
   const spawnImpl = opts.spawnImpl ?? spawn2;
   const timeoutMs = opts.timeoutMs ?? INSTALL_TIMEOUT_MS;
-  const fresh = join3(cacheRoot, "node_modules", "@lawaty", "lacode");
+  const fresh = join5(cacheRoot, "node_modules", "@lawaty", "lacode");
   const aside = `${cacheRoot}.stale-${Date.now()}`;
   try {
     rmSync(aside, { recursive: true, force: true });
-    renameSync(cacheRoot, aside);
+    renameSync2(cacheRoot, aside);
   } catch (error) {
     return { ok: false, detail: `could not set the old cache aside: ${String(error)}` };
   }
@@ -393,7 +603,7 @@ async function refreshCache(opts) {
     }
   } else {
     try {
-      renameSync(aside, cacheRoot);
+      renameSync2(aside, cacheRoot);
     } catch {
     }
   }
@@ -405,9 +615,9 @@ async function refreshCache(opts) {
 
 // src/lib/version.ts
 import { spawnSync as spawnSync2 } from "node:child_process";
-import { existsSync as existsSync2, readFileSync as readFileSync3, readdirSync, statSync as statSync2 } from "node:fs";
-import { homedir as homedir3 } from "node:os";
-import { isAbsolute, join as join4, relative, sep } from "node:path";
+import { existsSync as existsSync3, readFileSync as readFileSync6, readdirSync as readdirSync2, statSync as statSync4 } from "node:fs";
+import { homedir as homedir5 } from "node:os";
+import { isAbsolute, join as join6, relative, sep } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 
 // src/lib/jsonc.ts
@@ -460,15 +670,15 @@ var parseJsonc = (raw) => {
 // src/lib/version.ts
 var nodeStat = (path) => {
   try {
-    return statSync2(path).mtimeMs;
+    return statSync4(path).mtimeMs;
   } catch {
     return void 0;
   }
 };
-var nodeExists = (path) => existsSync2(path);
+var nodeExists = (path) => existsSync3(path);
 var nodeRead = (path) => {
   try {
-    return readFileSync3(path, "utf8");
+    return readFileSync6(path, "utf8");
   } catch {
     return void 0;
   }
@@ -484,17 +694,17 @@ var realGit = (root) => (args) => {
 };
 var walkSources = (root) => {
   const found = [];
-  const stack = [join4(root, "src")];
+  const stack = [join6(root, "src")];
   while (stack.length > 0) {
     const dir = stack.pop();
     let names;
     try {
-      names = readdirSync(dir);
+      names = readdirSync2(dir);
     } catch {
       continue;
     }
     for (const name of names) {
-      const full = join4(dir, name);
+      const full = join6(dir, name);
       if (name.endsWith(".ts")) found.push(full);
       else if (name === "plugins" || name === "lib" || name === "tunnel") stack.push(full);
     }
@@ -502,8 +712,8 @@ var walkSources = (root) => {
   return found;
 };
 var checkDist = (root, deps) => {
-  if (!deps.exists(join4(root, "dist"))) return { dist: "unknown" };
-  const built = deps.stat(join4(root, "dist", "index.js"));
+  if (!deps.exists(join6(root, "dist"))) return { dist: "unknown" };
+  const built = deps.stat(join6(root, "dist", "index.js"));
   if (built === void 0) return { dist: "unknown" };
   const sources = deps.listSources(root).map((file) => ({ file, mtime: deps.stat(file) }));
   const newer = sources.filter((s) => s.mtime !== void 0 && s.mtime > built).map((s) => relative(root, s.file));
@@ -544,13 +754,13 @@ var resolvesHere = (specifier, packageRoot) => {
 };
 function readVersionReport(deps = {}) {
   const packageRoot = deps.packageRoot ?? PACKAGE_ROOT;
-  const home = deps.home ?? homedir3();
+  const home = deps.home ?? homedir5();
   const git = deps.git ?? realGit(packageRoot);
   const readFile = deps.readFile ?? nodeRead;
   const stat = deps.stat ?? nodeStat;
   const exists = deps.exists ?? nodeExists;
   const listSources = deps.listSources ?? walkSources;
-  const isCheckout = exists(join4(packageRoot, ".git"));
+  const isCheckout = exists(join6(packageRoot, ".git"));
   const report = {
     version: readInstalledVersion(packageRoot, readFile),
     root: packageRoot,
@@ -563,11 +773,11 @@ function readVersionReport(deps = {}) {
   const dist = checkDist(packageRoot, { stat, exists, listSources });
   report.dist = dist.dist;
   if (dist.stale) report.staleSources = dist.stale;
-  const configPath = [join4(home, ".config", "opencode", "opencode.jsonc"), join4(home, ".config", "opencode", "opencode.json")].find(
+  const configPath = [join6(home, ".config", "opencode", "opencode.jsonc"), join6(home, ".config", "opencode", "opencode.json")].find(
     (candidate) => exists(candidate)
   );
   if (!configPath) {
-    report.note = `No opencode config found under ${join4(home, ".config", "opencode")}; nothing to compare this copy against.`;
+    report.note = `No opencode config found under ${join6(home, ".config", "opencode")}; nothing to compare this copy against.`;
     return report;
   }
   report.configPath = configPath;
@@ -639,6 +849,8 @@ var USAGE = `lacode \u2014 portable notifications and remote exec for LaCode
       permission | error; an omitted or unrecognised SOUND is none, so a
       four-argument caller simply gets no sound. Fire-and-forget: always
       exits 0.
+      With LACODE_REQUEST_ID set, the notification carries buttons and the
+      name of the clicked one is printed on stdout.
 
   lacode forward HOST -- COMMAND [ARG...]
       Run COMMAND on HOST over ssh. Exits with the remote's status.
@@ -666,7 +878,9 @@ Environment:
   OC_LOCAL_USER        desktop user the tunnel authenticates as
   OC_TUNNEL_PORT       reverse-forward listener port (default 10022)
   OC_NOTIFY_KEY        dedicated key (default ~/.ssh/lacode_notify)
-  OC_CONNECT_TIMEOUT_MS / OC_SSH_TIMEOUT_MS`;
+  OC_CONNECT_TIMEOUT_MS / OC_SSH_TIMEOUT_MS
+  LACODE_REQUEST_ID    makes a notification actionable: it carries buttons, and
+                        the clicked one is printed on stdout`;
 var argv = process.argv.slice(2);
 var command = argv.shift();
 switch (command) {
@@ -684,8 +898,16 @@ switch (command) {
       console.error(USAGE);
       process.exit(2);
     }
-    const result = notify({ title: rawTitle, message, urgency, icon, sound: normalizeSound(sound) });
+    const result = notify({
+      title: rawTitle,
+      message,
+      urgency,
+      icon,
+      sound: normalizeSound(sound),
+      requestID: process.env.LACODE_REQUEST_ID
+    });
     if (!result.ok) console.error(`lacode: notification not delivered via ${result.transport}: ${result.detail ?? "unknown reason"}`);
+    if (result.action) console.log(result.action);
     process.exit(0);
     break;
   }
@@ -765,6 +987,7 @@ ${report.note}`);
     const request = parsePayload(process.env.SSH_ORIGINAL_COMMAND ?? "");
     const result = sendLocal(request);
     if (!result.ok) console.error(`lacode receive: ${result.detail ?? "not delivered"}`);
+    if (result.action) console.log(result.action);
     process.exit(result.ok ? 0 : 1);
     break;
   }
@@ -776,7 +999,7 @@ ${report.note}`);
     }
     const { user, host, key } = resolveTunnel();
     const pub = `${key}.pub`;
-    if (!existsSync3(key)) {
+    if (!existsSync4(key)) {
       const gen = spawnSync3("ssh-keygen", ["-t", "ed25519", "-N", "", "-C", "lacode-notify", "-f", key], { stdio: ["ignore", "ignore", "inherit"] });
       if (gen.status !== 0) {
         console.error("lacode tunnel setup: ssh-keygen failed; create the key by hand and re-run.");
@@ -784,7 +1007,7 @@ ${report.note}`);
       }
       console.log(`Generated ${key}`);
     }
-    const pubkey = existsSync3(pub) ? readFileSync4(pub, "utf8").trim() : "(public key missing)";
+    const pubkey = existsSync4(pub) ? readFileSync7(pub, "utf8").trim() : "(public key missing)";
     const self = process.argv[1] ?? "lacode";
     console.log("\nOn the REMOTE host (where opencode runs), export:");
     console.log(`  OC_LOCAL_USER=${user || "<desktop-user>"}`);