@colinagent/hulala-bot 0.0.0-stage → 0.3.2

package/dist/index.mjs

@@ -0,0 +1,359 @@
+// src/init.ts
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { join as join2 } from "node:path";
+import { createInterface } from "node:readline/promises";
+import { stdin, stdout } from "node:process";
+
+// src/config.ts
+import { execFile } from "node:child_process";
+import { homedir } from "node:os";
+import { join, resolve } from "node:path";
+import { promisify } from "node:util";
+
+// src/telegram/proxy.ts
+import http from "node:http";
+import https from "node:https";
+import tls from "node:tls";
+function normalizeProxy(value) {
+  let url;
+  try {
+    url = new URL(value);
+  } catch {
+    throw new Error(`proxy must be an http:// or https:// URL, not ${JSON.stringify(value)}`);
+  }
+  if (url.protocol !== "http:" && url.protocol !== "https:") {
+    throw new Error(`proxy must be an http:// or https:// URL, not ${JSON.stringify(value)}`);
+  }
+  if (url.hostname === "") {
+    throw new Error(`proxy has no host: ${JSON.stringify(value)}`);
+  }
+  return url.toString();
+}
+function tunnel(proxy, host, port, secure, done) {
+  const proxySecure = proxy.protocol === "https:";
+  const authorization = proxy.username === "" ? undefined : `Basic ${Buffer.from(`${decodeURIComponent(proxy.username)}:${decodeURIComponent(proxy.password)}`).toString("base64")}`;
+  const request = (proxySecure ? https : http).request({
+    host: proxy.hostname,
+    port: Number(proxy.port || (proxySecure ? 443 : 80)),
+    method: "CONNECT",
+    path: `${host}:${String(port)}`,
+    headers: {
+      host: `${host}:${String(port)}`,
+      ...authorization === undefined ? {} : { "proxy-authorization": authorization }
+    },
+    timeout: 20000
+  });
+  request.once("connect", (response, socket) => {
+    if (response.statusCode !== 200) {
+      socket.destroy();
+      const detail = response.statusMessage === undefined ? "" : ` ${response.statusMessage}`;
+      done(new Error(`proxy CONNECT failed: ${String(response.statusCode)}${detail}`));
+      return;
+    }
+    if (!secure) {
+      done(null, socket);
+      return;
+    }
+    const wrapped = tls.connect({ socket, servername: host });
+    wrapped.once("secureConnect", () => done(null, wrapped));
+    wrapped.once("error", (error) => done(error));
+  });
+  request.once("error", (error) => done(error));
+  request.once("timeout", () => request.destroy(new Error("proxy CONNECT timed out")));
+  request.end();
+}
+function connect(proxy, options, secure, callback) {
+  const host = options.host ?? "localhost";
+  const port = Number(options.port ?? (secure ? 443 : 80));
+  tunnel(proxy, host, port, secure, (error, socket) => {
+    if (callback === undefined)
+      return;
+    if (socket === undefined)
+      callback(error ?? new Error("no socket from the proxy"), undefined);
+    else
+      callback(error, socket);
+  });
+  return;
+}
+
+class HttpTunnelAgent extends http.Agent {
+  #proxy;
+  constructor(proxy) {
+    super({ keepAlive: false });
+    this.#proxy = proxy;
+  }
+  createConnection(options, callback) {
+    return connect(this.#proxy, options, false, callback);
+  }
+}
+
+class HttpsTunnelAgent extends https.Agent {
+  #proxy;
+  constructor(proxy) {
+    super({ keepAlive: false });
+    this.#proxy = proxy;
+  }
+  createConnection(options, callback) {
+    return connect(this.#proxy, options, true, callback);
+  }
+}
+
+// src/config.ts
+var run = promisify(execFile);
+function hulalaHome(env = process.env) {
+  return env.HULALA_HOME ?? join(homedir(), ".hulala");
+}
+function botStateDir(env = process.env) {
+  const dshHome = env.DSH_HOME;
+  if (dshHome !== undefined && dshHome !== "")
+    return join(dshHome, "config", "hulala-bot");
+  return join(hulalaHome(env), "config", "hulala-bot");
+}
+
+// src/init.ts
+function parse(argv) {
+  const telegram = {};
+  const lark = {};
+  let defaultCwd;
+  let interactive = stdin.isTTY;
+  let touched = false;
+  for (let index = 0;index < argv.length; index += 1) {
+    const argument = argv[index];
+    const value = () => {
+      const next = argv[index + 1];
+      if (next === undefined)
+        throw new Error(`${argument} needs a value`);
+      index += 1;
+      return next;
+    };
+    const ids = () => value().split(",").map((entry) => entry.trim()).filter((entry) => entry !== "");
+    if (argument === "--telegram-token-ref") {
+      telegram.tokenRef = value();
+      touched = true;
+    } else if (argument === "--telegram-token-env") {
+      telegram.tokenEnv = value();
+      touched = true;
+    } else if (argument === "--telegram-allowed-user" || argument === "--telegram-allowed-users") {
+      for (const entry of ids()) {
+        const id = Number(entry);
+        if (!Number.isSafeInteger(id) || id <= 0)
+          throw new Error(`not a Telegram user id: ${entry}`);
+        telegram.allowedUsers = [...telegram.allowedUsers ?? [], id];
+      }
+      touched = true;
+    } else if (argument === "--telegram-allowed-chat" || argument === "--telegram-allowed-chats") {
+      for (const entry of ids()) {
+        const id = Number(entry);
+        if (!Number.isSafeInteger(id))
+          throw new Error(`not a Telegram chat id: ${entry}`);
+        telegram.allowedChats = [...telegram.allowedChats ?? [], id];
+      }
+      touched = true;
+    } else if (argument === "--proxy") {
+      telegram.proxy = normalizeProxy(value());
+      touched = true;
+    } else if (argument === "--parse-mode") {
+      const mode = value();
+      if (mode !== "markdown" && mode !== "plain")
+        throw new Error("--parse-mode is markdown or plain");
+      telegram.parseMode = mode;
+      touched = true;
+    } else if (argument === "--lark-app-id") {
+      lark.appId = value();
+      touched = true;
+    } else if (argument === "--lark-app-secret-ref") {
+      lark.appSecretRef = value();
+      touched = true;
+    } else if (argument === "--lark-app-secret-env") {
+      lark.appSecretEnv = value();
+      touched = true;
+    } else if (argument === "--lark-allowed-user" || argument === "--lark-allowed-users") {
+      lark.allowedUsers = [...lark.allowedUsers ?? [], ...ids()];
+      touched = true;
+    } else if (argument === "--lark-allowed-chat" || argument === "--lark-allowed-chats") {
+      lark.allowedChats = [...lark.allowedChats ?? [], ...ids()];
+      touched = true;
+    } else if (argument === "--lark-domain") {
+      const domain = value();
+      if (domain !== "feishu" && domain !== "lark")
+        throw new Error("--lark-domain is feishu or lark");
+      lark.domain = domain;
+      touched = true;
+    } else if (argument === "--default-cwd") {
+      defaultCwd = value();
+      touched = true;
+    } else if (argument === "--no-input")
+      interactive = false;
+    else if (argument === "--init")
+      continue;
+    else
+      throw new Error(`unknown option ${argument}`);
+  }
+  const hasTelegram = Object.keys(telegram).length > 0;
+  const hasLark = Object.keys(lark).length > 0;
+  return {
+    interactive: interactive && !touched,
+    options: {
+      ...defaultCwd === undefined ? {} : { defaultCwd },
+      ...hasTelegram ? { telegram } : {},
+      ...hasLark ? { lark } : {}
+    }
+  };
+}
+async function ask(rl, question) {
+  return (await rl.question(question)).trim();
+}
+async function prompt() {
+  const rl = createInterface({ input: stdin, output: stdout });
+  try {
+    const tokenRef = await ask(rl, "Telegram keychain reference (blank to skip): ");
+    let telegram;
+    if (tokenRef !== "") {
+      const allowedUsers = (await ask(rl, "Allowed Telegram user ids, comma separated: ")).split(",").map((entry) => Number(entry.trim())).filter((id) => Number.isSafeInteger(id) && id > 0);
+      telegram = {
+        tokenRef: tokenRef === "" ? "telegram/bot-token" : tokenRef,
+        allowedUsers,
+        allowedChats: []
+      };
+    }
+    const appId = await ask(rl, "Lark app id (cli_…), blank to skip: ");
+    let lark;
+    if (appId !== "") {
+      const appSecretRef = await ask(rl, "Lark app-secret keychain reference [lark/app-secret]: ");
+      const allowedUsers = (await ask(rl, "Allowed Lark open ids (ou_…), comma separated: ")).split(",").map((entry) => entry.trim()).filter((entry) => entry !== "");
+      lark = {
+        appId,
+        appSecretRef: appSecretRef === "" ? "lark/app-secret" : appSecretRef,
+        allowedUsers,
+        allowedChats: [],
+        domain: "feishu"
+      };
+    }
+    const cwdAnswer = await ask(rl, "Directory the first message mounts [~]: ");
+    return {
+      ...cwdAnswer === "" ? {} : { defaultCwd: cwdAnswer },
+      ...telegram === undefined ? {} : { telegram },
+      ...lark === undefined ? {} : { lark }
+    };
+  } finally {
+    rl.close();
+  }
+}
+function hasAllowlist(section) {
+  const users = Array.isArray(section.allowedUsers) ? section.allowedUsers : [];
+  const chats = Array.isArray(section.allowedChats) ? section.allowedChats : [];
+  return users.length > 0 || chats.length > 0;
+}
+function mergeSection(previous, next) {
+  const { allowedUsers, allowedChats, ...rest } = next;
+  return {
+    ...previous,
+    ...Object.fromEntries(Object.entries(rest).filter(([, value]) => value !== undefined)),
+    ...Array.isArray(allowedUsers) && allowedUsers.length > 0 ? { allowedUsers } : {},
+    ...Array.isArray(allowedChats) && allowedChats.length > 0 ? { allowedChats } : {}
+  };
+}
+function validateTelegram(section) {
+  if (typeof section.tokenRef !== "string" || section.tokenRef === "") {
+    throw new Error("--telegram-token-ref is required for the Telegram channel");
+  }
+  if (!hasAllowlist(section)) {
+    throw new Error("refusing to write an empty Telegram allowlist: pass --telegram-allowed-user <id>");
+  }
+}
+function validateLark(section) {
+  if (typeof section.appId !== "string" || !/^cli_[0-9a-fA-F]{16}$/.test(section.appId)) {
+    throw new Error("--lark-app-id must look like cli_<16 hex>");
+  }
+  if (typeof section.appSecretRef !== "string" || section.appSecretRef === "") {
+    throw new Error("--lark-app-secret-ref is required for the Lark channel");
+  }
+  if (!hasAllowlist(section)) {
+    throw new Error("refusing to write an empty Lark allowlist: pass --lark-allowed-user <ou_…>");
+  }
+}
+async function runInit(argv, env = process.env) {
+  const parsed = parse(argv);
+  const options = parsed.interactive ? await prompt() : parsed.options;
+  const stateDir = botStateDir(env);
+  const file = join2(stateDir, "config.json");
+  let existing = {};
+  try {
+    existing = JSON.parse(await readFile(file, "utf8"));
+  } catch {}
+  const document = { ...existing };
+  if (options.defaultCwd !== undefined)
+    document.defaultCwd = options.defaultCwd;
+  if (options.telegram !== undefined) {
+    document.telegram = mergeSection(existing.telegram, options.telegram);
+  }
+  if (options.lark !== undefined) {
+    document.lark = mergeSection(existing.lark, options.lark);
+  }
+  if (document.telegram === undefined && document.lark === undefined) {
+    throw new Error("nothing to configure: pass --telegram-token-ref … or --lark-app-id … (see --help)");
+  }
+  if (document.telegram !== undefined)
+    validateTelegram(document.telegram);
+  if (document.lark !== undefined)
+    validateLark(document.lark);
+  if (document.defaultCwd === undefined)
+    document.defaultCwd = "~";
+  await mkdir(stateDir, { recursive: true, mode: 448 });
+  await writeFile(file, JSON.stringify(document, null, 2) + `
+`, { mode: 384 });
+  console.log(`wrote ${file}`);
+  const refs = [options.telegram?.tokenRef, options.lark?.appSecretRef].filter((ref) => typeof ref === "string" && ref !== "");
+  console.log("store the credentials in the keychain, never in this file:");
+  for (const ref of refs)
+    printKeychain(ref);
+  console.log("restart the Host (or the bot process) to pick it up");
+  return 0;
+}
+function printKeychain(ref) {
+  const [service = "telegram", account = "bot-token"] = ref.split("/");
+  if (process.platform === "darwin") {
+    console.log(`  security add-generic-password -U -s ${service} -a ${account} -w '…'`);
+  } else {
+    console.log(`  secret-tool store --label '${service}' service ${service} account ${account}`);
+  }
+}
+
+// src/index.ts
+var arguments_ = process.argv.slice(2);
+if (arguments_.includes("--help") || arguments_.length === 0) {
+  console.log([
+    "hulala-bot — your agent on Telegram and Lark",
+    "",
+    "This package runs inside a Host as a plugin. The only command here writes",
+    "the configuration that plugin needs:",
+    "",
+    "  hulala-bot --init --no-input \\",
+    "    --telegram-token-ref telegram/bot-token --telegram-allowed-user <id>",
+    "  hulala-bot --init --no-input \\",
+    "    --lark-app-id cli_<16 hex> --lark-app-secret-ref lark/app-secret \\",
+    "    --lark-allowed-user ou_<id> [--lark-domain feishu|lark]",
+    "",
+    "Both channels may be configured in one file; --init rewrites only the",
+    "channel whose flags it was given. Telegram options: --proxy, --parse-mode.",
+    "Global options: --default-cwd <path>.",
+    "",
+    "Install it with one of:",
+    "  dsh plugin --profile tui add @colinagent/hulala-bot",
+    "  hulala plugin --profile tui add @colinagent/hulala-bot",
+    "  hulala install bot            # the same thing, on a Hulala install"
+  ].join(`
+`));
+  process.exit(0);
+}
+if (arguments_.includes("--init")) {
+  try {
+    process.exit(await runInit(arguments_.slice(arguments_.indexOf("--init") + 1)));
+  } catch (error) {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+}
+console.error(`unknown arguments: ${arguments_.join(" ")}
+try --help`);
+process.exit(1);