@lawaty/lacode 0.0.0-stage → 0.1.1

package/dist/lacode.js

@@ -0,0 +1,254 @@
+#!/usr/bin/env node
+
+// bin/lacode
+import { fileURLToPath } from "node:url";
+
+// 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 = (command2, args, timeout) => {
+  try {
+    const result = spawnSync(command2, 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 = (command2) => {
+  try {
+    return spawnSync("sh", ["-c", `command -v ${command2}`], { 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, argv2, 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, "--", ...argv2], 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")
+  };
+}
+
+// bin/lacode
+if (!process.features?.typescript) {
+  if (process.env.LACODE_STRIP_TYPECHECKED === "1") {
+    console.error("lacode: this node cannot load TypeScript sources; node >= 22.18 is required.");
+    process.exit(1);
+  }
+  const { spawnSync: spawnSync2 } = await import("node:child_process");
+  const result = spawnSync2(
+    process.execPath,
+    ["--experimental-strip-types", "--no-warnings", fileURLToPath(import.meta.url), ...process.argv.slice(2)],
+    { stdio: "inherit", env: { ...process.env, LACODE_STRIP_TYPECHECKED: "1" } }
+  );
+  process.exit(result.status ?? 1);
+}
+var USAGE = `lacode \u2014 portable notifications and remote exec for LaCode
+
+  lacode notify TITLE [MESSAGE] [URGENCY] [ICON]
+      Send one desktop notification. Local host: straight to the desktop
+      session. Over ssh: handed to the desktop through the reverse forward.
+      URGENCY is low | normal | critical. Fire-and-forget: always exits 0.
+
+  lacode forward HOST -- COMMAND [ARG...]
+      Run COMMAND on HOST over ssh. Exits with the remote's status.
+
+  lacode doctor
+      Print what the environment resolves to. Diagnostics only.
+
+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`;
+var argv = process.argv.slice(2);
+var command = argv.shift();
+switch (command) {
+  case void 0:
+  case "--help":
+  case "-h":
+  case "help":
+    console.log(USAGE);
+    process.exit(0);
+    break;
+  case "notify": {
+    const [rawTitle, message, urgency, icon] = argv;
+    if (!rawTitle) {
+      console.error("lacode notify: TITLE is required");
+      console.error(USAGE);
+      process.exit(2);
+    }
+    const result = notify({ title: rawTitle, message, urgency, icon });
+    if (!result.ok) console.error(`lacode: notification not delivered via ${result.transport}: ${result.detail ?? "unknown reason"}`);
+    process.exit(0);
+    break;
+  }
+  case "forward": {
+    const host = argv.shift();
+    const separator = argv.indexOf("--");
+    if (!host || separator < 0 || separator === argv.length - 1) {
+      console.error("lacode forward: usage: lacode forward HOST -- COMMAND [ARG...]");
+      process.exit(2);
+    }
+    const command2 = argv.slice(separator + 1);
+    const result = forward(host, command2);
+    if (result.stdout) process.stdout.write(result.stdout);
+    if (!result.ok) console.error(`lacode: ${host}: ${result.detail ?? "remote command failed"}`);
+    process.exit(result.ok ? 0 : 1);
+    break;
+  }
+  case "doctor": {
+    const info = describe();
+    for (const [key, value] of Object.entries(info)) console.log(`${key.padEnd(11)} ${String(value)}`);
+    if (info.running.startsWith("remote")) {
+      if (info.user === "(unset)") console.log("\nOC_LOCAL_USER is unset: the hop cannot name the desktop user, and guessing with `id -un` is wrong on most remote accounts.");
+      console.log("Set OC_LOCAL_USER, OC_TUNNEL_PORT and OC_NOTIFY_KEY, or point OC_NOTIFY_HELPER at a helper that knows them.");
+    } else if (info.channel === "none") {
+      console.log("\nNo local notification channel: `lacode notify` on this machine has nothing to deliver with, and every send will be reported as failed rather than shown.");
+    }
+    process.exit(0);
+    break;
+  }
+  default:
+    console.error(`lacode: unknown command ${JSON.stringify(safeTitle(command))}`);
+    console.error(USAGE);
+    process.exit(2);
+}